diff --git a/.gitattributes b/.gitattributes index 3f47ae5..80adb5e 100644 --- a/.gitattributes +++ b/.gitattributes @@ -11,6 +11,9 @@ evidence/tm-port-v1/** -text reference/** -text lean/upstream/OAI/** -text lean/comparator/ComparatorChallenges/** -text +lean/snaky/OAI/** linguist-vendored=true -text +lean/snaky/FiniteCards/** linguist-generated=true +evidence/snaky-finite-v1/certificate.txt -text lean/CertificateData.lean linguist-generated=true space/vendor/cytoscape-3.34.4.min.js -text space/vendor/cytoscape-LICENSE.txt -text diff --git a/.github/workflows/verify.yml b/.github/workflows/verify.yml index 0d8792a..f556556 100644 --- a/.github/workflows/verify.yml +++ b/.github/workflows/verify.yml @@ -95,6 +95,17 @@ jobs: python scripts/build_five_object_chart.py --check python lean/five_object/generate_certificates.py --check python -m unittest discover -s scripts -p 'test_five_object*.py' -v + - name: Check exact Snaky certificate and recorded finite-board binding + run: | + python scripts/check_snaky.py replay + python scripts/snaky_proof.py replay + python scripts/build_snaky_chart.py --check + python lean/snaky/generate_finite_cards.py --check + python scripts/build_snaky_play.py --check + python scripts/check_snaky_play.py + python scripts/build_snaky_presentation.py --check + python -m unittest discover -s scripts -p 'test_snaky*.py' -v + node scripts/check_snaky_play_ui.cjs - name: Preserve reproduction evidence if: always() uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4 @@ -106,7 +117,10 @@ jobs: lean: name: Concrete Lean certificates runs-on: ubuntu-latest - timeout-minutes: 20 + timeout-minutes: 210 # Build 60m + kernel 120m + setup, controls, other proofs and artifact upload. + env: + LEAN_NUM_THREADS: '1' + MATHLIB_NO_CACHE_ON_UPDATE: '1' steps: - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4 - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5 @@ -132,6 +146,22 @@ jobs: name: five-object-proof path: runs/five-object-proof/ retention-days: 90 + - name: Prove Snaky on both finite boards and reject mismatched claims + run: | + mkdir -p runs + { nproc; free -h; df -h .; } | tee runs/snaky-host-resources.txt + /usr/bin/time -v -o runs/snaky-host-timing.txt python scripts/snaky_proof.py run --out runs/snaky-proof + python scripts/snaky_proof.py replay --out runs/snaky-proof + - name: Preserve Snaky finite-board proof and binding evidence + if: always() + uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4 + with: + name: snaky-finite-proof + path: | + runs/snaky-proof/ + runs/snaky-host-resources.txt + runs/snaky-host-timing.txt + retention-days: 90 grouping-checker: name: Generic grouping checker and native agreement diff --git a/CHANGELOG.md b/CHANGELOG.md index 9df2667..0ea1728 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,15 @@ ## Unreleased +- Finite-board Snaky formalization for the exact 251-cell envelope and its + containing 17 by 17 square, with fresh-move accounting, a nonvacuous continuing + case, complete local kernel replay, axiom audit and seven changed-claim controls. + Independent reconstruction of all 728 cards, exact atlas binding, and a readable + branch viewer with one separately checked execution and immutable evidence links. + The paper already states the finite-board result; no stronger move bound is claimed. + +- Prominent OpenAI math source-and-scope banner at the top of the public atlas. + - Exact five-object comparison: two eight-congruence families with isomorphic inclusion orders and respective minimum unary rule counts of three and two. Standalone Lean classification and lower bounds, exact theorem bindings, diff --git a/README.md b/README.md index 8d66719..6ca02ae 100644 --- a/README.md +++ b/README.md @@ -33,6 +33,7 @@ classifies all representable grouping families through four objects, yielding **[Agent repair experiment](docs/REPAIR_BENCHMARK.md)** · **[TM translation checks](docs/TM_TRANSLATION_CHECKS.md)** · **[Compare Turing examples](docs/TM_ATLAS.md)** · +**[Snaky on finite boards](docs/SNAKY_FINITE_BOARD.md)** · **[Changelog](CHANGELOG.md)** · **[Support](SUPPORT.md)** | Candidate colorings | Full witnesses | Vertex classes | Saved examples | @@ -120,10 +121,18 @@ python scripts/five_object_proof.py run --out runs/five-object-fresh python scripts/query_context.py explain context:family-206:five-object:operation-minima:v1 ``` +The [Snaky walkthrough](docs/SNAKY_FINITE_BOARD.md) formalizes the paper's +21-Maker-claim guarantee on its exact 251-cell envelope and containing 17 by 17 +square. The Lean proof, kernel replay, axiom audit and seven changed-claim +rejections pass, alongside an independent certificate audit. Follow +[one complete example play](docs/SNAKY_PLAY.md) to see each move, a surviving +continuation, the remaining bound and its evidence. The example's eight-claim +win is distinct from the theorem's guarantee against every legal reply. + Read the [query contract](docs/ATLAS_QUERY.md), [agent retrieval evaluation](docs/ATLAS_QUERY_EVALUATION.md), and [infrastructure direction](docs/INFRASTRUCTURE.md). These interfaces are an -early foundation for reliable evidence retrieval in a bounded mathematical domain. +early foundation for reliable evidence retrieval across these selected mathematical examples. ## Propose a grouping, get a checked counterexample diff --git a/WORK_LOG.md b/WORK_LOG.md index 86d21bd..f1e3589 100644 --- a/WORK_LOG.md +++ b/WORK_LOG.md @@ -1,5 +1,285 @@ # Finite graph search work log +## 2026-10-19 — Fix a Linux process-disappearance race in the cleanup test + +The push run for `4102fc1ec98a8516182270765e730a04ec626295` failed its +Python 3.10 job while the corresponding PR job passed. The +[job log](https://github.com/Maverick0351a/finite-congruence-checks/actions/runs/39316093274/job/118277828681) +records `ProcessLookupError: [Errno 3] No such process` during a read of the +terminated child's `/proc` status. The test already handled a missing file; +it now also handles the process disappearing after the file was opened. +Other read errors still propagate, and a live child still fails the deadline. + +Two deterministic regression tests cover both disappearance errors and retain +the permission-error/live-process failures. All 14 runner tests passed on +WSL/Linux in 10.751 seconds; Windows passed its 11 applicable tests with three +existing platform skips. Independent review approved the narrow test-only +repair and ran the two added controls. The test file is outside the proof's +194-source manifest and presentation's 219-input anchor; the actual proof, +runner and saved receipt are unchanged. All 13 immutable presentation links +also resolved and matched their anchored files after push. Fresh CI and +deployment remain pending. Benchmarks and training remain paused. + +## 2026-10-19 — Revised Snaky replay completes with exact module inventory + +Committed source `c3af350005f413554aea03db8cbf2c4c2d09e31b` completed all 12 +proof stages from 19:34:58 to 19:59:10 UTC, using the existing WSL dependency +and build cache. Kernel replay took 1,303.713 seconds and exited zero. The 179 +verbose module names match the independently reconstructed import closure +exactly, with no missing, duplicate or extra modules. All 19 declaration axiom +reports pass the existing policy. All seven altered bindings exited 1 with +the expected mathematical rejection diagnostics. No timeout or setup failure +is counted as a rejection. + +Independent review matched all 194 source hashes to both the frozen commit and +the executing native checkout, verified all 20 artifact hashes, and replayed +the completed receipt. The 21 receipt files were copied without rewriting +their contents into the evidence directory, where saved replay also passes. +The full run took 1,451.334 seconds; its cached build took 11.8 seconds. These +measurements do not establish fresh hosted performance or isolate a speedup +from the discovery change. The receipt is committed at +`3bd96caa445c459371128e882fe420479084924e`; the renewed presentation binds all +219 inputs to that commit. Independent review passed all 88 focused Linux +tests in 105.372 seconds without skips and approved the receipt and anchor. +Presentation freshness and full renderer checks pass; the refreshed browser +page displays the new receipt hash and immutable references. Fresh hosted CI, +HTTP link checks and deployment remain release gates. Earlier runs retain +their original outcomes. Benchmarks and training remain paused. + +## 2026-10-19 — Hosted Snaky kernel replay exceeds its stage allowance + +The [PR run](https://github.com/Maverick0351a/finite-congruence-checks/actions/runs/39280967879) +and [push run](https://github.com/Maverick0351a/finite-congruence-checks/actions/runs/39280963678) +of PR #18 head `22fdfd061fc69c29553297ecb073c7200d3b8912` +completed compilation and the axiom-report command. The PR run's build took +1,980.924 seconds; the push run took 2,147.996 seconds. Independent inspection +of each downloaded axiom log passes all 19 declaration reports. Both kernel +stages then reached the 2,400-second limit. Their receipts correctly record +`failure_kind=timeout`; exit -9 resulted from the runner's cleanup. No negative +controls ran, and neither receipt is accepted as a completed verification. + +The repair assigns kernel replay a 7,200-second bound, keeps compilation at +3,600 seconds and the remaining stages at 2,400 seconds, and gives the job +210 minutes for both long stages plus other proofs, setup, controls and uploads. +Host capacity and GNU time measurements will be retained separately from proof +artifacts. The complete module list, mathematical sources, axiom policy and +negative controls remain required. This is not evidence of an out-of-memory +failure or a mathematical counterexample. The modified runner requires a new +actual receipt and reviewed presentation anchor; those gates are pending. +Inspection of the pinned Lean checker also found a full search-path scan per +selector. Nine selectors match exactly the same 179 modules in both the source +tree and local compiled cache, avoiding 170 redundant scans. The runner now +requests verbose output and validates its complete module inventory alongside +exit zero in both actual execution and saved replay. An announced module is +not reported as complete before the process succeeds. The speed effect remains +unmeasured; the older empty kernel logs cannot attribute the timeout's cost. +Model benchmarks, reserved tasks and training remain paused. + +## 2026-10-19 — Renewed Snaky verification passes with complete stage records + +The revised runner completed all 12 actual proof stages from committed source +`5fa1b81550a1841a3b2b91a0c48a7cc5b4380448`, using the existing WSL build cache. +The run lasted from 15:14:11 to 15:45:45 UTC. Kernel replay passed in 1,733.691 +seconds; the 179 local modules, 19 allowed-axiom reports and seven deliberately +changed claims remain covered. Each rejection completed with exit code 1. +The receipt replays successfully and is committed at +`f516abb4e98696cc61003de55518961245416a40`. Presentation generation now binds +its 219 inputs to that commit. The earlier successful receipt is preserved in +Git history. Independent review checked all 194 source hashes against the source +commit, passed all 84 focused tests on Linux without skips, and approved the +renewed receipt and presentation. Generation freshness and the full renderer +check pass. Hosted reproduction and HTTP checks for the new evidence anchor +remain pending before merge and deployment. + +## 2026-10-19 — Fresh hosted Snaky compilation exceeded its stage allowance + +PR #18 run `39267847727` passed eight of nine required jobs. The Concrete Lean +certificates job reproduced the five-object proof, then the Snaky compilation +hit its 2,400-second stage limit. The failed Snaky step ran from 14:26:00 to +15:07:55 UTC; version and dependency setup succeeded before compilation began +at 14:27:55. The initial disk check reported 83 GB free. This is a compilation +timeout, not a mathematical counterexample or a completed hosted proof run. + +The downloaded failure receipt contains only version/dependency stages because +the original runner buffered compiler output and did not save a timed-out +stage. The repair extends compilation to 3,600 seconds, retains 2,400 seconds +for other stages, and gives the CI job 120 minutes. It will preserve stage logs +and checkpoint running/failed stage information. All 179 kernel modules, 19 +axiom reports and seven mathematical rejection controls remain required. +The changed runner requires a new actual proof receipt and updated source +anchor before publication. The earlier successful local receipt remains in +Git history; it is not relabeled as a fresh hosted run. Benchmark/model work +remains paused. + +## 2026-10-19 — Snaky proof and complete branch viewer pass local review + +The committed-source proof run completed all 12 stages. Lean built both finite +board theorems, audited 19 declarations against the allowed-axiom policy, +replayed 179 local modules, and rejected all seven deliberately changed claims. +The 194 proof input hashes still match. The actual receipt is saved under +`evidence/snaky-finite-v1/proof/`; this run reused the dependency/build cache. +Kernel replay took 1,631.946 seconds; the full run took about 30 minutes. + +All 73 focused tests pass with the real proof receipt and generated presentation. +The exporter binds 219 inputs to source commit +`767294d63b5cf0c3a4c664aa62c46d8dcbe3b65a`. Its JSON download, offline browser +script, query record and evidence references agree. The renderer check initially +compared separately decoded objects by identity; it now checks object identity +within the packet and normalized content across the JSON/JS boundary. The full +renderer check passes all eight states and the complete six-cell winning target. + +Actual browser review caught and fixed a mobile grid overflow. The board now +scrolls within a focusable panel; the page and expanded eight-row move table fit +375/390-pixel layouts without horizontal page overflow. Enter, Space and End +operate the controls, and ArrowRight scrolls the board. Desktop and mobile +screenshots are retained in `runs/snaky-ui-review/`; no browser warning or error +was observed. Independent review covers the mathematical explanation, generated +records, rejection controls and final presentation changes. + +An isolated replay of the highest card module passed in 168.195 seconds with +13.82 GiB peak RSS, close to the bulk run's observed 14.30 GiB peak. Splitting the +replay into single modules would not remove this dominant memory requirement. +The existing runner and successful receipt remain unchanged. Hosted CI has a +90-minute limit and is the remaining fresh-checkout resource/reproduction gate. +No model benchmark, reserved task or training run was started. + +## 2026-10-19 — Snaky presentation prepared behind the proof gate + +The page, offline-script exporter and download share one generated packet. +Export requires the actual proof receipt, supported exact claim, independently +replayed example and immutable Git bytes for every linked input. Five anchor +controls pass, including a rehashed local mutation that disagrees with Git. +The explicit development renderer check passes all eight ownership states, +continuation outlines, counters, links and the final six-cell target. Browser +layout and keyboard review still await the real exported packet. + +The ongoing bulk kernel replay has reached more than 25 minutes and observed +roughly 14.3 GiB peak RSS. This is a measurement of this local run, not a hosted +resource guarantee. The required Concrete Lean certificates job now allows +90 minutes; its job name and branch-protection requirement are unchanged. +The saved source runner and its current replay have not been changed. + +## 2026-10-19 — OpenAI corpus highlight published + +PR #17 adds a prominent source-and-scope banner above the atlas introduction, +with links to OpenAI's math corpus and this project's exact claims. Independent +review found no issues; all nine required checks passed before protected merge +`3632a58d80320e56a7a44c017a74746008b920d8`. The public static Hugging Face Space +now serves commit `63a85954e68f4e0202db2382c875267f9ae03f40`, containing the 44 +tracked Space files from that GitHub revision. All remote file hashes match. +The public Space page visibly shows the banner and reports Running. + +The first publishing attempt failed during local Windows-to-WSL path conversion, +before an HTTP commit. The corrected attempt rechecked the unchanged remote +parent and exact payload. No credentials were written to the payload or logs. +The publication receipt and live screenshot are retained under +`runs/hf-corpus-banner-3632a58d8032/`. This delivery is independent of the ongoing +Snaky proof replay and makes no new verification claim. + +## 2026-10-19 — Checked illustrative Snaky play + +The new adapter records eight fresh Maker claims and seven legal Breaker replies, +with the first complete Snaky on Maker's eighth move. An independent validator +reconstructs placements, ownership, surviving continuations and move budgets. +All 23 focused tests pass, including incorrect transforms, stale envelopes, +incomplete winning targets, post-win moves, and counted replacement moves. +A separate reviewer reconstructed the ownership and all target placements +without importing either implementation and found the same first win. + +This is one chosen execution on the exact 251-cell board. It establishes no +eight-move guarantee or formally verified policy extraction. The forthcoming +viewer distinguishes actual moves, the remaining 21-claim allowance, and each +selected card's bound; its exporter requires the separate formal proof receipt. + +## 2026-10-19 — Complete finite Snaky build and committed-source replay + +The full native `SnakyBinding` build passed, including the 728-card strategy, +the new finite semantics, both concrete board theorems and the literal atlas +binding. The development log spans about 20 minutes 12 seconds with the warmed +dependency cache. This is a development measurement, not a clean-checkout timing. + +Candidate source commit `f205fe504af726f57a3fc52e84c0b7fa962137f6` was exported +with `git archive` into a new native directory. The verification runner is now +checking that committed source while reusing the development `.lake` cache. +It hashes 194 source files, audits 19 declarations, and explicitly supplies 179 +local modules for kernel replay. Its seven altered-claim checks remain a +separate gate. Hosted CI will supply the independent fresh-checkout run. + +The next presentation step is one checked example play with a per-move +certificate explanation. A read-only feasibility probe found an eight-Maker-move +branch. That example would not strengthen the universal 21-move guarantee; its +chosen Breaker replies and complete winning placement must be recorded. + +## 2026-10-19 — Finite Snaky core compiles + +The native Lean 4.34.1 build now accepts `SnakySemantics`, including the +finite-cell budget, composition, coordinate transport, impossible-target and +zero-budget lemmas. The initial build caught two proof-script errors: the +composition proof supplied obligations in the wrong order, and a transport +induction case referred to outer sets instead of its case-local sets. Both were +repaired and independently reviewed. The statements and game rules were not +weakened to make them compile. + +The pinned Mathlib cache is complete; compilation of the individual strategy +cards is still running. Full theorem verification, kernel replay, axiom audit +and the seven deliberate claim changes remain pending at this stage. Hosted CI +uses one heavy Lean compilation at a time, with a 60-minute job limit. The +planned local receipt will reuse the development dependency/build cache and +will be identified accordingly; hosted CI supplies a separate checkout run. + +A `leanchecker --help` probe unexpectedly began checking all modules on its +search path. The exact probe process was stopped; it produced no proof receipt. +Inspection of the pinned checker source showed that unknown flags are ignored +and an empty module list selects a default prefix. The runner already passes +the explicit 179-module local closure. It now also sets and records +`LEAN_NUM_THREADS=1` and `MATHLIB_NO_CACHE_ON_UPDATE=1`, validates those settings +on receipt replay, and includes a changed-environment rejection test. + +## 2026-10-19 — Snaky audit and exact-binding preparation + +The independent Python checker reconstructs all 728 cards from the pinned +38,367-byte certificate, with 24 focused tests passing. A separate review parser +compared all 728 required sets, envelopes and heights with the upstream Lean +literals: 2,184 exact comparisons and zero discrepancies. The chart shows the +251-cell support, the 17 by 17 square, a labeled illustrative target and the +replacement-cell bound. It is not a play trace. + +The new finite strategy-tree semantics includes fresh board-contained moves, +explicit availability of a legal Breaker response, immediate victory, and lemmas +excluding success for an impossible target or an unwon zero-budget position. +These are written proof obligations pending the Lean build. The exact claim +binding includes the complete board sets, six-cell target, empty starting sets, +card identity and move bound. Four runner-input tests pass. The independent +reviewer is withholding final approval until the actual proof receipt and seven +rejected-binding logs are inspected. + +The existing 11 context-query tests and 13 five-object proof tests pass. Saved +five-object, both N5 transfer, and Turing pair receipts still replay successfully. +The first Snaky Lean build is preparing its pinned Mathlib dependency cache in +WSL; native Git was installed there as an ordinary build dependency. No benchmark +answering sessions, new credentials or security-setting changes were made. + +## 2026-10-19 — Snaky finite-board extension started + +PR #16 merged through protected main at `557a718`; both nine-job pre-merge +CI runs and the subsequent main run passed. Started `codex/snaky-finite-board` +from that clean revision, following the user's selected mathematical order. + +The target is the paper's existing 21-Maker-move corollary on the final +251-cell envelope and the containing 17 by 17 square. The selected upstream +Lean theorem at `1581d4cbdd69a0faf34b2089614fe2a814316a6a` concerns the infinite +grid. Its replacement-move lemma uses infinitude. The finite extension must +justify spare cells with a move-count invariant and keep all moves on the +board; it cannot assert fresh moves on arbitrary exhausted finite states. + +The 728-card certificate, including six bases, is separate from the older +616-card reconstruction. Independent certificate reconstruction, Lean proof, +and independent implementation review are assigned separately. The intended +claim has stable ID `context:family-187:snaky:finite-board-21:v1`. Until its +proof and checks complete, this is a development target rather than verified +atlas evidence. No smaller move bound, smaller board, novelty, or agent +performance gain is claimed. Model benchmarks and training remain paused. + ## 2026-10-19 — Make the source mathematics visible in the public demo Added a prominent source-and-scope banner above the atlas introduction, with diff --git a/docs/CLAIMS.md b/docs/CLAIMS.md index 975e82b..98a47fb 100644 --- a/docs/CLAIMS.md +++ b/docs/CLAIMS.md @@ -13,6 +13,9 @@ for one row does not establish a stronger claim from another row. | Minimum unary operation counts are 0,1,1,1,0,2,2 | `evidence/minimized-algebras.json` | C2,C3,C4,B2,M3,N5,B3; fixed carriers and exact saved relation families | | The minimizer agrees with a third exhaustive method | `evidence/operation-minima-audit.json` | All 313 representable exact relation families on carriers 1–4; 60 impossible controls | | Two exact five-object congruence families have isomorphic eight-element orders but minimum unary rule counts three and two | [Formal statement and walkthrough](FIVE_OBJECT_MINIMUM.md), [exact claim](../evidence/five-object-v1/claim.json), [independent computation](../evidence/five-object-v1/computational.json) | All equivalence relations and all unary maps on the fixed five-object carrier; exact families only, including empty signatures and repeated rules; no minimum over all embeddings | +| Maker has a Snaky strategy within 21 fresh claims on each of two exact finite boards | [Formal statement and reproduction](SNAKY_FINITE_BOARD.md), [exact claim](../evidence/snaky-finite-v1/claim.json), [proof receipt](../evidence/snaky-finite-v1/proof/summary.json) | Exact 251-cell envelope and containing 17 by 17 square, empty initial sets, every legal Breaker reply under the formal rules; formalizes the paper's existing finite-board result | +| An independent checker reconstructs the 728-card Snaky certificate | [Computational record](../evidence/snaky-finite-v1/computational.json) | Exact pinned certificate, required sets, envelopes, placements and heights; separate from the older 616-card comparator and from a formal correctness proof of Python | +| One recorded Snaky play reaches a complete target after eight Maker claims | [Example and adapter](SNAKY_PLAY.md), [complete execution](../evidence/snaky-play-v1/example.json) | One chosen sequence of seven Breaker replies on the exact 251-cell board; independently replayed ownership and target; no eight-move guarantee or verified policy extraction | | The atlas groups all small representable relation families | [Atlas method](ATLAS.md), `evidence/atlas.json`, `evidence/atlas-review.json` | Carriers 1–4; 313 labeled families, 39 classes under object relabeling, 22 abstract lattice types across the range; finite computational evidence | | M4 has no graph witness in the searched range | Search and replay records | At most four carrier vertices; larger carriers are outside this claim | | Saved N5/B3 graphs satisfy the exact upstream predicate in Lean | [Bridge proof and reproduction record](LEAN_VERIFICATION.md) | Exact generated color tables; all five `IsGraphWitness` conditions, including every nonempty finite ordered seed set | @@ -25,6 +28,8 @@ for one row does not establish a stronger claim from another row. | Five step properties hold for the extracted upstream Turing-machine definition | [Source lemmas](../lean/tm/MachineChecks.lean), [axiom reports](../evidence/tm-port-v1/build/axioms.log), [build and kernel receipt](../evidence/tm-port-v1/summary.json) | Halted configurations are fixed; a missing instruction changes only state; a present instruction has the defined write/move/target effect and preserves other cells; exact pinned fragment with narrower imports | | The maintained Python TM port agrees with one compiled Lean oracle on complete configurations | [Native comparison receipt](../evidence/tm-port-v1/summary.json), [method and limits](TM_TRANSLATION_CHECKS.md) | 2,857 specified snapshots: 297 named, 1,960 exhaustive within a stated small domain, 600 sampled; full nonzero tape support, state, head and halting status; 34 decoder rejection probes and seven output-corruption controls; no general port-equivalence proof | | The TM atlas compares three properties of four exact encoding pairs | [Pair claims](../evidence/tm-atlas-v1.json), [trace records](../evidence/tm-atlas-traces-v1.json), [method](TM_ATLAS.md) | Twelve separate stopping-time, complete-tape, and head-position observations on blank input; exact source/trace citations and qualified generic lemma links; no pair-equivalence theorem | +| The exact tiny-stay machines first halt after one transition with equal heads and different complete tapes | [Formal supplement and reproduction](TM_PAIR_PROOF.md), [separate proof receipt](../evidence/tm-pair-proof-v1/summary.json) | Exact two machine definitions and blank input; tape formulas quantified over every integer position; no general Python/Lean equivalence claim | +| Two consistent relabelings preserve the saved N5 construction's complete classification, ordering and distinctness | [Proof-reuse walkthrough](N5_PROOF_REUSE.md), [generic transfer](N5_RENAMING.md) | Two exact registered applications of the general bijective transport theorem; inconsistent rule correspondences and unrelated theorem references are rejected | | One fresh-context agent selected the required evidence in six guided questions | [First answers and score](../evidence/tm-retrieval-v1/summary.json), [protocol and limits](TM_ATLAS_EVALUATION.md) | Six first responses pass structured pair/property/value/citation checks; prose receives separate same-session AI review; no control arm, feedback advantage, or general capability claim | No claim of a new mathematical theorem or classification is made. These small @@ -45,7 +50,9 @@ as outside peer review. Novelty would require a separate literature investigatio The [archive review](ARCHIVE_REVIEW.md) preserves the original inspection scope. The subsequent [TM checks](TM_TRANSLATION_CHECKS.md), [pair atlas](TM_ATLAS.md), and [retrieval exercise](TM_ATLAS_EVALUATION.md) support only their scoped rows -above. Pair-specific Lean preservation proofs remain future work in the -[TM halt pilot](TM_HALT_PILOT.md). Lexical dependency counts cannot support proof-dependency claims; +above. The [tiny-stay formal supplement](TM_PAIR_PROOF.md) now proves that one +exact pair's result while retaining the original bounded execution records. +Broader preservation proofs remain future work in the [TM halt pilot](TM_HALT_PILOT.md). +Lexical dependency counts cannot support proof-dependency claims; those require elaborated declarations. Evidence does not transfer between different constructions or certificates merely because they share a name. diff --git a/docs/CONTEXT_QUERY.md b/docs/CONTEXT_QUERY.md index 83f7430..1d1310e 100644 --- a/docs/CONTEXT_QUERY.md +++ b/docs/CONTEXT_QUERY.md @@ -2,7 +2,8 @@ The context interface supports two exact N5 construction claims, their comparison, two proved N5 renamings, a pair of exact five-object operation -minima, and one existing Turing-machine tape claim. +minima, one existing Turing-machine tape claim, and the exact finite-board Snaky +guarantee. Each query fails closed if its required evidence is missing or invalid. It reads the website's records and separately identified proof supplements, validates the relevant saved evidence, and returns JSON. It runs locally using the Python standard library. No model, credentials, @@ -37,6 +38,34 @@ saved receipt and recomputes the 52-partition/3,125-map audit. The correspondenc is between grouping indices, with no asserted carrier relabeling. The command format and evidence schema are unchanged. +## Finite-board Snaky registration + +The [Snaky walkthrough](SNAKY_FINITE_BOARD.md) describes the exact 728-card +certificate, six-cell target, 251-cell envelope and containing 17 by 17 square. +The registered ID is `context:family-187:snaky:finite-board-21:v1`. +Its conclusion is a strategy guarantee within 21 actual fresh Maker claims +from an empty board, covering every legal on-board Breaker reply. + +The claim binds the literal target and both boards, the empty initial Maker +and Breaker sets, the move bound and the applicable theorem. The independent +Python reconstruction checks the concrete certificate arithmetic separately. +Receipt replay checks these records without executing Lean; it cannot certify +an arbitrary changed board or strategy. The older 616-card comparator record +is not evidence for this claim. + +Use the existing commands: + +```sh +python scripts/query_context.py explain context:family-187:snaky:finite-board-21:v1 --out snaky.json +python scripts/query_context.py check snaky.json +``` + +The original command formats and schema remain unchanged. In particular, +`compare` continues to compare the two original N5 records; it does not compare +unrelated claims from different mathematical domains. + +## Reading an N5 result + An N5 `explain` result includes: - The exact claim and construction IDs, carrier, ordered operation tables, diff --git a/docs/HUGGING_FACE_DEMO.md b/docs/HUGGING_FACE_DEMO.md index 0b528cb..7773137 100644 --- a/docs/HUGGING_FACE_DEMO.md +++ b/docs/HUGGING_FACE_DEMO.md @@ -95,6 +95,13 @@ and do not execute a proof or machine simulation in the browser. ## Publish +The top of the atlas highlights its work with OpenAI's math corpus and links +directly to the original repository and our claim ledger. The wording identifies +independent checks and formal extensions of selected results. This banner was +published through PR #17 from GitHub commit +`3632a58d80320e56a7a44c017a74746008b920d8` to Space commit +`63a85954e68f4e0202db2382c875267f9ae03f40`; all 44 published file hashes matched. + Publish only the contents of `space/` to the static Space `Maverick03511/finite-congruence-checks`. Its README declares `sdk: static` and `app_file: atlas.html`. Keep GitHub as the canonical source and record the source diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 5dc17cd..0550406 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -1,6 +1,6 @@ # Research and engineering roadmap -## Current milestone: five-object minima; next, Snaky +## Current milestone: Snaky on finite boards [PR #11](https://github.com/Maverick0351a/finite-congruence-checks/pull/11) and [PR #12](https://github.com/Maverick0351a/finite-congruence-checks/pull/12) are merged. @@ -21,9 +21,21 @@ with the same eight-element order but different minimum unary rule counts. The five-object proof now supplies complete classifications, arbitrary-unary-map lower bounds, exact theorem bindings, and a separate exhaustive Python audit. It adds formal coverage to a saved finding; it does not assert novelty or a -complete five-object classification. Once this delivery passes protected-branch -review and CI, the next task is a narrowly scoped Snaky source-and-certificate -review, keeping the 616-row comparator and 728-card theorem data separate. +complete five-object classification. PR #16 merged through protected main and +its main CI run passed. + +The [Snaky finite-board extension](SNAKY_FINITE_BOARD.md) now formalizes the paper's +existing 21-Maker-claim guarantee on its exact 251-cell envelope and containing +17 by 17 square. Independent reconstruction of the 728-card certificate passes; +the finite-board Lean proof, full local kernel replay, axiom audit and seven +changed-claim checks pass. The 616-card comparator reconstruction remains a +different result. The [branch walkthrough](SNAKY_PLAY.md) shows one complete +independently replayed example, including each Maker move, chosen Breaker reply, +remaining budget and supporting certificate step. It distinguishes that chosen +eight-claim play from the theorem covering every legal reply within 21 claims. +Complete hosted reproduction and publication review before closing this milestone. +Then inspect one directed-graph example's exact source statement and +assumptions before selecting its proof target. Before any resumed model evaluation, resolve the dummy runner's [isolation and usage gates](NATIVE_PREFLIGHT_STATUS.md). Report actual preflight diff --git a/docs/SNAKY_FINITE_BOARD.md b/docs/SNAKY_FINITE_BOARD.md new file mode 100644 index 0000000..9328c02 --- /dev/null +++ b/docs/SNAKY_FINITE_BOARD.md @@ -0,0 +1,197 @@ +# Snaky on a finite board + +The finite-board Lean extension, complete local-module kernel replay, +allowed-axiom audit and seven altered-claim rejections pass. The separate Python +checker reconstructs all 728 certificate cards. The [saved receipt](../evidence/snaky-finite-v1/proof/summary.json) +records exactly which sources and commands were checked. + +Two players take turns claiming an empty square. Maker moves first and tries to +own a copy of this six-cell shape. Breaker tries to prevent that. Rotations, +reflections and translations of the shape count; resizing does not. + +```text + ■ ■ + ■ ■ ■ ■ + 0 1 2 3 4 x +``` + +The bottom row is `y = 0`; the upper cells are `(3,1)` and `(4,1)`. The formal +definition is the pinned upstream [`snaky` and `HasSnaky`](https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/lean/OAI/GameTheory/SnakyTwentyOne/Model.lean). + +The paper already gives a strategy that wins within 21 Maker claims on a +particular set of 251 squares, and therefore on the containing 17 by 17 square. +Its [finite-board argument](https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/build/strategy.tex) +is the result this extension formalizes. The pinned upstream Lean +[scope note](https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/lean/docs/187.md) +selects the infinite-grid strategy. This project adds formal +coverage of that finite-board corollary, without asserting a new move bound or +mathematical novelty. + +## How the certificate works + +Think of a card as a small instruction with three parts: + +- **Required cells:** cells Maker already owns. +- **Envelope:** cells Breaker has not yet claimed, where the plan can continue. +- **Height:** how many additional Maker claims suffice. + +A card offers several smaller continuation cards. Maker claims its pivot. A +single Breaker reply cannot spoil all the continuations, so Maker chooses one +that survives. Heights decrease along this choice. A base card ends by claiming +the remaining cell of a Snaky copy. + +Why must a continuation survive? Any cell shared by **every** child envelope is +already owned by Maker after the pivot claim. Breaker must choose a fresh cell, +so its reply cannot belong to every child envelope. At least one child envelope +therefore stays free of Breaker cells. That is the local condition checked at +each combination, including combinations nested inside a numbered card. + +There are 728 cards, including six base cards. The final card is number 727; +it starts with no required Maker cells and has height 21. This is the exact +[certificate](../evidence/snaky-finite-v1/certificate.txt) used here. The older +616-card reconstruction has a different bound and does not support this claim. + +## Why the board size matters + +![The exact 251-cell envelope inside a square with coordinates 0 through 16; P marks the first pivot and S1 to S6 illustrate a target, not played moves](assets/snaky-board.svg) + +Sometimes a card's suggested pivot is already owned by Maker. The proof can use +a fresh replacement cell and continue. An infinite grid always has such a cell. +A finite board needs a count: before Maker's 21st claim, at most 20 Maker cells +and 20 Breaker cells are occupied. That leaves at least `251 − 40 = 211` free +cells on the smaller board. + +The formal resource condition carries both occupied cells and remaining moves: + +```text +occupied cells + 2 × remaining Maker claims ≤ board size +``` + +After an ordinary Maker/Breaker round, occupancy rises by two and the remaining +claim budget falls by one. The inequality stays true. A winning Maker move +can end play immediately; it does not require another Breaker reply. + +At the empty starting position, this budget asks for at least `2 × 21 = 42` +cells. The theorem also requires the board to contain the entire 251-cell +envelope, so it does not assert that a 42-cell board suffices. + +The theorem covers every legal Breaker reply on the selected board. +In the square version, Breaker may also play outside the 251-cell envelope. +The finite game definition requires both players' moves to stay on the +board and use fresh cells. Its continuing case requires a legal Breaker reply +to exist, excluding a vacuous win from an exhausted board. + +## Evidence and limits + +The [independent reconstruction](../evidence/snaky-finite-v1/computational.json) +checks the certificate's finite sets, placements, heights and local combination +conditions. Its Python implementation does not itself prove the game theorem. +The [Lean theorem](../lean/snaky/SnakyFinite.lean), +[literal typed binding](../lean/snaky/SnakyBinding.lean) and +[proof receipt](../evidence/snaky-finite-v1/proof/summary.json) provide separate +formal evidence. Both `envelope_wins` and `square_wins` establish `FiniteWins` +for the stated target, empty initial ownership and bound 21. + +The receipt records 194 source hashes, 179 explicitly replayed local modules, +19 declaration axiom reports, and all seven rejected bindings. Only +`propext`, `Classical.choice` and `Quot.sound` occur in the audited dependencies. +The renewed local run used committed source +`c3af350005f413554aea03db8cbf2c4c2d09e31b` with a warmed build/dependency +cache. Its kernel stage took 1,303.713 seconds; the full 12-stage run took +24 minutes 11 seconds. All 179 verbose module announcements match the exact +import closure, and the process exited successfully. These are local +measurements, not fresh hosted-build timings or a controlled measurement of +the discovery change's speed effect. Earlier successful receipts remain in Git +history, including the 1,733.691-second kernel run from source `5fa1b815`. + +Stable claim ID: `context:family-187:snaky:finite-board-21:v1`. + +## Reproduce the result + +To run the complete verification from a fresh checkout: + +```sh +python scripts/snaky_proof.py run --out runs/snaky-fresh +``` + +Use a fresh checkout with Python 3.10 or later, Git, and the pinned Lean 4.34.1 +toolchain available through `lake`. The command downloads the pinned Mathlib +dependency cache on its first run. Allow time and disk space for that dependency +and the 728-card proof. The output directory must be new, so a run preserves its +own logs. CI runs the same command on Linux; Windows users can use WSL. +The runner records `LEAN_NUM_THREADS=1` to reduce concurrent compilation work. +This setting is not a strict memory or concurrency limit for `leanchecker`: +the pinned runtime may start another worker when a task waits on dependencies. +The initial local bulk replay reached roughly 14.3 GiB RSS. Allow substantial +memory and disk space; hosted CI has a 210-minute job allowance. Compilation +has a 60-minute stage allowance, kernel replay allows 120 minutes, and the +other stages each allow 40 minutes. A +timeout fails verification and preserves the partial stage log and receipt. +The first fresh hosted attempt reached the former 40-minute compilation limit; +it did not reach kernel replay or the negative controls. After compilation's +allowance increased, both hosted builds passed in 33–36 minutes, but their +kernel replay reached its former 40-minute limit. Neither failed run completed +kernel replay or the negative controls. The longer kernel allowance retains all +179 modules and records host capacity plus GNU time resource measurements as +separate CI diagnostics. Hosted resource behavior is assessed separately from +the warmed local run; a timeout never counts as proof success. + +The pinned [Lean checker implementation](https://github.com/leanprover/lean4/blob/5045d0056413266e57c625dcd7c365b10e377c52/src/LeanChecker.lean) +rescans its entire module search path for each command-line selector. The +runner uses nine exact names or namespace prefixes to select the same 179 +local modules, avoiding 170 redundant discovery scans. It checks that these +selectors match the source import closure. Verbose replay output must name +every expected module exactly once, including during saved-receipt replay; +missing or extra compiled modules fail the inventory check. Each `replaying` +line announces a task wait, so the complete inventory must be accompanied by +a successful process exit. A partial log is not a completed proof. The earlier +empty logs do not tell us how much time was spent on discovery versus replay. + +The runner first checks the independent certificate reconstruction and exact +upstream bytes. It then builds the Lean proof, audits the theorem dependencies' +axioms, rechecks the proof modules with `leanchecker`, and compiles seven changed +claim bindings that must fail. Those changes alter the target, envelope, square, +move bound, card number, initial position, or theorem reference. A missing import +or exhausted compiler budget does not count as a successful rejection. + +The exact binding checks a mathematical type involving both literal boards, the +literal six-cell target, empty initial sets and move bound 21. It does not rely +only on a filename, theorem name or hash. The original upstream files remain +byte-for-byte copies; sibling modules supply the finite-board argument. + +The existing local query interface uses the saved proof receipt alongside +the independent computational record: + +```sh +python scripts/query_context.py explain context:family-187:snaky:finite-board-21:v1 --out snaky.json +python scripts/query_context.py check snaky.json +python scripts/snaky_proof.py replay +``` + +`explain` and `check` replay the saved record and recompute the finite certificate +audit. They do not execute Lean. A changed record is **unsupported by this exact +registration**; that alone does not mean its mathematical conclusion is false. +For example, a smaller board would need its own argument. The three activities +have distinct meanings: + +| Check | What it establishes | +| --- | --- | +| Lean build, kernel replay and axiom audit | The formal finite-board strategy statement follows from the displayed definitions under the recorded trust assumptions. | +| Independent Python reconstruction | The certificate's concrete finite calculations pass a separately implemented checker. | +| Record binding and offline replay | This saved atlas claim matches the exact proof statement and recorded artifacts. | + +Hashes and saved logs support inspection; they are not authenticated attestations. +The runner pins the dependency manifest and Lean release. It rechecks the local +proof modules and audits their transitive axiom dependencies; it does not attest +every cached Mathlib artifact in the build environment. The hosted CI build +provides a separate reproduction from a fresh repository checkout. + +The [interactive branch walkthrough](SNAKY_PLAY.md) adds one independently +checked execution, with eight Maker claims and a complete winning placement. +It shares the exact claim with the query interface. That chosen execution is +not a formally verified extraction of the strategy, nor an eight-move guarantee. + +This milestone supplies a formal strategy guarantee. It does not formally extract +or benchmark a playable policy, prove that 21 is optimal, find a smallest board, +verify a general translator, or measure whether an AI reasons better. The model +benchmark and training remain paused. diff --git a/docs/SNAKY_PLAY.md b/docs/SNAKY_PLAY.md new file mode 100644 index 0000000..9f2c95a --- /dev/null +++ b/docs/SNAKY_PLAY.md @@ -0,0 +1,110 @@ +# Follow one Snaky strategy branch + +The walkthrough at `space/snaky-play.html` shows one complete play on the +exact 251-cell envelope. Maker owns a six-cell Snaky after eight claims in this +record. The separate [finite-board theorem](SNAKY_FINITE_BOARD.md) guarantees a +win within 21 Maker claims against every legal reply under its formal rules. +One convenient sequence of replies cannot establish a better universal bound. + +## What happens at each move + +The display advances by a round: a fresh Maker claim and, unless Maker has won, +a fresh Breaker reply. The outlined envelope belongs to the continuation chosen +after that reply. It avoids all Breaker cells. The card's required cells must +already belong to Maker. + +```mermaid +flowchart LR + A[Current card] --> B[Maker claims a fresh square] + B --> C{Maker has won?} + C -->|Yes| D[Stop] + C -->|No| E[Breaker claims a fresh square] + E --> F[Choose a surviving child] + F --> A +``` + +For a combination card, any square common to every child envelope already +belongs to Maker after the pivot claim. Breaker cannot claim it legally. +Consequently a legal reply cannot lie inside every child envelope: at least +one continuation survives. A base card completes a copy of the target. + +Sometimes the pivot already belongs to Maker. A fresh replacement square +still consumes a Maker claim. The finite-board proof supplies the resource +argument for that case; the example checker also tests replacement accounting. +This recorded branch happens to use no replacement moves. + +Three quantities stay distinct in the viewer: + +| Quantity | Meaning | +| --- | --- | +| Actual Maker claims | Fresh squares Maker has claimed so far. | +| Remaining 21-claim allowance | 21 minus those actual claims. | +| Card bound | Additional claims sufficient for that particular continuation. | + +A child card can have a much lower bound than its parent. That improves the +remaining plan's bound without counting extra moves as played. + +## The exact choices + +The first two Breaker replies follow the pinned paper's illustrative opening. +Later replies use the lexicographically first free square of the root board. +The adapter selects the first printed child that remains available. These are +reproducible example choices, not an optimized opponent or an extracted, +formally verified policy. + +| Maker claim | Maker square | Breaker reply | Card bound before this claim | +| ---: | --- | --- | ---: | +| 1 | (8, 8) | (7, 8) | 21 | +| 2 | (8, 7) | (8, 6) | 20 | +| 3 | (11, 8) | (0, 4) | 18 | +| 4 | (8, 9) | (0, 5) | 14 | +| 5 | (8, 10) | (0, 6) | 7 | +| 6 | (8, 11) | (0, 7) | 3 | +| 7 | (9, 11) | (0, 8) | 2 | +| 8 | (9, 10) | No reply: Maker has won | 1 | + +The winning cells are `(8,7), (8,8), (8,9), (8,10), (9,10), (9,11)`. +The complete [record](../evidence/snaky-play-v1/example.json) includes all +ownership sets, coordinate placements, child references and source links. +The two other Maker cells are not part of this winning copy. + +## What the adapter adds + +[build_snaky_play.py](../scripts/build_snaky_play.py) follows the certificate +and exports this example. [check_snaky_play.py](../scripts/check_snaky_play.py) +independently reconstructs its transformations, moves, ownership and final +target. It does not import the example generator. + +[build_snaky_presentation.py](../scripts/build_snaky_presentation.py) requires +that independent replay, the actual saved Lean verification receipt, and a +supported exact atlas claim. It checks that the example's board matches the +proved envelope. It also verifies every linked source against an immutable Git +commit before writing the browser script and JSON download from one packet. + +The example replay supports this execution. The Lean proof supports the formal +strategy guarantee. The binding checks connect the saved claim to that proof. +None of these alone proves that the Python adapter implements a winning policy +for all possible plays. + +## Reproduce and inspect + +From a full checkout, run: + +```sh +python scripts/build_snaky_play.py --check +python scripts/check_snaky_play.py +python scripts/build_snaky_presentation.py --check +python -m unittest discover -s scripts -p 'test_snaky*.py' -v +node scripts/check_snaky_play_ui.cjs +``` + +These commands inspect saved evidence and recompute finite calculations. The +separate fresh proof command is documented in [the formal walkthrough](SNAKY_FINITE_BOARD.md). +The presentation command deliberately fails if its real receipt, source anchor +or generated files are missing. The renderer's explicit `--example-only` +development mode omits the publication packet and cannot certify publication. + +The renderer checks are tests against a DOM stub. Real browser layout, native +keyboard controls and mobile readability require a separate visual review. +The complete move table and downloadable record provide alternatives to the +small coordinate labels in the board diagram. diff --git a/docs/SNAKY_REVIEW.md b/docs/SNAKY_REVIEW.md new file mode 100644 index 0000000..8735c4f --- /dev/null +++ b/docs/SNAKY_REVIEW.md @@ -0,0 +1,371 @@ +# Independent review of the finite-board Snaky proof + +Review completed 19 October 2026. Verdict: **approve the reviewed implementation**. +This is an independent AI-assisted review within the implementation chat, not +external peer review. The completed proof, exact bindings, recorded verification, +illustrated execution, and presentation have been inspected. Protected-branch +CI and public-link availability remain separate release gates. + +## Source and claim boundary + +The review uses OpenAI's math corpus at commit +`1581d4cbdd69a0faf34b2089614fe2a814316a6a`. +Its [scope note](https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/lean/docs/187.md) +describes a formal 21-Maker-move strategy on the infinite integer lattice and +explicitly excludes the smaller finite-board restriction. The paper's +[strategy argument](https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/build/strategy.tex) +already proves finite-board corollaries for the 251-cell final envelope and +the square `{0,...,16} × {0,...,16}`. This milestone aims to formalize that +existing argument; it does not improve the move bound or establish novelty. + +The relevant certificate has 728 cards, indexed 0 through 727, including six +bases and 722 further numbered lines. The older uploaded 616-row comparator +certificate is a different object. Exact references and transformations are +part of the certificate's identity. + +## Mathematical obligations + +- Every claimed Maker or Breaker move lies in the chosen finite board and is + previously unoccupied. Ownership remains disjoint. +- A prescribed pivot already owned by Maker requires a fresh replacement; + that replacement consumes an actual Maker move. +- Before Maker move 21, at most 40 cells are occupied. This supports finite + replacement availability; an infinite-board fresh-cell theorem alone does + not establish it. +- A win may finish immediately after Maker's move. No Breaker reply after + victory is required. +- A recursive move must not win vacuously because there are no legal Breaker + replies. The reviewed design includes an explicit legal-reply existence + obligation. +- Quantification over Breaker replies on the square includes replies outside + the 251-cell envelope. Nested envelopes preserve the required avoidance of + all earlier Breaker cells. +- A finite-board strategy cannot be globally fresh on arbitrary exhausted + states. Availability assumptions belong in the exact game interface. +- Board containment and the root's height, requirements, and certificate + identity must be bound to the theorem, not merely to a diagram or file hash. + +## Checks completed + +- Read the pinned paper's strategy and certificate-proof arguments, the + upstream game constructors and composition proof, the exact root card, and + the certificate summary. +- Confirmed that the paper distinguishes actual Maker moves, replacement + moves, and the absence of a required final Breaker reply. +- Confirmed that upstream `WinsIn.move`, used without further conditions on a + finite carrier, can have an empty universal-reply premise. The proposed + finite semantics strengthens this with explicit reply availability and an + immediate-win constructor. +- Independently reconstructed the literal certificate with a separate + transient parser, without importing the implementation's checker. All + 728 required sets, envelopes, and heights agree with the pinned Lean card + literals: 2,184 comparisons with no discrepancies. The root has empty + requirements, a 251-cell envelope inside the stated square, and height 21. + The parser traversed 898 inline combinations and 4,089 numbered references. +- Read the independent reconstruction implementation and its malformed-input + controls. Re-ran all 24 focused Python tests and the saved computational + receipt replay successfully. Checked the paper's signed-coordinate order + separately from the upstream model's different symmetry numbering. +- Read the board-chart generator, checked generated-data freshness, and + inspected its rendered output. Coordinate axes, root pivot, sample target, + and replacement arithmetic are legible; the image explicitly identifies + the sample target as an illustration rather than an execution trace. +- Checked all 94 vendored files against their raw-byte manifest. Ninety-two + also agree byte-for-byte with the earlier pinned local source snapshot; + the two remaining modules, `Policy.lean` and `Replies.lean`, agree with + separate downloads from the same immutable upstream commit. +- Read the finite game, composition, transport, and concrete-board statements. + The composition proof preserves board containment and disjoint ownership, + charges a fresh replacement as an actual Maker claim, and carries the + occupied-cell budget through each reply. The explicit reply witness rules + out empty-response-set victories. The additional `false_impossible` and + `zero_iff` statements address impossible targets and exhausted move budgets. +- Checked the generated finite proof source: 86 modules and 3,246 semantic + derivations match the generator. This is a source-freshness check; successful + Lean compilation and kernel replay remain separate obligations. +- Read the typed binding, receipt validator, query integration, CI changes, + and draft walkthrough. Re-ran four input/audit validation tests successfully, + including altered vendor/dependency pins and setup errors that must not be + classified as mathematical rejection. +- Inspected the completed native development build: all 9,103 jobs passed, + including the finite semantics, complete certificate adaptation, concrete + boards, and literal claim binding. The proof source was then frozen at + `f205fe504af726f57a3fc52e84c0b7fa962137f6` for the recorded verification run. +- Read the actual axiom log from that run. All 19 requested declarations have + reports, using only `propext`, `Classical.choice`, and `Quot.sound`; no missing + proof or extra axiom appears. +- Inspected the completed 12-stage receipt and all seven actual negative + logs. The 179-module kernel command exited successfully in 1,631.946 seconds. + Changed target, envelope, square, move bound, card number, initial ownership, + and theorem substitutions failed on false propositions or incompatible + mathematical types, not unavailable imports or resource exhaustion. The + copied receipt replays against all 194 source hashes. All 15 proof/query + tests passed independently, including altered logs, forged controls, + missing stages, wrong kernel commands, and wrong execution settings. +- Reviewed the Hugging Face corpus banner's wording and source changes. Its + reference to independent checks and formal extensions of selected corpus + results is appropriately scoped. Visual browser checks were performed by + the implementation agent; this review adds a wording check, not a second + browser inspection. +- Read the illustrative-play adapter and its separate replay checker. The + checker reconstructs certificate geometry using separate coordinate + formulas, composes placements through basis-point images, and verifies + fresh claims, child requirements and envelopes, actual move counts, and the + complete winning target. It shares the pinned certificate grammar, not the + move generator. All 23 play tests, saved replay, and generator freshness + checks passed when rerun independently. +- Reconstructed the play's ownership history with a separate transient + calculation importing none of the implementation modules. Enumeration of + signed coordinate permutations confirms eight legal Maker claims, seven + legal Breaker replies, no earlier win, and one complete six-cell target at + move eight. These are checks of one chosen execution, not a better universal + move bound. The replacement test is an isolated fixture, not a position + asserted to occur in that illustrated play. +- Checked the initial play choices against the pinned paper's + [worked continuation](https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/build/certificate-proof.tex#L184). + Its two displayed Breaker replies and first three Maker pivots match. The + example then uses its explicitly declared deterministic reply choices. +- Re-ran five presentation-anchor controls using actual temporary Git + commits, plus the explicit example-only renderer check. They check committed + bytes, all eight rendered ownership states, surviving-envelope outlines, + the final target, links, and navigation. The renderer check uses a DOM stub; + browser layout and native keyboard behavior require separate inspection. + Full publication tests intentionally require the actual proof receipt, + source anchor, and generated packet instead of skipping missing inputs. +- Reviewed the stable viewer and presentation exporter sources. The export + requires a supported exact claim and independently validated execution, + checks their common board and claim ID, and binds published evidence links + to committed bytes. The page separates the eight-claim illustration, the + 21-claim strategy guarantee, and the absence of a verified policy extraction. + It displays actual claims and both remaining bounds separately, with a + complete textual move list alongside the diagram. +- Reviewed the completed illustrated-play walkthrough against the saved + execution: all eight Maker cells, seven Breaker replies, card bounds, and + six final target cells match. The prose explains child survival, replacement + accounting, and the distinction between an execution checker and a verified + policy. Reviewed the final atlas navigation, CI publication gates, and + corrections to stale N5/Turing claim summaries; no correctness issue was + found in those changes. +- Re-ran the complete focused suite with the real receipt and presentation: + all 73 tests passed (24 certificate, 23 play, 11 presentation, and 15 + proof/query tests). The presentation freshness command and the default full + renderer check both pass. The source anchor binds 219 inputs to commit + `767294d63b5cf0c3a4c664aa62c46d8dcbe3b65a`; the JSON download, browser script, + exact query record, and immutable evidence links agree. These tests include + actual temporary Git history and rejection of changed claims, proofs, + execution states, and incomplete winning targets. +- Reviewed the completed-status documentation against the actual receipt. + It correctly reports the local warmed-cache run and does not describe it as + a fresh hosted build. The final mobile styling preserves board-label size + through a keyboard-focusable horizontal scrolling region, while retaining + the full move table as a textual alternative. +- Reviewed the mobile overflow correction (`min-width: 0` and a constrained + grid column) and independently inspected the resulting 390-pixel screenshot. + The board remains inside the page with readable controls and a visible focus + outline. The implementation agent reports equal page scroll/client widths, + a 321-pixel board viewport over 468-pixel content, native ArrowRight scrolling, + Enter advancing to move two, and End selecting the eighth and final move + with Next disabled. Those interaction checks are reported browser evidence, + separate from this reviewer's screenshot and source inspection. +- Independently inspected the final desktop screenshot: all six winning cells, + both additional Maker cells, the seven Breaker cells, and the separately + labeled claim counts match the record. The implementation agent also reports + native Space activation of Previous, expansion of all eight text-table rows + using Enter, no page overflow with the table open, and an empty browser + warning/error log. This reviewer did not independently repeat those browser + actions. + +No correctness finding remains open in the reviewed implementation. The finite game +constructors permit immediate victory; they do not require every strategy-tree +derivation to syntactically stop at its first winning position. A winning +position can use `done`, and a winning fresh move can use `finish`. Explanations +should preserve this distinction from an extracted executable policy. + +## Approval scope and release gates + +The approval covers the mathematical source, exact claim binding, completed +local verification receipt, finite replay checks, and reviewed presentation. +The proof source is fixed at `f205fe504af726f57a3fc52e84c0b7fa962137f6`; +the proof-and-play evidence links use +`767294d63b5cf0c3a4c664aa62c46d8dcbe3b65a`. The recorded proof run uses +Git-archived committed sources with an existing dependency/build cache. It +does not constitute a clean build or an attestation of every cached dependency. + +Hosted CI must pass before merge. Public HTTP evidence links must be checked +after the referenced commit is pushed, and the published demo must be checked +after deployment. Their local source bytes and URLs have passed the anchor +checks; this review does not claim that those later release actions are complete. +Subsequent mathematical or evidence changes require renewed review. No model +benchmark, reserved task, API session, or training job was run for this review. + +## Operational follow-up after hosted compilation timeout + +The first hosted PR run (`39267847727`, job `118112018126`) reached the former +2,400-second compilation limit at 15:07:55 UTC on 19 October 2026. The downloaded +failed receipt records successful version and dependency stages; the build's +buffered output was not saved. This is a verification-infrastructure failure, +not a rejected mathematical claim or a completed hosted reproduction. + +The operational code review is **approved**. Only compilation receives the +3,600-second allowance; every other stage retains 2,400 seconds. The hosted +job allowance is 120 minutes, with the mathematical and negative-binding +checks retained. Logs stream to files, and an atomic checkpoint records the +stage before execution and after completion or failure. The receipt excludes +itself and its temporary file from the artifact hashes. Replay requires each +stage to have passed, no failure classification, and the exact timeout policy. + +Review found one cleanup gap in the first draft: a terminated direct child +could leave a live helper in its process group. The final code cleans that +owned POSIX group on every stage failure while preserving the direct child's +original exit code. A regression test exercises a parent terminated by SIGTERM +and its live descendant. POSIX group cleanup applies to Linux/WSL; native +Windows cleanup terminates the direct child only. + +This reviewer independently ran all 11 synthetic runner tests on WSL/Linux; +all passed in 10.265 seconds. They exercise partial output, timeouts, +interruption, launch failure, owned-group cleanup, preservation of an unrelated +process, actual completed rejection, and rejection of incomplete or failed +stage records. In particular, a timeout after printing a type-error message +and a process terminated by a signal cannot become successful mathematical +rejection evidence. The fixtures run short Python processes and do not execute +Lean or establish the Snaky theorem. + +The earlier mathematical approval remains limited to its recorded source and +receipt. The updated runner still requires its own completed 12-stage receipt +and publication anchor before renewed full approval. Those evidence checks +are **pending**; code approval is sufficient to freeze and run the candidate. + +## Renewed receipt and publication review + +**Approved** after inspection of the completed replacement receipt. This +supersedes the pending evidence gate immediately above. The renewed run used +source commit `5fa1b81550a1841a3b2b91a0c48a7cc5b4380448`, and the receipt is +committed at `f516abb4e98696cc61003de55518961245416a40`. This reviewer checked +all 194 recorded source hashes against the source commit's Git blobs and +confirmed that the Lean project, exact claim, and certificate are unchanged +from the original mathematical review. + +All 12 recorded stages completed with status `passed`, no failure classification, +and the exact reviewed timeout policy. The kernel stage names 179 local modules +and records exit code 0 after 1,733.691 seconds. The 19 declaration reports +contain only the allowed standard axioms. All seven deliberate bad bindings +completed with exit code 1; their saved diagnostics identify false propositions +or the expected mathematical type mismatches. No timeout or interrupted process +is counted as a successful rejection. The 20 artifact hashes exclude the +receipt itself. The normalized receipt SHA-256 is +`f7548e47de85f73ff2b88ce6da23b007d531030cd979d1a285f0c7287b5ff581`. + +This reviewer independently ran saved-receipt replay and all 84 focused tests +on WSL/Linux; all passed in 88.836 seconds with no skips. That total comprises +the earlier 73 certificate, play, presentation and proof/query tests plus 11 +runner fixtures. Presentation freshness and the full renderer check also +passed. The renewed 219-input publication anchor identifies commit +`f516abb4e98696cc61003de55518961245416a40`; the generated JSON, JavaScript +wrapper, exact claim and evidence URLs agree. The updated walkthrough correctly +identifies the warmed-cache run and retains the original receipt in Git history. + +This approval covers the revised runner, renewed local receipt and regenerated +presentation records. The reviewer did not start another Lean execution; saved +receipt validation remains distinct from the recorded kernel run. The local +build reused its existing cache, so it does not resolve the fresh hosted-build +gate. Hosted CI, HTTP checks for the newly pushed evidence commit, merge and +public deployment remain separate release gates. No model benchmark or training +was resumed. + +## Hosted kernel-timeout recovery review + +The subsequent hosted PR receipt (`39280967879`) records successful compilation +in 1,980.924 seconds followed by kernel timeout at 2,400.105 seconds. This +reviewer checked its diagnostic artifact hashes and independently audited its +19 axiom reports. The kernel failure is recorded as a timeout with exit -9 +from cleanup; no negative controls ran. It is not an accepted proof receipt, +and the available evidence does not establish an out-of-memory failure. + +The next operational candidate is **approved to freeze and execute**. Kernel +replay receives 7,200 seconds, compilation retains 3,600, and other stages +retain 2,400. The 210-minute CI job leaves time beyond the two long-stage caps +for setup, other proofs, controls and artifact upload. Host capacity and GNU +time measurements remain diagnostic sidecars outside the proof artifact set. + +This reviewer independently inspected the pinned +[Lean checker source](https://github.com/leanprover/lean4/blob/5045d0056413266e57c625dcd7c365b10e377c52/src/LeanChecker.lean). +Its discovery loop scans the module search path for each selector. Nine exact +names or namespace prefixes preserve the same 179-module selection while +reducing those scans. The new runner checks selector coverage against the +local import closure, requests verbose output, and requires the exact complete +module inventory plus successful process exit in both execution and saved +replay. The announcement precedes waiting on a task; it alone does not certify +completion. The speed effect is still unmeasured at this review. + +Review found and resolved a parsing gap: the first inventory parser ignored +unexpected module names containing apostrophes or Unicode. The final parser +collects every announced module suffix before exact comparison, so these extra +names and malformed suffixes fail validation. The reviewer independently ran +12 runner tests and six input tests on WSL/Linux; all 18 passed in 16.428 +seconds. After that parsing correction, all six input tests passed again in +8.232 seconds, including the added naming controls. No Lean execution was +started by this review. + +The theorem sources, exact claim, axiom policy and seven negative bindings +remain unchanged. The preceding receipt stays preserved in Git history, with +its original runner identity and command list. This updated runner requires a +new actual completed receipt, exact verbose inventory, and renewed publication +anchor before full evidence approval. Those gates and hosted reproduction are +pending. No benchmark or training was resumed. + +## Final recovery receipt and publication review + +**Approved** after independent inspection of the completed replacement receipt +and publication anchor. This closes the pending local evidence gates in the +preceding section. The run used frozen source commit +`c3af350005f413554aea03db8cbf2c4c2d09e31b`; its receipt is committed at +`3bd96caa445c459371128e882fe420479084924e`. This reviewer matched all 194 source +hashes to the frozen commit's Git blobs and confirmed that the Lean project, +exact claim, certificate, computational record, saved play, independent +checkers and query implementation remain unchanged from the prior approval. + +All 12 recorded stages passed with no failure classification and the reviewed +timeout policy. The kernel stage completed with exit code 0 in 1,303.713 seconds; +its verbose log contains each of the required 179 modules exactly once and no +additional module. The 19 declaration reports use only the allowed standard +axioms. All seven negative bindings completed with exit code 1, with diagnostics +for the expected false propositions or mathematical type mismatches. The 20 +artifact hashes exclude the receipt itself. Its normalized SHA-256 is +`9e2f9fafa6882ca21a89775671fe58bb21850faecf96f3c4916f8a7957e2079d`. +The measured kernel duration describes this warmed-cache run; it is not a +controlled measurement of the discovery optimization's speed benefit. + +This reviewer independently ran saved-receipt replay and the complete focused +`test_snaky*.py` suite on WSL/Linux. All **88 tests passed in 105.372 seconds**, +with no skips. This includes the exact kernel-inventory controls, failed-stage +and process-cleanup fixtures, actual receipt replay, theorem/claim mutations, +and checks of the generated presentation against its 219-input Git anchor at +`3bd96caa445c459371128e882fe420479084924e`. The implementation agent separately +reported passing presentation-freshness and full-renderer checks. This review +started no new Lean execution and did not repeat the earlier browser review; +the mathematical and viewer sources are unchanged by this recovery. + +No additional actionable finding remains for the local candidate. Successful +fresh hosted CI is still required before merge. HTTP checks of the new immutable +evidence links follow pushing the anchor commit, and the public demo requires +its deployment check. The locally warmed build and receipt inspection do not +establish completion of those release gates. Model benchmarks, reserved tasks +and training remain paused. + +## Process-observation test race follow-up + +**Approved** the narrow test-only correction following push run `39316093274`, +Python 3.10 job `118277828681`. The saved traceback shows `ProcessLookupError` +(errno 3) during the read of `/proc//stat` in the child-cleanup assertion. +A process can disappear after the file is opened. The helper now accepts that +exception alongside `FileNotFoundError`; it continues to propagate permission +errors and reject a live process at its deadline. + +This reviewer independently ran the two new deterministic WSL/Linux tests; +both passed in 0.002 seconds. They cover both disappearance exceptions, +unreadable process status, and a still-live sleeping process. The reviewed code +delta changes only `scripts/test_snaky_runner.py`. That file is absent from +both the receipt's 194-source hash set and the publication anchor's 219 inputs, +so the production runner, mathematical sources, receipt and evidence anchor +retain their prior identities. No proof execution was started for this review. +Hosted checks for the corrected candidate remain the release gate. diff --git a/docs/assets/snaky-board.svg b/docs/assets/snaky-board.svg new file mode 100644 index 0000000..11830ff --- /dev/null +++ b/docs/assets/snaky-board.svg @@ -0,0 +1,361 @@ + +The 251-cell Snaky certificate support inside a 17 by 17 board +Coordinates run from 0 to 16 on both axes. Blue cells form the 251-cell support of card 727. P marks the root pivot at (8,8). Six green cells labelled S1 through S6 illustrate one Snaky target; they are not occupied starting cells or an execution trace. Before Maker move 21, at most 40 cells are occupied, leaving at least 211 support cells free. + + +A finite board with room for every required move +Exact certificate: 728 cards · final support: 251 cells · height: 21 Maker moves +(0,0): square cell outside the support +(1,0): square cell outside the support +(2,0): square cell outside the support +(3,0): square cell outside the support +(4,0): certificate support +(5,0): certificate support +(6,0): certificate support +(7,0): certificate support +(8,0): certificate support +(9,0): certificate support +(10,0): certificate support +(11,0): certificate support +(12,0): square cell outside the support +(13,0): square cell outside the support +(14,0): square cell outside the support +(15,0): square cell outside the support +(16,0): square cell outside the support +(0,1): square cell outside the support +(1,1): square cell outside the support +(2,1): certificate support +(3,1): certificate support +(4,1): certificate support +(5,1): certificate support +(6,1): certificate support +(7,1): certificate support +(8,1): certificate support +(9,1): certificate support +(10,1): certificate support +(11,1): certificate support +(12,1): certificate support +(13,1): certificate support +(14,1): certificate support +(15,1): square cell outside the support +(16,1): square cell outside the support +(0,2): square cell outside the support +(1,2): certificate support +(2,2): certificate support +(3,2): certificate support +(4,2): certificate support +(5,2): certificate support +(6,2): certificate support +(7,2): certificate support +(8,2): certificate support +(9,2): certificate support +(10,2): certificate support +(11,2): certificate support +(12,2): certificate support +(13,2): certificate support +(14,2): certificate support +(15,2): square cell outside the support +(16,2): square cell outside the support +(0,3): square cell outside the support +(1,3): certificate support +(2,3): certificate support +(3,3): certificate support +(4,3): certificate support +(5,3): certificate support +(6,3): certificate support +(7,3): certificate support +(8,3): certificate support +(9,3): certificate support +(10,3): certificate support +(11,3): certificate support +(12,3): certificate support +(13,3): certificate support +(14,3): certificate support +(15,3): certificate support +(16,3): square cell outside the support +(0,4): certificate support +(1,4): certificate support +(2,4): certificate support +(3,4): certificate support +(4,4): certificate support +(5,4): certificate support +(6,4): certificate support +(7,4): certificate support +(8,4): certificate support +(9,4): certificate support +(10,4): certificate support +(11,4): certificate support +(12,4): certificate support +(13,4): certificate support +(14,4): certificate support +(15,4): certificate support +(16,4): certificate support +(0,5): certificate support +(1,5): certificate support +(2,5): certificate support +(3,5): certificate support +(4,5): certificate support +(5,5): certificate support; illustrative target cell S1 +S1 +(6,5): certificate support; illustrative target cell S2 +S2 +(7,5): certificate support; illustrative target cell S3 +S3 +(8,5): certificate support; illustrative target cell S4 +S4 +(9,5): certificate support +(10,5): certificate support +(11,5): certificate support +(12,5): certificate support +(13,5): certificate support +(14,5): certificate support +(15,5): certificate support +(16,5): certificate support +(0,6): certificate support +(1,6): certificate support +(2,6): certificate support +(3,6): certificate support +(4,6): certificate support +(5,6): certificate support +(6,6): certificate support +(7,6): certificate support +(8,6): certificate support; illustrative target cell S5 +S5 +(9,6): certificate support; illustrative target cell S6 +S6 +(10,6): certificate support +(11,6): certificate support +(12,6): certificate support +(13,6): certificate support +(14,6): certificate support +(15,6): certificate support +(16,6): certificate support +(0,7): certificate support +(1,7): certificate support +(2,7): certificate support +(3,7): certificate support +(4,7): certificate support +(5,7): certificate support +(6,7): certificate support +(7,7): certificate support +(8,7): certificate support +(9,7): certificate support +(10,7): certificate support +(11,7): certificate support +(12,7): certificate support +(13,7): certificate support +(14,7): certificate support +(15,7): certificate support +(16,7): certificate support +(0,8): certificate support +(1,8): certificate support +(2,8): certificate support +(3,8): certificate support +(4,8): certificate support +(5,8): certificate support +(6,8): certificate support +(7,8): certificate support +(8,8): certificate support; root pivot P +P +(9,8): certificate support +(10,8): certificate support +(11,8): certificate support +(12,8): certificate support +(13,8): certificate support +(14,8): certificate support +(15,8): certificate support +(16,8): certificate support +(0,9): certificate support +(1,9): certificate support +(2,9): certificate support +(3,9): certificate support +(4,9): certificate support +(5,9): certificate support +(6,9): certificate support +(7,9): certificate support +(8,9): certificate support +(9,9): certificate support +(10,9): certificate support +(11,9): certificate support +(12,9): certificate support +(13,9): certificate support +(14,9): certificate support +(15,9): certificate support +(16,9): certificate support +(0,10): certificate support +(1,10): certificate support +(2,10): certificate support +(3,10): certificate support +(4,10): certificate support +(5,10): certificate support +(6,10): certificate support +(7,10): certificate support +(8,10): certificate support +(9,10): certificate support +(10,10): certificate support +(11,10): certificate support +(12,10): certificate support +(13,10): certificate support +(14,10): certificate support +(15,10): certificate support +(16,10): certificate support +(0,11): certificate support +(1,11): certificate support +(2,11): certificate support +(3,11): certificate support +(4,11): certificate support +(5,11): certificate support +(6,11): certificate support +(7,11): certificate support +(8,11): certificate support +(9,11): certificate support +(10,11): certificate support +(11,11): certificate support +(12,11): certificate support +(13,11): certificate support +(14,11): certificate support +(15,11): certificate support +(16,11): certificate support +(0,12): certificate support +(1,12): certificate support +(2,12): certificate support +(3,12): certificate support +(4,12): certificate support +(5,12): certificate support +(6,12): certificate support +(7,12): certificate support +(8,12): certificate support +(9,12): certificate support +(10,12): certificate support +(11,12): certificate support +(12,12): certificate support +(13,12): certificate support +(14,12): certificate support +(15,12): certificate support +(16,12): square cell outside the support +(0,13): square cell outside the support +(1,13): certificate support +(2,13): certificate support +(3,13): certificate support +(4,13): certificate support +(5,13): certificate support +(6,13): certificate support +(7,13): certificate support +(8,13): certificate support +(9,13): certificate support +(10,13): certificate support +(11,13): certificate support +(12,13): certificate support +(13,13): certificate support +(14,13): certificate support +(15,13): certificate support +(16,13): square cell outside the support +(0,14): square cell outside the support +(1,14): square cell outside the support +(2,14): certificate support +(3,14): certificate support +(4,14): certificate support +(5,14): certificate support +(6,14): certificate support +(7,14): certificate support +(8,14): certificate support +(9,14): certificate support +(10,14): certificate support +(11,14): certificate support +(12,14): certificate support +(13,14): certificate support +(14,14): certificate support +(15,14): certificate support +(16,14): square cell outside the support +(0,15): square cell outside the support +(1,15): square cell outside the support +(2,15): certificate support +(3,15): certificate support +(4,15): certificate support +(5,15): certificate support +(6,15): certificate support +(7,15): certificate support +(8,15): certificate support +(9,15): certificate support +(10,15): certificate support +(11,15): certificate support +(12,15): certificate support +(13,15): certificate support +(14,15): square cell outside the support +(15,15): square cell outside the support +(16,15): square cell outside the support +(0,16): square cell outside the support +(1,16): square cell outside the support +(2,16): square cell outside the support +(3,16): square cell outside the support +(4,16): square cell outside the support +(5,16): certificate support +(6,16): certificate support +(7,16): certificate support +(8,16): certificate support +(9,16): certificate support +(10,16): certificate support +(11,16): certificate support +(12,16): certificate support +(13,16): square cell outside the support +(14,16): square cell outside the support +(15,16): square cell outside the support +(16,16): square cell outside the support +0 +0 +1 +1 +2 +2 +3 +3 +4 +4 +5 +5 +6 +6 +7 +7 +8 +8 +9 +9 +10 +10 +11 +11 +12 +12 +13 +13 +14 +14 +15 +15 +16 +16 +x coordinate +y coordinate +How to read the board + +251 cells in the final support + +38 other cells of the square board + +P: first prescribed pivot, (8,8) + +S1–S6: one illustrative Snaky target + +Why a replacement cell is available +If play reaches Maker move 21: +20 Maker claims + 20 Breaker claims +occupy at most 40 cells. +251 − 40 = 211 +At least 211 support cells are still free. +All cells start unclaimed. The highlighted +target is an illustration; no play trace is shown. +The diagram shows a fixed support. The proof +also handles every legal Breaker reply. +Generated from the pinned certificate and independent audit · finite-congruence-checks + diff --git a/evidence/snaky-finite-v1/certificate.txt b/evidence/snaky-finite-v1/certificate.txt new file mode 100644 index 0000000..265eedc --- /dev/null +++ b/evidence/snaky-finite-v1/certificate.txt @@ -0,0 +1,722 @@ +6 14 4:100 5:101 +7 05 6:001 6:405 +8 41 6:101 6:301 +9 15 6:011 6:615 +10 14 5:714 8:101 +11 11 0:305 5:304 +12 15 7:616 8:102 9:626 +13 15 7:211 8:102 9:626 +14 15 7:616 8:102 9:001 +15 14 0:100 0:715 +16 04 4:304 6 +17 14 6:010 16:211 +18 14 4:714 8:101 +19 01 5:714 18:001 +20 14 0:715 6:010 +21 04 5:304 6 +22 03 0:305 5:304 +23 04 0:305 5:304 +24 41 4:641 6:101 +25 30 2:324 5:401 +26 41 6:101 7:301 +27 04 5:304 16:001 +28 12 5:314 5:714 +29 04 0:305 6 +30 02 0:304 5:100 +31 15 8:102 8:305 +32 30 0:324 5:401 +33 15 7:211 8:305 9:221 +34 03 5:101 5:304 +35 32 1:734 5:001 +36 14 2:100 2:714 +37 14 5:714 6:010 +38 32 0:734 5:001 +39 13 5:714 8:101 +40 13 5:111 5:714 +41 14 6:210 24:101 +42 13 5:714 24:101 +43 14 0:715 3:714 +44 14 0:100 43:001 +45 33 5:002 23:230 +46 31 5:402 45 +47 42 7:102 9:303 46:010 +48 14 5:714 24:101 +49 41 6:301 9:100 +50 12 5:714 8:101 +51 14 0:715 3:100 +52 14 0:100 51:001 +53 01 0:100 51:001 +54 02 0:100 51:001 +55 34 5:003 53:020 +56 34 5:003 53:636 +57 34 52:103 53:636 +58 43 2:002 52:030 +59 32 28:542 31:020 58:001 +60 03 0:242 52:210 +61 13 0:100 51:001 +62 15 6:415 6:615 +63 14 16:211 24:101 62:405 +64 02 0:100 43:001 +65 15 20:002 20:405 +66 14 0:715 5:314 +67 11 8:101 32:304 +68 02 0:716 1:100 +69 31 5:402 15:230 +70 13 2:714 3:100 +71 21 0:241 10:220 +72 32 20:101 29:302 46 +73 23 0:643 52:010 +74 13 30 30:210 36 36:210 +75 04 20:002 23:615 +76 14 4:714 5:314 +77 21 3:001 5:314 +78 30 5:401 77:540 +79 34 8:121 78:744 +80 13 5:314 5:714 +81 32 5:001 42:020 +82 43 52:030 64:102 +83 14 5:314 5:714 +84 15 6:615 17:002 +85 25 15:626 65:417 72:305 +86 12 2:715 78:744 +87 42 11:030 35:744 +88 34 52:103 53:020 +89 14 4:714 7:010 +90 41 6:301 37:110 +91 14 4:714 16:011 +92 33 5:002 69 +93 41 6:101 21:311 +94 03 0:304 5:100 +95 15 19:002 19:407 49:103 49:306 +96 30 4:530 5:401 +97 12 5:714 24:101 +98 02 5:304 16:001 +99 32 5:403 44:230 +100 41 2:402 10:240 +101 03 0:100 51:001 +102 13 0:715 5:314 +103 04 6 11 +104 14 10:002 10:406 52:212 52:616 +105 03 5:101 11 +106 11 4:714 7:010 +107 12 3:714 18:001 +108 11 15:010 102:303 +109 23 5:403 44:230 +110 34 12:240 28:542 58:001 100:001 +111 43 17:112 55:240 +112 23 34:303 44:010 +113 13 0:100 23:002 +114 34 5:003 14:020 +115 32 5:403 114 +116 43 7:103 9:102 115:240 +117 43 7:303 9:304 115:240 +118 43 7:303 9:102 115:010 +119 23 5:403 114 +120 23 44:303 52:303 116 +121 30 1:324 5:401 +122 24 8:111 46:304 +123 41 4:241 4:641 +124 21 5:314 123:101 +125 12 5:714 124 +126 12 5:714 123:101 +127 15 7:416 24:102 124:001 +128 15 9:406 16:212 124:001 +129 12 0:715 3:714 +130 14 3:100 129 +131 13 0:242 15 +132 13 5:242 131:010 +133 11 5:642 132 +134 42 16:112 24:413 133:250 +135 25 7:021 9:636 133:101 +136 24 21:221 37:011 133:305 +137 42 7:102 9:303 133:250 +138 14 3:100 3:714 +139 13 0:100 138:001 +140 13 0:100 43:001 +141 14 53 53:616 76:102 +142 12 5:643 141:010 +143 41 6:101 11:301 +144 32 46 103:302 143:001 +145 32 5:001 10:020 +146 21 5:001 5:314 +147 32 5:001 39:020 +148 14 4:714 21:011 +149 13 5:714 124 +150 12 5:714 7:010 +151 42 21:031 35:744 +152 23 5:413 99:240 +153 14 4:714 5:243 +154 13 0:715 3:714 +155 42 7:302 9:101 46:010 +156 31 2:324 5:401 +157 40 4:401 156:010 +158 04 6:001 6:405 +159 31 23:101 66:010 +160 12 5:714 11:415 +161 43 6:103 142 +162 43 6:303 142 +163 02 3:100 129 +164 33 0:643 55 +165 43 44:030 64:102 +166 33 14:240 28:542 58:001 100:001 +167 32 5:001 152:305 +168 22 5:642 131:010 +169 14 1:100 1:716 +170 12 2:242 3:714 +171 43 6:303 26:414 116:010 +172 43 142 142:656 +173 43 142 142:250 +174 35 116:102 117:306 135:011 135:657 173:306 173:562 +175 15 7:211 32:102 60:406 +176 22 0:242 60:240 +177 11 0:642 23 +178 11 5:642 177:010 +179 13 5:242 178 +180 42 16:112 24:413 179:250 +181 42 7:102 9:303 179:250 +182 25 7:426 9:011 179:101 +183 42 5:012 178:250 +184 23 99:240 179:655 +185 14 5:101 113 +186 11 6:615 185:010 +187 06 6:002 7:002 185:407 +188 25 8:112 26:532 133:306 186:417 187:020 +189 15 8:102 26:102 62:406 186:627 187:210 +190 25 8:112 26:112 179:306 186:637 187:220 +191 01 5:714 89:001 +192 15 9:001 9:626 186 187:010 191:001 +193 15 7:616 26:522 191:001 +194 14 4:714 9:220 +195 14 5:714 7:010 +196 30 5:401 143:010 +197 41 6:301 8:010 26:010 196 +198 15 0:716 6:415 +199 11 0:510 198 +200 13 3:100 3:714 +201 30 5:401 146:540 +202 32 5:001 27:230 +203 13 5:314 202:101 +204 23 52:416 203:102 +205 15 6:415 23:212 +206 11 0:510 205 +207 31 5:401 77:540 +208 40 4:401 207:010 +209 14 0:715 138:614 +210 00 1:714 4:641 +211 35 7:636 8:122 151:001 +212 14 5:714 76:001 +213 14 53:220 53:416 212:304 +214 34 5:003 213:416 +215 31 5:402 11:230 +216 43 52:030 54:102 +217 24 21:221 37:011 179:305 +218 12 0:714 83:404 +219 11 4:714 11:615 +220 31 0:241 5:324 +221 13 5:520 220:404 +222 21 5:521 220 +223 30 5:401 6:030 +224 31 5:001 5:734 +225 15 6:615 26:522 +226 41 4:241 32:010 +227 14 0:100 53:220 +228 32 52:303 227:010 +229 33 5:002 215 +230 42 7:302 9:101 229:010 +231 43 8:012 55:240 +232 14 5:714 26:521 +233 41 6:101 27:311 +234 21 5:314 148:221 +235 21 5:314 226:101 +236 15 6:615 32:102 +237 01 0:642 10 +238 24 0:725 133:305 +239 31 11:635 25:744 +240 23 0:643 52:230 +241 21 5:314 91:221 +242 42 5:242 69:010 +243 22 10:221 242 +244 14 5:243 5:714 +245 14 5:314 32:101 +246 14 5:714 25:101 +247 34 11:030 35:744 +248 25 44:626 47:306 127:011 +249 42 17:241 35:744 +250 12 0:510 195 +251 42 4:001 224:010 +252 24 55:406 56:406 91:112 +253 43 6:303 18:112 252 +254 15 11:211 75 103:615 +255 32 5:403 254:020 +256 34 5:003 255 +257 43 7:103 9:304 256:010 +258 33 8:002 161:406 162:406 256 +259 24 15:011 159:405 +260 30 5:401 208:540 +261 13 3:100 129 +262 11 15:010 66:303 +263 34 7:030 9:240 78:541 +264 14 8:101 201:304 +265 14 4:714 93:101 +266 06 6:002 16:003 113:407 +267 25 8:112 17:012 75:010 179:306 266:220 +268 14 7:616 8:102 9:626 +269 15 7:416 21:212 +270 42 70:742 106:101 122:110 269:101 +271 23 5:403 52:230 +272 21 5:001 39:020 +273 33 2:003 206:030 +274 32 13:020 44:303 83:542 +275 42 16:312 24:011 179:250 +276 24 44:626 52:626 155:306 275:102 +277 13 0:252 69:240 +278 42 6:302 277 +279 43 6:303 141:010 +280 12 3:714 6:012 +281 13 2:243 3:100 +282 32 20:303 29:102 92 +283 22 1:002 282:020 +284 13 8:103 17:003 19:407 75:001 +285 43 6:103 26:012 117:010 +286 42 35:744 253:561 +287 16 169:616 230:552 +288 15 54:305 68 +289 12 22 28:405 126:625 +290 21 5:241 203 +291 34 7:230 25:541 +292 43 6:103 19:102 214 +293 43 17:112 56:240 +294 33 10:102 48:102 165:306 +295 31 34:551 180:560 +296 23 0:725 132:305 +297 53 9:764 142:010 162:426 +298 53 7:763 142:010 161:426 +299 35 12:427 165:002 264:242 +300 25 44:626 52:626 128:011 155:306 +301 33 23:303 55 +302 53 6:753 214:416 +303 34 55:416 234:304 +304 14 7:211 8:102 9:626 +305 13 5:714 124:405 +306 41 18:241 207:744 +307 42 5:642 131:010 +308 15 44:616 52:616 63:002 158:616 +309 43 19:102 19:304 115:240 +310 13 5:714 76:001 +311 31 4:401 (41 5:411 6:101) +312 21 5:314 311:402 +313 30 5:401 312:540 +314 41 6:301 8:010 17:110 (30 5:401 20:110) +315 14 5:714 314:101 +316 12 8:305 314:102 +317 35 44:104 60:242 316:020 +318 13 10:406 52:212 52:616 315:002 +319 34 52:305 318:020 +320 35 5:004 316:020 +321 33 5:404 320 +322 44 7:304 9:103 321:010 +323 24 11:754 320:240 +324 13 60:406 237:002 307:002 316:220 +325 34 5:244 321:010 +326 24 3:644 321:020 +327 44 32:013 321:240 +328 34 7:104 9:305 321:010 +329 14 10:406 52:212 52:616 315:002 +330 34 7:304 9:103 321:010 +331 34 5:003 (32 5:403 (35 20:022 29:635)) +332 43 9:102 11:103 331:240 +333 14 3:714 (02 0:715 3:100) +334 15 101:001 101:616 333:002 333:615 +335 33 52:102 334:230 +336 14 6:010 18:001 (23 5:110 (15 4:715 37:222)) +337 12 7:416 143:305 336:002 +338 24 44:626 47:306 337:010 +339 42 35:744 336:241 +340 06 139:212 148:406 (16 5:513 91:003) +341 44 53:764 57:562 340:020 +342 31 5:402 (34 11:230 78:541) +343 33 5:002 342 +344 13 5:242 343:010 +345 42 8:011 11:102 344 +346 23 0:643 342:405 +347 13 20 29:210 (03 5:510 (23 5:110 94:303)) +348 31 5:001 (30 5:401 311:120) +349 35 12:241 165:002 216:406 (43 10:242 54:304) +350 40 4:401 (41 1:334 5:411) +351 31 5:001 350 +352 42 4:001 351:010 +353 46 95:659 352:102 +354 30 5:401 (32 5:001 70:230) +355 34 8:121 354:744 +356 35 7:436 8:122 (23 21:232 121:745) +357 23 5:530 (43 5:130 (13 4:643 (14 3:100 5:243))) +358 24 5:111 357:304 +359 14 10:406 52:212 52:616 (16 5:716 9:222) +360 24 22:220 347:101 (23 5:724 45:304) +361 31 15:230 57:100 360:111 +362 13 2:003 (14 2:644 53:616) +363 44 44:031 362 +364 44 52:031 362 +365 16 6:012 (03 5:716 (04 0:510 0:717)) +366 11 6:615 365:220 +367 15 8:102 9:626 366 +368 45 14:437 31:437 181:562 189:031 257:572 355:416 367:657 +369 16 7:617 19:002 187:618 (17 6:213 8:104 365:002) +370 41 6:301 (12 16:111 210) +371 41 6:101 8:010 370:010 (51 6:311 (22 210:010 (32 0:261 5:001))) +372 42 96:304 (44 81:101 351:010) +373 14 5:314 372 +374 42 4:001 (41 1:744 5:011) +375 31 5:401 374 +376 30 5:401 (24 2:324 77:540) +377 14 7:210 9 376:101 +378 31 5:402 (33 5:002 18:020) +379 32 21:302 37:101 378 +380 32 5:001 (30 5:401 379:110) +381 31 5:001 (40 4:401 (41 0:334 5:411)) +382 14 22:210 381:541 +383 31 5:402 (33 5:002 219:425) +384 33 8:121 383:754 +385 33 115:101 383:754 +386 31 5:402 (33 5:002 (34 5:531 11:230)) +387 42 200:101 376:110 386:100 +388 24 11:220 387:001 +389 04 6 21:001 27:001 (13 5:100 23:001) +390 17 11:213 17:004 389:617 +391 24 5:111 (21 5:314 (31 0:241 36:424)) +392 33 0:643 391 +393 14 11:010 20:001 391:405 +394 14 17:001 241 392 +395 33 5:002 (31 5:402 217:010) +396 26 7:222 9:232 395:306 +397 33 8:002 161 162 395:001 +398 33 171 197:002 197:404 285 395:001 +399 25 12:011 135:001 181:102 396 396:408 +400 32 5:642 395:010 +401 24 3:644 397:427 +402 31 38:304 (24 0:530 5:111) +403 15 86 (25 4:531 381:542) +404 24 5:111 (21 5:314 (31 0:241 354)) +405 14 0:715 404 +406 14 199 199:406 405:001 405:405 +407 14 7:010 8:101 9:220 (04 5:511 404:405) +408 15 44:616 127:001 407:406 +409 14 44:616 127:001 407:406 +410 15 10:002 12:221 12:407 407:406 +411 15 15:616 65:407 407:406 +412 21 5:314 (31 0:241 358) +413 24 5:111 (23 5:724 45:101) +414 14 0:315 413 +415 32 2:402 414:250 +416 33 5:002 (31 5:402 239:405) +417 32 0:242 416 +418 30 5:401 (32 5:001 (33 8:120 25:540 41:020 (22 5:002 29:230))) +419 21 5:314 418:101 +420 31 0:241 418 +421 14 8:101 11:010 419 +422 22 0:002 (42 69:010 413:551) +423 23 383:415 (12 5:643 244) +424 34 7:030 25:541 (42 2:403 11:030) +425 43 2:643 (32 2:002 44:030) +426 24 11:220 (33 0:653 221:241) +427 21 5:314 (24 5:111 (04 5:511 (01 5:714 (31 17:302 357:304 (42 4:001 (41 5:011 (43 70:304 226:010))) (30 52:301 (23 2:324 (33 0:243 2:530))))))) +428 14 7:010 8:101 9:220 427:405 +429 34 7:230 8:121 9:020 (43 2:002 46:551) +430 35 14:427 31:427 58:002 100:406 429:002 +431 44 160:754 243:250 429:011 +432 40 4:401 (41 5:411 146:550) +433 34 86 432:541 +434 32 80:551 (51 1:412 10:250) (44 8:551 41:031 253:111 256:571 336:031) +435 42 130:313 140:303 183:405 (34 52:103 76:542 (32 0:403 212:241) (35 76:242 130:435 (32 5:335 11:231))) +436 35 10:022 47:316 52:636 435:562 +437 34 10:022 47:316 52:636 435:562 +438 43 10:764 47:665 436:020 +439 33 5:404 (32 251:745 432:745 (42 2:642 5:335) (21 4:735 (31 5:734 (41 5:334 5:241)))) +440 01 18:001 (11 5:714 439:754) +441 33 28:102 58:241 440 +442 33 40:754 149:754 440 +443 21 5:314 (01 5:714 (31 4:001 (40 4:401 (24 5:111 (41 5:411 (33 5:540 (53 3:253 5:140))))))) +444 14 7:010 8:101 9:220 443:405 +445 30 5:401 (33 20:020 29:230 221:010) +446 23 5:316 (24 0:317 72:405) +447 24 5:111 (23 0:110 445:101) +448 13 56:646 447:102 +449 43 10:314 27:113 48:314 63:314 448 +450 34 0:654 448:407 +451 14 11:210 (23 0:643 402) +452 44 52:764 317:020 (64 5:664 55:031) +453 32 5:001 (30 5:401 (33 21:230 37:020 354:540)) +454 13 5:111 453:304 +455 11 8 16:101 24:402 453 +456 24 5:111 453:304 +457 14 7:010 8:101 9:220 456:405 +458 14 7:010 9 62 456 +459 16 12:222 13:222 33:628 189:222 192:408 369:221 457:003 458:407 +460 14 13:001 14:221 33:001 457:406 458:002 +461 33 28:541 100 429 457:020 +462 15 13:221 14:627 31:407 189:221 367:407 428:406 457:002 +463 45 147:102 167:102 (26 4:112 348:103) 353 460:438 +464 12 15:211 (22 0:242 (11 0:510 11:010)) (15 29:212 38:305) +465 32 25:304 (45 39:031 42:031 (04 5:511 (24 5:111 (34 4:404 4:004)))) +466 14 7:210 8:101 9 465 +467 46 31:658 398:114 444:657 466:657 +468 34 28:103 126:103 126:305 (35 54:305 (33 71:646 71:242 73:646 73:242) (33 71:242 73:646 426:656 (36 8:123 17:243 75:241 266:031 447:022))) +469 32 78:304 (23 101:303 314:521) +470 33 319:010 335:417 (23 54:636 78:646) (36 56:418 (23 2:736 78:646)) +471 33 5:002 (34 11:230 354:541) +472 43 5:012 471:240 +473 11 5:642 472 +474 42 7:102 8:011 9:303 473:250 +475 25 13:417 14:637 31:417 396:408 474:102 +476 35 12:021 12:241 12:427 264:242 474:316 +477 42 7:102 9:101 62:101 473 +478 22 5:642 472 +479 35 14:647 31:427 181:112 367:427 (32 8:745 386:552) 435:562 474:112 +480 33 13:427 14:427 192:241 298:101 435:766 474:756 477:552 +481 24 13:011 14:231 33:011 457:416 477:102 +482 22 7:102 24:011 124:101 472 +483 25 13:011 14:231 33:011 458:012 474:306 +484 45 81:102 204:408 (32 (22 5:315 96:305) (44 18:032 33:437 130:645) (42 39:031 268:250 (22 5:315 223:305))) (24 314:522 (44 58:012 168:656 357:645)) +485 43 313:305 469:001 (45 81:102 204:408 353 481:428) (45 81:102 167:102 (44 14:251 189:031 192:251 193:251 457:032 477:326) (24 166:011 314:522)) 484 +486 43 19:102 84:102 314:012 (12 5:643 (42 5:413 (14 5:243 156:304))) +487 23 5:530 486 +488 46 95:659 (26 4:112 (16 5:113 34:306)) (44 7:042 9:252 357:013) +489 38 313:254 470:41A (56 5:025 (57 10:044 44:658 63:044 486:328)) (58 81:024 167:024 481:586 488:104) +490 57 321:023 321:42B 485:106 485:308 489:002 489:40C +491 33 44:240 270:011 (53 60:324 60:764 83:434 106:112) (53 60:324 70:753 345:425) +492 12 78:744 (13 0:715 (23 0:643 32:541)) +493 33 87 197:541 492 +494 33 7:030 87 286 492 +495 24 10:012 52:222 52:626 (22 5:522 221:405) +496 11 5:304 (12 0:305 30:101) +497 03 5:101 496 +498 43 114:111 496:240 +499 21 15:220 (43 1:643 347:011) (33 43:102 52:020) +500 12 0:715 (11 5:511 146) +501 13 2:243 500 +502 43 7:103 69:415 (24 11:103 53:426) +503 23 0:403 502 +504 31 32:744 (35 6:031 18:022 (23 0:736 56:101)) +505 41 6:301 (42 5:011 350:010) (42 5:011 (43 5:744 6:041)) +506 15 44:416 67:001 (12 7:416 32:305) +507 34 44:103 274 506:240 (35 33:647 44:636 47:316) +508 43 12:102 13:102 14:102 297 298 474:415 507:010 +509 43 12:304 127:102 128:102 474:011 507:010 +510 43 10:314 (14 0:253 138:543) 507:010 +511 14 15:615 (34 13:240 14:240 240:001 (44 2:644 44:031) (24 0:644 (35 7:031 9:241 221:012))) +512 43 74:113 108:001 (33 69:241 416:011) (44 30:314 59:417 511:011 (45 (34 0:654 5:014) (36 18:436 382:012))) +513 14 7:210 9 (04 5:511 439:551) +514 32 34:752 149:551 513 +515 21 2:724 (31 0:641 78) +516 43 52:030 (23 3:643 83:644) 515:101 +517 44 74:314 (34 0:654 404:103) (43 30:113 59:010 346:416 (45 14:657 79:416 367:437 513:252 516:012)) (43 36:314 59:417 346:416 (45 14:437 58:012 79:416 429:012)) +518 46 61:032 89:646 183:112 (36 5:133 (37 6:233 213:564 278:114)) +519 35 10:022 47:316 52:636 518:260 +520 45 10:326 317:669 519:262 +521 21 5:314 (24 5:111 (23 45:101 45:304)) +522 42 8:011 11:102 (13 5:242 416:010) +523 35 14:021 122:012 136:416 367:241 522:756 +524 35 88:306 213:102 254:021 522:756 +525 30 5:401 (32 5:001 (33 21:230 37:020 78:540)) +526 31 0:241 525 +527 22 206:010 (25 23:222 198:416) 405:415 (25 7:021 23:222 (33 392:416 417:011 420:012 521:011 522:405 526:012)) +528 07 61:213 (13 4:513 49:726) (17 5:514 446:001) +529 56 12:262 181:133 189:262 369:261 474:133 528:040 (53 133:337 (66 5:153 (46 5:553 (75 (36 4:666 4:436) (73 38:346 351:447)))) 505:766) +530 24 72:405 360:405 499:001 (22 23:625 (32 51:303 (25 5:325 20:012))) +531 14 0:100 530 +532 23 44:022 52:022 134:306 (26 19:232 84:232 314:533 521:417) +533 43 11:303 279:010 (34 53:020 55:416 392:754) +534 25 44:426 52:426 388:305 (36 139:022 (26 5:123 177:103) (35 0:122 239:756)) +535 35 345:407 421:306 522:407 530:418 532 533:002 534:408 +536 35 14:241 88:766 213:562 534:306 +537 43 74:113 108:001 (33 45:645 418:012) (45 166:011 464:417 (25 15:626 425:012) (44 13:251 30:314 (36 139:242 382:012 (35 0:542 (25 0:122 23:222))))) +538 56 459:041 (57 190:033 190:273 258:585 273:419 415:014 507:124) (46 2:416 512:439) (54 136:437 (57 7:053 9:263 354:564) (46 2:416 15:253) (57 8:144 505:767)) (46 2:416 517:032) (57 116:328 180:574 258:585 273:419 275:134 415:014 518:282) (46 2:416 527:439) 529:001 535:43A (46 2:416 537:439) +539 19 6:015 (05 5:718 (25 4:319 (21 (34 5:734 (35 5:405 6:435)) (34 5:734 (35 5:405 (42 1:001 153:242))) (11 5:001 (12 0:241 2:715)) (41 83:020 281:541)))) +540 43 44:436 (23 237:112 281:543) (06 16:216 (45 170:003 (44 164:315 199:437 283:001))) +541 18 6:214 (19 6:015 (04 4:718 (25 4:319 (35 0:645 (34 6:435 86 (43 170:001 (42 0:336 35:744))))))) +542 13 3:715 (21 5:734 (42 1:001 (43 29:031 (52 0:662 1:413)))) +543 29 8:116 280:013 (45 433:012 (57 261:043 370:116) (2A 6:226 (16 4:72A (37 16:027 (57 1:657 (55 154:043 170:013))))) (2A 6:226 539:012) 540:010 541:012 (46 7:042 86:012 542:012)) (38 278:106 (25 3:727 5:125)) +544 34 23:425 (43 15:553 259:102 (53 0:263 62:764)) +545 13 27:416 52:012 284:629 (16 19:222 84:222 314:523 419:407) +546 16 10:223 44:417 63:223 (13 19:407 19:627 62:407 (23 5:316 (26 5:113 (06 5:513 (36 25:407 27:306 37:105))))) +547 14 19 314:521 (15 6:615 17:222) (24 5:111 525:304) +548 17 10:224 52:418 189:003 547:408 +549 13 10:626 52:012 63:406 547:002 +550 56 390:306 544:583 545:66A 546:261 548:260 +551 64 52:335 523:031 (63 10:456 44:262 63:456 (66 19:052 84:052 314:153 (56 5:563 (25 1:025 (53 5:766 (73 5:366 (43 25:272 (33 6:773 78:242) (33 4:023 6:753)))))))) +552 86 188:144 258:063 326:43A 543:308 (77 544:144 545:46B 546:062 (56 3:276 389:156) 548:061) 551:021 +553 76 107:337 163:337 538:021 552 (54 433:327 (56 3:276 (55 10:667 52:657 52:053 (57 3:437 5:757))) (67 2:437 (74 54:273 158:324 (64 6:774 145:043))) (56 3:276 (43 54:657 247:327))) +554 14 5:101 (13 0:100 515:003) +555 33 13:647 14:241 31:021 230:756 367:021 428:022 (22 61:636 194:022 224:001) +556 24 3:644 (54 115:427 171:427 197:425 197:023 285:427) +557 46 110:013 119:013 430:012 461:014 555:011 (47 13:659 28:757 58:418) (36 5:416 (43 42:437 152:112 (22 (15 2:316 5:646) (33 11:303 41:112 (34 1:736 392:754))))) +558 32 8:001 16:102 24:403 (31 5:402 471) +559 61 8:432 236:570 (40 0:334 17:130) (34 5:334 (50 244:560 (64 35:030 (44 5:131 (23 1:664 (13 0:643 0:003)))))) +560 54 67:315 228:021 373:425 435:427 531:031 (31 5:131 (65 153:765 (41 5:334 (51 44:561 52:561 (52 44:121 156:435))))) (53 227:031 245:765 274:427) 559:405 +561 27 154:013 319:40A 335:003 (24 1:727 57:002) +562 33 52:304 506:647 (35 13:241 14:021 33:241 122:012 388:416) +563 35 134:407 180:407 258:418 435:408 507:002 (45 18:114 (24 0:655 (26 0:727 393:417)) (44 5:415 (34 0:405 (36 15:437 (33 11:637 38:746))))) 561 562:001 +564 44 119:111 497:240 498 (54 12:113 12:315 79:121 135:112 182:316 (55 44:124 (24 5:024 453:253) (56 67:262 134:573 180:573 327:797 504:022 558:574 (57 16:254 235:668 (45 0:758 (25 102:564 (35 5:025 55:252) (24 5:254 342:252))))) 560:111 563:103)) +565 52 140:313 (53 5:423 179:011) (13 4:413 142) +566 35 116:102 116:306 172:102 172:306 182:011 565:561 +567 45 27:436 44:032 560:001 563:020 (55 67:316 134:427 180:427 327:669 504:112 558:437 (65 16:335 235:776 (44 0:675 (42 94:435 102:436 (43 5:142 92:765))))) +568 44 110:111 497:240 (43 255:571 496:240) (54 79:121 189:315 518:307 (35 52:564 (64 24:435 77:325) (33 3:335 (36 8:543 387:253 (37 6:033 132:553) (37 6:233 124:243)))) 565:417 567:101) +569 55 287:102 322:429 457:124 (65 8:034 (53 68:102 (66 5:035 54:052)) (63 169:763 202:436)) (53 68:102 495:030) (65 9:326 (63 99:032 169:763) (46 11:125 288:102)) +570 43 150:437 283:001 (45 5:543 446:439) (23 1:003 (53 20:324 29:123 331:020)) +571 44 250:437 569:001 (47 2:747 (56 287:103 288:103 345:024 457:125)) (45 0:747 (43 5:543 446:439)) (45 0:747 (43 5:543 283:001)) 570 (23 1:003 (45 0:747 (43 7:447 (53 5:346 29:123) 446:439))) +572 46 97:307 98:106 (26 5:246 78:417) 571 +573 36 384:002 385:002 493:002 494:002 (35 8:123 115:103 197:543 286:002 339:002) (35 7:032 8:123 9:242 473:317) (35 8:123 403:002 487:003 492:002) (35 87:002 487:003) (17 107:003 572) (35 9:242 249:002 383:756 403:002) +574 45 184:252 384:102 385:102 493:102 494:102 (32 130:112 (33 43:112 64:646) (42 5:012 (44 5:745 223:011)) (44 18:032 61:646 (42 5:745 236:656))) +575 54 257:021 326 (24 3:644 8:023) (64 (24 3:644 6:324) 554:574) (64 280:103 554:574) +576 43 5:674 (42 52:041 246:655 (45 (55 0:284 5:142) (32 5:745 87:305)) (32 87:305 215:010)) +577 43 5:012 (33 0:002 (31 15:030 393:240)) +578 43 26:012 49:414 117:010 577:001 +579 34 118:001 137:406 172:001 173:001 181:406 435:407 507:001 578:001 578:407 +580 42 24:011 49:413 194:111 577 +581 46 188:022 188:262 258:574 309:777 578:113 578:573 +582 46 184:317 423:317 572:010 (45 133:122 (56 5:143 160:317)) (36 12:307 14:307 109:113 424:113) (45 383:766 432:553) +583 76 401:032 552:40C 556:032 575:032 (56 3:676 (86 8:457 321:45A (96 6:156 576:42A) (96 6:356 576:42A))) 579:45A (68 184:275 423:275 (58 7:128 86:125 542:125) 572:105 (67 48:275 109:035 246:275)) 582:104 +584 21 5:001 (34 39:020 (41 4:241 121:010) (12 0:241 203)) +585 13 5:242 (11 5:642 (41 5:412 (14 11:010 358:101))) +586 42 8:011 179 585 +587 25 12:011 12:231 12:417 12:637 586:102 586:306 +588 43 42:102 289:303 291:010 586:120 +589 42 7:102 8:011 9:303 585:250 +590 23 52:010 588 +591 46 42:105 430:012 (36 5:646 265:115) (44 12:438 13:438 14:438 289:306 435:317) (44 13:032 356:012 (43 109:416 157:756 (35 17:436 80:756)) 586:123 (43 8:336 19:252 271:416)) +592 14 22:405 36:614 150 (15 1:101 158:416) +593 43 2:002 (45 36:032 105:031 250:436 592:436) +594 64 53:784 (55 5:553 91:043) (26 272:563 290:767 (23 1:023 (25 7:627 208:113 (12 4:726 (51 375:315 (55 5:553 (52 5:151 6:455)))))) (23 1:023 268:011) 593:573) +595 65 4:024 (64 5:034 (63 5:434 (62 8:775 (21 5:001 (51 4:765 (50 3:764 (41 4:411 5:421)))) (42 2:001 208:775) (52 5:765 (42 5:662 153:131)) (42 2:001 157:775)))) +596 44 197:415 (42 2:001 (45 2:745 5:014)) (42 2:001 (43 0:745 5:414)) (54 6:314 595 (42 2:001 82:121)) +597 55 272:112 290:316 593:102 (54 13:667 109:022 291:022) (54 (52 7:456 (42 5:755 5:252)) (42 140:656 (52 5:252 (61 4:422 4:355))) 596:112) +598 35 (36 5:134 (45 0:338 (55 5:265 133:273))) (36 5:134 (45 0:338 (55 5:265 133:677))) 584:124 591:42A 594:281 (36 5:134 (45 0:338 (55 5:265 413:326))) 597:012 +599 43 107:304 163:304 401:407 (34 2:404 (35 10:242 27:032 48:242 63:242 (32 9:646 251:745 (45 5:132 (25 5:532 (55 8:024 17:124 41:124 (56 5:025 64:042) (65 6:325 16:335 (44 0:675 44:042)))))))) +600 32 23:635 (35 20:022 55:305) +601 43 247:001 (44 (35 29:032 35:745) 499:112 501:001) (44 406:436 499:112 (24 3:244 (63 1:263 (42 15:435 (52 66:031 94:132)))) 600:417 (24 3:244 72:022)) (44 406:436 501:001) +602 67 553:001 (68 59:43B 497:328 (58 320:034 496:328) 555:033) (77 107:338 163:338 556:43B (68 2:438 545:45C)) 557:022 564:124 568:124 573:308 574:42A 583:40D 598:40C 599:034 (68 119:035 497:328 498:124 (55 (65 157:034 383:263) (66 18:055 381:778) (57 64:054 500:328) 601:318)) +603 15 13:221 14:627 31:407 189:221 367:407 457:002 (12 7:416 8:305 9:626 427:406) +604 32 5:403 (34 5:003 267:010) +605 43 12:102 135:101 182:305 474:011 (13 115:240 585:001 604:010) +606 33 28:102 168:001 (34 53:436 240:241) +607 43 13:657 211:417 (42 8:335 383:562) (46 7:647 8:553 (12 352:756 (25 25:553 42:626))) (46 197:553 363:012 371:553 606:252) +608 46 13:438 31:438 355:417 364:012 434:003 (12 (53 18:253 375:756) (25 28:756 42:626) (25 42:626 58:013)) +609 31 (21 5:314 48:302) (33 25:101 54:030) +610 15 19:001 197:522 225:001 609:406 +611 25 27:223 47:307 (23 7:427 17:013 93:316) +612 14 36:614 50 54 (15 (12 6:011 6:211) (02 0:716 3:101) (12 4:715 6:011)) +613 25 104:010 329:220 409:418 612:012 612:416 612:626 +614 55 68:104 558:437 (53 276:438 (24 1:004 425:426) 611:439 (43 68:304 495:438) (43 68:304 (44 66:436 66:032)) (43 68:304 612:446)) +615 45 362:001 614 (55 116:262 134:427 180:427 435:428 558:437 561:020 (46 43:033 57:428 (64 139:325 148:564 (65 5:435 (44 0:675 (43 11:447 20:436 402:032)))))) +616 33 345:001 421:102 522:001 530:010 533:406 534 (25 11:021 (26 6:022 123:533) 521:011) +617 43 14:657 136:426 332:776 616:021 +618 55 398:123 434:012 610:261 (56 7:052 8:143 9:262 (34 25:766 (35 53:637 378:133))) (56 7:052 8:143 9:262 604:123) (56 9:262 171:123 577:337 609:667) (56 9:262 256:583 577:337) 615:020 (44 80:563 111:122 616:031 (34 5:024 (64 4:664 113:114))) +619 43 8:012 26:012 49:012 115:010 292:010 (22 56:240 253:010) +620 45 57:563 57:767 293:563 293:767 (33 17:646 37:646 233:543) +621 24 206:103 238:552 414:755 417:646 (23 15:754 159:112 164:646) (14 0:404 133:406) +622 44 57:766 (36 41:243 56:766) (22 61:636 (36 4:736 41:243) (32 5:735 11:436)) (45 23:436 621:271) +623 56 467:69B 602:103 603:263 605:584 607:69B 608:69B (55 188:273 444:044 606:449 610:449) 618:6AA (55 137:778 181:778 363:689 474:778 606:449) (58 12:264 188:274 211:284 (59 9:44A 151:285 186:264 187:254 (47 27:256 35:349)) 619:125 (55 179:339 371:348 443:449) 620:282) (58 12:044 322:115 369:44B 435:125 (55 179:339 197:348 465:044) 622:68B) +624 34 54:104 545:020 (33 10:646 52:032 82:406 (43 64:304 315:242)) +625 32 50:303 125:303 454:551 455:011 (33 54:303 294:561 449:100 (34 10:241 82:001 (31 56:764 73:240))) +626 56 323:262 430:022 592:766 (45 317:429 (25 5:025 38:656) 519:022) (46 11:316 336:125 (25 5:656 412:115)) +627 54 34:774 478:022 (44 5:434 472:272) (56 (55 0:357 (53 38:766 205:667)) (55 0:357 (53 38:766 179:337)) (57 50:263 97:263 98:053 454:448 455:144 624:5A3) 626:101 (55 0:357 (53 38:766 413:042)) (66 59:593 105:262 323:327 603:125)) +628 33 126:102 270:415 (32 36:743 53:030) (34 34:754 464:240) (23 5:643 265:314) +629 35 190:251 295:272 364:261 518 628:427 +630 46 368:283 368:68A (48 12:034 13:65A 355:679 356:67A 434:285 435:575 441:43A) 467:68B 627:013 (45 13:033 112:034 363:679 364:679) (45 112:034 181:564 181:328 295:688 466:034) 629:41A (45 112:034 257:318 398:777 (57 10:658 34:337) 628:033) +631 35 44:436 52:436 63:242 (42 43:435 51:435 (32 45:755 418:122)) +632 33 50:304 125:304 454:552 455:012 (34 54:304 294:562 (35 10:242 52:436 82:002 (32 92:315 378:112)) 631) +633 44 47:666 144:656 (56 27:253 52:657 144:336 (53 8:143 93:346)) +634 55 438:001 452:001 587:438 612:765 633 +635 23 14:417 33:637 181:306 589:306 (26 7:222 9:012 395:103) +636 34 125:305 454:553 (45 399:428 408:031 475:428 509:112 587:021 (35 22:755 108:657 512:021) 635:429 (46 10:033 44:647 63:033 117:317) (54 332:021 474:426 522:022 (35 1:415 (55 85:031 164:032 262:427)) (64 7:324 11:124 331:261))) (54 118:021 188:112 188:316 192:113 193:113 396:582) +637 42 21:112 41:313 48:313 (43 5:012 (33 0:002 (44 15:645 44:113))) +638 33 57:406 136:305 217:305 530:010 (34 15:103 85:417) 637:001 +639 34 50:103 125:103 478:002 482:002 (33 54:103 638:102 (35 71:242 73:646 (36 21:033 37:243 62:647) 451:646) (35 71:242 73:646 435:562 451:646)) +640 45 10:032 47:326 52:646 (36 61:242 89:436 183:562 (46 5:543 (26 44:316 260:553 (56 5:143 90:025)))) +641 23 52:303 144:011 (34 14:020 44:103 60:241) +642 35 299:001 349:001 476:001 587:011 587:418 612:305 641:002 +643 35 299:408 349:408 476:408 587:011 587:418 612:104 641:407 +644 64 120:677 338:316 437:317 611:306 613:113 634:010 (65 104:114 359:114 452:011 476:438 479:031 (55 10:574 317:031 640:428)) 642:030 643:030 +645 64 120:677 276:316 338:316 437:317 611:306 634:010 642:030 643:030 (54 44:574 52:574 128:325 144:666) (65 104:114 359:114 438:418 452:011 476:438 479:031) +646 44 361:011 361:561 411:103 600:571 621:307 (42 15:241 72:122 262:765) +647 54 399:786 408:315 410:315 480:591 546:103 587:316 635:796 646:111 (55 600:582 600:428 621:111 (65 15:775 65:584 282:667)) +648 44 174:011 475:021 480:010 480:270 483:428 566:011 587:021 587:428 605:112 635:020 644 647 +649 44 52:315 523:011 (43 10:436 44:242 63:436 (46 19:032 84:032 314:133 (36 5:543 (33 5:746 (26 15:555 (34 5:533 (23 5:736 (13 0:003 78:242)))))))) +650 55 13:114 14:114 257:428 435:428 507:022 649:41A (54 52:325 545:260) +651 36 (35 55:563 56:766) (35 20:243 29:033 46:553) (43 85:775 94:243) +652 43 0:253 (25 10:232 558:103 (44 222:305 (45 36:114 44:646 (35 0:655 245:252)))) +653 24 53:304 53:563 652:010 (44 206:103 301:021 405:553) +654 44 248:102 300:102 436:101 449:417 509:011 510:417 653:307 (45 53:031 53:647 651:678 (46 0:747 502:317)) +655 33 10:426 52:232 435:766 (36 179:552 314:123 344:757) +656 66 508:033 508:439 605:033 605:439 644:5A2 645:5A2 647:5A2 650:021 650:42B (55 248:679 300:679 436:689 449:328 510:328 (54 117:123 134:337 180:337 337:669 341:689 435:327 558:336) (45 1:025 651:112) (45 1:025 652:439)) 654:593 +657 43 50:112 125:112 478:011 482:011 (44 510:111 631:010 653:110 (24 54:314 79:251) (42 54:112 71:251 345:121) (54 85:582 85:437 411:447 537:582 (34 15:324 65:113 (64 20:133 29:334 (63 5:434 445:435))))) +658 23 27:626 52:222 284:419 (26 314:113 378:306) +659 34 5:405 658:010 +660 35 13:574 137:263 332:668 (65 9:326 (75 6:575 18:144) 659:030 (75 6:575 252:032)) +661 46 13:032 14:252 33:032 116:113 (43 9:657 115:776 302:777 303:777) +662 44 52:315 658:020 (15 5:415 141:242) +663 45 134:417 180:417 435:418 507:012 558:427 562:419 580:013 662 +664 65 134:437 180:437 309:272 435:438 558:447 580:033 662:020 +665 45 459:031 588:317 (47 70:647 106:033 269:033 322:104) (47 70:647 257:574 435:574) (35 40:647 517:104 (34 5:736 (37 4:737 93:544))) +666 23 5:530 (43 5:130 (13 4:643 314:012)) +667 34 7:030 9:240 666:001 +668 34 7:230 9:020 666:001 +669 64 188:448 590:273 668:437 (67 19:273 197:154 225:273 (45 25:777 (57 5:564 (47 48:576 (46 0:748 (56 0:676 66:777)) (37 5:437 36:034) (37 24:266 36:034))))) +670 66 459:051 (55 40:776 125:124 660:111) 661:42A (55 40:776 125:124 663:113) (56 270:034 588:273 638:449 (76 106:135 219:135 530:459) (55 40:776 98:325 512:449)) (55 40:776 125:124 617:021) (64 13:458 31:458 355:437 356:438 434:023 435:133 441:678) (55 40:776 125:124 535:44A) 665:102 (64 188:042 188:448 441:678 442:678 514:273 667:437) (64 13:272 514:273 590:273 668:437 (55 125:124 136:447)) 669 +671 33 28:102 126:102 126:304 (34 22:754 464:240) +672 22 34:302 305:101 (21 22:010 22:101) +673 44 (14 30:013 74:314) (34 0:654 (14 38:243 (45 5:014 260:013))) (45 188:022 190:668 230:767 263:013 306:418) (34 0:654 (14 38:243 145:013)) (14 30:013 (45 263:417 271:417 424:417 (43 8:336 19:032 25:756) (34 5:014 10:033))) +674 24 34:222 149:012 673 +675 76 459:061 618:022 629:2A2 (77 12:283 356:043 364:043 367:283 671:689) (74 188:052 190:698 441:282 442:282 514:687 667:043) (73 304:468 672:687 (74 8:366 26:786 133:152 186:061 187:478) 674:317 (66 (74 5:573 179:592) (65 22:786 34:585 305:786))) (77 190:053 190:293 363:043 671:689) (65 34:585 97:336 535:45A) (73 328:337 330:337 384:447 672:687 674:317 (74 321:336 354:583)) +676 43 7:303 8:012 9:102 (24 55:646 380:012) +677 33 13:647 14:427 33:647 589:316 676:102 +678 15 31:407 160:305 (26 18:626 (43 22:754 382:242)) +679 23 52:010 (33 0:403 222:551) +680 33 0:653 (13 56:240 179:655) +681 34 11:104 (46 44:647 52:647 (43 32:756 44:314 90:336) (43 17:033 32:756)) +682 44 408:438 410:438 475:668 509:317 510:777 587:428 646:678 (43 44:242 52:242 128:437 676:112) (64 422:272 450:428 503:677 642:030 (65 59:438 105:325 678:271 (66 13:272 14:678 79:437 679:273 (46 377:273 (67 7:063 9:273 386:584) 426:023 (56 0:676 222:124)))) 680:427 (65 430:031 431:022 592:775 678:271 (66 13:678 79:437 243:272 679:273) 681:429)) +683 35 50:104 150:104 (25 5:645 9:306) (25 5:645 604:012) 682:40A +684 7A (87 118:45A 355:35A 434:35B 468:136 (97 8:468 115:46A 469:156 470:45C 485:348 489:44C) 491:79B) 623:30F (79 50:066 97:066 98:276 454:68B 455:587 624:126) 625:596 630:30E 632:5A6 636:5B6 639:136 (7B 174:44E 475:057 475:297 483:057 508:148 508:5A8 566:44E 587:057 587:297 635:45F 644:43F 645:43F 647:43F) 656:115 657:145 670:124 675:5C3 683:126 (87 257:054 (97 8:066 313:296) 434:35B 468:5B6 491:79B) +685 55 67:316 175:776 228:022 435:428 531:032 (32 5:132 (64 96:122 (62 351:436 (21 4:735 (31 5:734 312:020))))) +686 45 134:562 180:562 337:030 435:572 558:563 (54 43:123 57:572 340:030) (42 7:446 9:436 256:572) +687 55 44:124 324:260 685:101 686:011 +688 15 0:101 (34 8:405 41:305 253:407 256:407 336:305) +689 45 44:114 324:250 686:001 (46 67:252 175:658 228:113 373:553 435:573 688:104) +690 34 21:123 56:656 (36 39:022 80:022 463:102) +691 36 8:123 (45 27:436 277:317 278:113) (46 5:133 (45 0:132 (65 102:326 400:023 (66 30:336 59:439 462:052 (56 0:676 317:032))))) (37 6:233 8:124 690:102 (45 21:034 56:767 (65 39:124 80:124 (67 (26 5:533 35:124) 460:45A 488:022)))) +692 15 5:102 (34 110:002 119:002 399:418 430:001 461:003 475:418 (33 13:427 14:427 118:306 192:241 193:021 396:010 435:766) (44 2:405 509:417)) +693 78 147:044 339:788 692:125 (57 319:67A (58 28:044 409:127) (58 168:574 409:127 611:116) (35 6:575 26:264 214:272 (54 10:564 308:448)) (56 44:658 52:458 (54 233:274 314:767 314:347))) +694 57 116:328 188:273 397:125 435:584 691:022 (46 390:44B 544:273 545:105 546:595 549:105) (54 7:458 26:347 142:788 693:30B) +695 45 12:104 118:418 135:103 182:307 (46 44:115 324:251 686:002 (47 67:253 175:659 228:114 435:574 688:105 (15 5:015 (38 96:014 (14 5:645 (17 308:628 348:555 (16 11:013 75:222 103:417) (16 11:013 17:224 90:727))))))) +696 54 12:668 322:797 369:261 435:787 622:021 (44 317:317 (57 5:757 197:564) 436:787 685:689) +697 53 7:763 8:022 690 (34 21:123 56:656 (36 39:242 121:252 (56 151:766 460:585 (66 95:797 (52 16:753 374:022))))) +698 46 12:032 182:668 188:022 619:573 620:010 622:011 687:101 697:112 +699 75 197:044 321:041 693:2B0 (48 147:274 249:338 692:595 (68 371:044 460:597 (78 95:7A9 112:144 (76 42:064 52:145)))) (64 389:345 545:050 546:459 549:050 (63 10:676 48:676 134:346 (74 5:445 259:457))) +700 45 204:408 (25 39:104 52:012) 460:030 (26 61:012 348:103 (25 0:112 (35 5:645 197:416))) (46 304:658 (44 7:242 8:336 9:437) (25 40:104 52:012)) +701 77 12:338 322:283 435:044 697:69A 699:012 (5A (58 10:348 39:266) 683:5A6 (58 52:587 325:116) (47 8:276 463:126) (48 18:348 348:276) 700:126 (58 10:348 (59 5:35A 9:046) (59 5:35A 372:046))) +702 43 22:303 400:001 (42 30:112 108 (11 15:010 40:101) 511:010) +703 43 13:657 369:250 (33 195:032 (53 3:253 27:042) (23 0:253 52:426) (32 0:746 101:426)) 516:416 (42 7:446 9:656 (32 5:745 (52 5:345 (22 11:562 103:122 157:251)))) (46 9:657 49:553 186:031 (53 18:253 77:252)) +704 44 22:104 400:406 (45 30:315 (46 28:554 58:013 306:012) 703 (43 516:416 (55 2:655 52:042) (55 2:655 10:656) (46 25:553 78:756))) +705 54 422:262 450:418 503:667 642:020 680:417 (55 59:428 105:315 323:261 (56 14:668 79:427 181:133 189:262 367:448 474:133)) (55 323:261 430:021 431:012 592:765 681:419 (56 79:427 243:262 518:281 (44 52:657 242:262))) +706 44 512:786 517:316 527:786 537:786 (34 15:124 65:315 (73 261:334 (64 4:434 9:123) (53 154:334 159:436) (75 22:335 152:282 166:041))) (53 417:775 420:765 526:765 532:306 (33 318:103 334:774 379:335) (34 66:765 238:766 394:325)) (75 22:335 74:345 325:439 (74 30:144 59:041 296:336 603:061)) +707 56 459:041 535:43A 617:011 660:101 663:103 (57 116:328 134:574 180:574 337:042 435:584 558:575 662:103) (54 14:668 33:448 322:317 (57 7:053 9:263 380:564)) (54 136:437 267:032 322:317 322:593 (57 7:053 8:144 9:263 485:449)) (54 13:448 14:668 332:787 (57 9:263 115:124 302:583 303:583)) (57 12:263 13:263 118:584 369:66A 435:584 528:041 689:113) (46 537:584 537:439 702:574 702:438 704:104 704:031) 705:42A 706:40A +708 78 459:5C7 475:5B6 587:34A 603:147 605:055 650:6BD 684:011 (68 117:055 137:296 181:296 257:295 435:295 (77 57:295 88:295 111:295 213:055 (58 7:598 234:147 241:597) (76 44:275 52:075 (79 7:275 9:065 92:596))) (98 7:358 186:5B7 292:69B)) (98 12:359 135:5B6 181:066 435:46B 565:45B 687:2C4 689:054) 694:7DD 695:053 696:5D3 698:134 701:2D1 (98 12:157 12:359 12:5B7 12:7B9 490:051 490:2B1) 707:2C3 +709 57 14:263 116:584 181:574 (66 524:593 536:799 545:7A7 655:5A3 664:41B (54 11:458 253:787 (45 53:125 56:327 392:043)) (54 11:458 521:448 (53 6:457 89:666))) +710 36 13:022 14:242 117:103 (33 7:437 115:306 (32 6:032 196:326) 577:112) +711 66 120:273 338:114 437:113 611:104 613:317 634:41A 642:43A 643:43A (65 104:316 359:316 452:419 476:032 479:439 520:290) +712 56 174:429 508:123 508:583 566:429 605:123 605:583 647:41A 650:102 650:5A2 (54 116:327 297:328 435:583 435:123 649:7A8 (64 44:457 545:5A3 655:7A7)) 661:291 710:021 711:010 +713 56 508:123 508:583 605:123 605:583 645:41A 647:41A 650:102 650:5A2 654:429 654:689 711:010 +714 33 15:232 88:306 (36 41:023 55:306) +715 56 523:429 532:103 536:689 545:66A 655:42A 664:101 (35 44:125 52:125 134:263 (44 53:658 53:042 111:022 394:124)) (46 361:273 408:585 621:789 714:103 (75 22:135 74:145 325:031 (76 30:346 110:043 296:134 511:043))) +716 75 9:134 49:446 142:032 (64 55:042 659:270) +717 66 192:125 192:787 550:2A1 550:40B 578:033 578:679 622:113 622:799 716:001 716:6AB +718 75 120:688 276:327 338:327 437:328 611:317 642:041 643:041 (65 44:585 52:585 155:687 341:328) (76 452:022 520:2A0 587:459 612:786 633:021) (76 329:5A5 452:022 462:469 (66 52:346 52:786 232:145 232:585) (74 12:468 12:688 12:062 377:283 (73 8:366 229:593)) (66 315:585 317:042 640:439)) +719 33 318:230 334:427 (36 53:022 53:638 209:637 (46 53:105 53:766 209:756 (47 1:133 (48 0:749 (45 45:328 343:565 (38 5:545 412:034)))))) (34 65:021 301:103 417:755) (34 15:232 65:021 72:113) +720 76 54:786 64:786 (35 10:766 180:263 200:135) (75 40:134 310:134 (57 0:758 (77 12:283 13:283 369:68A 474:154 (67 52:274 315:146) (74 197:787 201:584)))) +721 54 14:261 176:426 216:022 218:123 (56 7:457 8:563 (24 25:766 (36 22:232 (46 5:553 (26 5:426 208:657))))) +722 44 13:251 176:416 (46 8:553 9:437 366:658 (34 17:033 32:756)) (54 2:654 345:122) (34 0:654 307:252) (34 0:654 267:021) +723 55 328:011 330:011 (45 46:657 321:021) (24 53:638 53:022 310:114) (57 (37 44:638 52:638 180:554 (34 9:648 90:327 99:564)) (56 82:024 176:428 218:125 369:66A) (37 44:638 52:638 180:554 (34 145:124 314:327)) (56 13:263 192:449 369:66A 435:124 474:134 477:338) 721:002 722:012) +724 68 523:595 524:595 677:115 (48 57:035 111:275 390:5A7 397:045) (78 188:136 188:33A 258:055 (48 19:587 19:789 395:046) (48 19:587 231:275 279:045) (69 53:66B 637:046)) 719:7AA (47 53:788 53:127 720:7AC 720:103) (67 512:044 600:32A 621:69B 702:136 714:283) (48 88:035 231:275 267:586 (78 7:338 9:137 604:045)) 723:68D +725 78 459:46C 579:7B9 581:6BC 654:44B 661:033 677:6AC 682:7CB 694:42D 696:022 698:6BC 709:022 710:043 715:32C 717:7DC 718:022 724:6CF +726 87 459:136 579:46B 581:133 654:144 661:5C3 677:33A 682:44C 694:122 696:5D2 698:33B 709:5D2 710:5C4 715:032 717:43D 718:5D2 724:5F2 +727 88 648:043 648:134 648:33C 648:44D 708:100 708:2G0 708:40G 708:7GG 712:033 712:133 712:2D3 712:33D 712:43D 712:5D3 712:6DD 712:7DD 713:2D3 713:33D 713:43D 713:5D3 725:011 725:111 725:2F1 725:31F 725:41F 725:5F1 725:6FF 725:7FF 726:111 726:2F1 726:41F 726:6FF diff --git a/evidence/snaky-finite-v1/claim.json b/evidence/snaky-finite-v1/claim.json new file mode 100644 index 0000000..e8f9963 --- /dev/null +++ b/evidence/snaky-finite-v1/claim.json @@ -0,0 +1,1132 @@ +{ + "schema_version": 1, + "namespace": "finite-congruence-atlas/snaky-finite-v1", + "id": "context:family-187:snaky:finite-board-21:v1", + "kind": "finite_board_strategy", + "evidence_status": "lean_proof_with_recorded_kernel_replay", + "statement": "Maker can force Snaky within 21 actual claims on the exact 251-cell envelope, and on the square with integer coordinates 0 through 16 in both directions.", + "scope": "One exact 728-card certificate, two specified finite boards, empty initial position; all legal board-contained Breaker replies.", + "assumptions": [ + "Maker moves first; players alternate claiming one fresh cell of the selected board.", + "Maker wins by owning a translated, rotated or reflected copy of the six specified target cells.", + "The game ends when Maker wins; no Breaker reply after victory is required.", + "Lean's kernel and only the standard axioms listed in the receipt are trusted." + ], + "limits": [ + "This formalizes the source paper's existing 21-Maker-claim finite-board corollaries. It does not establish a new bound, optimality, or a smallest board.", + "The formal result is a finite-board strategy-tree guarantee, not an extracted or benchmarked executable policy.", + "The 728-card theorem certificate is distinct from the historical 616-card comparator reconstruction.", + "The independent Python certificate reconstruction is tested computation, not a formally verified implementation.", + "Saved receipt replay checks recorded sources, commands, artifacts and bindings. It is not a new kernel execution or an authenticated attestation.", + "No general translation correctness or improved agent reasoning is established. Model benchmarks and training remain paused." + ], + "values": { + "target": [ + [ + 0, + 0 + ], + [ + 1, + 0 + ], + [ + 2, + 0 + ], + [ + 3, + 0 + ], + [ + 3, + 1 + ], + [ + 4, + 1 + ] + ], + "card_index": 727, + "envelope": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 0, + 12 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 1, + 12 + ], + [ + 1, + 13 + ], + [ + 2, + 1 + ], + [ + 2, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 2, + 14 + ], + [ + 2, + 15 + ], + [ + 3, + 1 + ], + [ + 3, + 2 + ], + [ + 3, + 3 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 3, + 14 + ], + [ + 3, + 15 + ], + [ + 4, + 0 + ], + [ + 4, + 1 + ], + [ + 4, + 2 + ], + [ + 4, + 3 + ], + [ + 4, + 4 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 4, + 15 + ], + [ + 5, + 0 + ], + [ + 5, + 1 + ], + [ + 5, + 2 + ], + [ + 5, + 3 + ], + [ + 5, + 4 + ], + [ + 5, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 5, + 16 + ], + [ + 6, + 0 + ], + [ + 6, + 1 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 8 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 7, + 16 + ], + [ + 8, + 0 + ], + [ + 8, + 1 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 0 + ], + [ + 9, + 1 + ], + [ + 9, + 2 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 9, + 16 + ], + [ + 10, + 0 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 11, + 16 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 12, + 15 + ], + [ + 12, + 16 + ], + [ + 13, + 1 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 13, + 15 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 14, + 14 + ], + [ + 15, + 3 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 4 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "square_bounds": { + "x_min": 0, + "x_max": 16, + "y_min": 0, + "y_max": 16 + }, + "initial_maker": [], + "initial_breaker": [], + "certificate": { + "repository": "openai/math", + "commit": "1581d4cbdd69a0faf34b2089614fe2a814316a6a", + "path": "preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt", + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt", + "certificate_sha256": "3fa12d36a6d4dbb185e3f2808c8dfde13d85ee309afbca030d6ad17ae9fe3d04", + "byte_length": 38367, + "hash_encoding": "SHA-256 of exact original certificate bytes; no newline normalization." + } + }, + "conclusion": { + "predicate": "A finite-board strategy tree guarantees a translated or square-symmetry copy of the exact six-cell Snaky within the stated number of actual fresh Maker claims from empty Maker and Breaker sets; every legal on-board Breaker reply is covered, and victory needs no further reply.", + "maker_claims_at_most": 21, + "envelope_cells": 251, + "square_cells": 289 + }, + "theorems": { + "envelope": "FiniteCongruenceChecks.SnakyFinite.envelope_wins", + "square": "FiniteCongruenceChecks.SnakyFinite.square_wins" + }, + "applicable_lemmas": [ + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.fresh_cell", + "role": "A strict occupied-cell bound supplies a legal board-contained cell." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.finite_compose", + "role": "The finite resource invariant justifies pivot replacement and every legal Breaker continuation." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.board_wins", + "role": "Any finite board containing the exact final envelope and at least 42 cells supports the strategy." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.envelope_wins", + "role": "Empty initial position on the exact 251-cell envelope." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.square_wins", + "role": "Empty initial position on the exact 17 by 17 square." + } + ], + "citations": [ + { + "path": "lean/snaky/SnakySemantics.lean", + "sha256": "eed7dee5c079df33d8488018119dfdb48d8bc1bc6aeb70e6a23f679135e52f2b" + }, + { + "path": "lean/snaky/SnakyFinite.lean", + "sha256": "4481d384a4f7920d98088bd2cc10796d330e5ae9da11aeff718e0d949c27d3ff" + }, + { + "path": "lean/snaky/vendor-manifest.json", + "sha256": "ca09b16a386355c5aa5a46c91fa87b6979cfc809ddc01b55743d6199e6e63c22" + }, + { + "path": "lean/snaky/SnakyBinding.lean", + "sha256": "c2067bfff6b6a25ce5dc3c6f5d42973943d19f1587954d627e3e774e9b261f8b" + } + ], + "upstream_context": { + "family": "187", + "revision": "1581d4cbdd69a0faf34b2089614fe2a814316a6a", + "scope_url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/lean/docs/187.md", + "paper_url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/build/strategy.tex", + "role": "The paper states the finite-board corollaries. The selected upstream Lean theorem covers the infinite grid." + } +} diff --git a/evidence/snaky-finite-v1/computational.json b/evidence/snaky-finite-v1/computational.json new file mode 100644 index 0000000..8cd0b04 --- /dev/null +++ b/evidence/snaky-finite-v1/computational.json @@ -0,0 +1,7544 @@ +{ + "schema_version": 1, + "id": "context:family-187:snaky:finite-board-21:v1", + "kind": "independent_finite_certificate_audit", + "status": "PASS", + "upstream": { + "repository": "openai/math", + "commit": "1581d4cbdd69a0faf34b2089614fe2a814316a6a", + "path": "preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt", + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt", + "certificate_sha256": "3fa12d36a6d4dbb185e3f2808c8dfde13d85ee309afbca030d6ad17ae9fe3d04", + "byte_length": 38367, + "hash_encoding": "SHA-256 of exact original certificate bytes; no newline normalization." + }, + "checker": { + "path": "scripts/check_snaky.py", + "sha256": "39557ec80096081efac4f5f8f0182383a4d23af855bb652a8108fa4228ee2d42", + "hash_encoding": "SHA-256 of UTF-8 file bytes with CRLF normalized to LF; no other byte changes." + }, + "counts": { + "numbered_cards": 728, + "explicit_lines": 722, + "base_cards": 6, + "maximum_height": 21, + "combination_nodes": 1620, + "reference_nodes": 4089, + "maximum_inline_depth": 8 + }, + "checked_local_obligations": [ + "Backward references and nonempty child lists at every expression", + "All eight placements are invertible signed coordinate permutations", + "Every requirement lies in its support", + "Every child support and pivot lies in its parent support", + "Child requirements and common support lie in parent requirements plus pivot", + "Height strictly decreases when passing to a child" + ], + "final": { + "index": 727, + "pivot": [ + 8, + 8 + ], + "required": [], + "support": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 0, + 12 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 1, + 12 + ], + [ + 1, + 13 + ], + [ + 2, + 1 + ], + [ + 2, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 2, + 14 + ], + [ + 2, + 15 + ], + [ + 3, + 1 + ], + [ + 3, + 2 + ], + [ + 3, + 3 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 3, + 14 + ], + [ + 3, + 15 + ], + [ + 4, + 0 + ], + [ + 4, + 1 + ], + [ + 4, + 2 + ], + [ + 4, + 3 + ], + [ + 4, + 4 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 4, + 15 + ], + [ + 5, + 0 + ], + [ + 5, + 1 + ], + [ + 5, + 2 + ], + [ + 5, + 3 + ], + [ + 5, + 4 + ], + [ + 5, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 5, + 16 + ], + [ + 6, + 0 + ], + [ + 6, + 1 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 8 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 7, + 16 + ], + [ + 8, + 0 + ], + [ + 8, + 1 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 0 + ], + [ + 9, + 1 + ], + [ + 9, + 2 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 9, + 16 + ], + [ + 10, + 0 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 11, + 16 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 12, + 15 + ], + [ + 12, + 16 + ], + [ + 13, + 1 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 13, + 15 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 14, + 14 + ], + [ + 15, + 3 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 4 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "required_count": 0, + "support_count": 251, + "height": 21, + "support_sha256": "6320dabfae66fe64b26c8ad648ce4fc947198f18ef7dfc3cf7caee654388c500" + }, + "finite_board": { + "bounds": { + "x_min": 0, + "x_max": 16, + "y_min": 0, + "y_max": 16 + }, + "square_cells": 289, + "envelope_cells": 251, + "max_maker_moves": 21, + "max_occupied_before_maker_move": 40, + "min_free_envelope_cells": 211, + "occupancy_assumptions": "Empty board; alternating single fresh-cell claims; Maker first." + }, + "cards": [ + { + "index": 0, + "required_count": 5, + "support_count": 6, + "height": 1, + "required_sha256": "1f618eb0d39619fcb9bff634c20d3e2ec532eedfb3b9a58b6fb9cf5e1f6dc1a5", + "support_sha256": "6d85c9e325f0bc51abb85b9464131aaa21035be8f279a9c8ce807198253ae720" + }, + { + "index": 1, + "required_count": 5, + "support_count": 6, + "height": 1, + "required_sha256": "ff8460a54eee153e31df3b92f54300193a856400fe88906750df37b2a8f51d1d", + "support_sha256": "6d85c9e325f0bc51abb85b9464131aaa21035be8f279a9c8ce807198253ae720" + }, + { + "index": 2, + "required_count": 5, + "support_count": 6, + "height": 1, + "required_sha256": "124268e236ef163e02f8c3ecb31b1a5679399ddb50cce01b5c82d6fb9b0714ba", + "support_sha256": "6d85c9e325f0bc51abb85b9464131aaa21035be8f279a9c8ce807198253ae720" + }, + { + "index": 3, + "required_count": 5, + "support_count": 6, + "height": 1, + "required_sha256": "d3261051fce5b4d5a77d60928df8c3815e55dfd4d380db6a0a7fdd0e3c6d902f", + "support_sha256": "6d85c9e325f0bc51abb85b9464131aaa21035be8f279a9c8ce807198253ae720" + }, + { + "index": 4, + "required_count": 5, + "support_count": 6, + "height": 1, + "required_sha256": "90fd32a152a84fbb6845b9f2620af321d953fdf9b51942a658e1bd25f02dcf0e", + "support_sha256": "6d85c9e325f0bc51abb85b9464131aaa21035be8f279a9c8ce807198253ae720" + }, + { + "index": 5, + "required_count": 5, + "support_count": 6, + "height": 1, + "required_sha256": "cf5706764364c1fb3ddc6f6c98d6d1dcdaa8f72fd2f1e2c0d3a55aeb5d455b6f", + "support_sha256": "6d85c9e325f0bc51abb85b9464131aaa21035be8f279a9c8ce807198253ae720" + }, + { + "index": 6, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "cee5064b44be37c07f37111a049f9b1e5a1a6a6b21081d38f43a72b72e95055d", + "support_sha256": "da0bf1742162bdfca73f7c67c18f9e5177b2dbd55cffeaffdd587db127880532" + }, + { + "index": 7, + "required_count": 4, + "support_count": 11, + "height": 3, + "required_sha256": "622f15868ce8a8efd3e1d2de1f8431c8f2a4e61e2e1627d54421d77a6cbea61e", + "support_sha256": "97760bad22f71abec90a1477df334ffbd1cadd700ebe52ef1556d9ed5bd1d55e" + }, + { + "index": 8, + "required_count": 4, + "support_count": 11, + "height": 3, + "required_sha256": "46576f3a23c8ffdd313f5e32976e9e0e9bf70d6bba3be98f43a262c22bc344c3", + "support_sha256": "0a6babc5f77ff61ca455b0a2b7571c962d1731a2ecf47484a0af21f053d65356" + }, + { + "index": 9, + "required_count": 4, + "support_count": 11, + "height": 3, + "required_sha256": "8d0d0c77559ba009c5b6581d245814abafc3345b766313e3723445846710c2df", + "support_sha256": "225e5fff310296eec840afd9627a242ff229df218fe51d29bf518c012c0c122c" + }, + { + "index": 10, + "required_count": 4, + "support_count": 13, + "height": 4, + "required_sha256": "acc57e38519a06f568622d2896fd6a06732c1fccce0d01b0cf02d99077648f09", + "support_sha256": "3e7f25f7b417f0477b91b667ca67225068b6b529d46ea8c977d250965fce85d7" + }, + { + "index": 11, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "df8a00b94df39628d8f0eb3e88b7aa873c356b18fc0e57d1c982a6be4add70d6", + "support_sha256": "100ae63c366ad666ce81ec2ab1db2df0038cd4de046294c7444bf8f45d28147a" + }, + { + "index": 12, + "required_count": 3, + "support_count": 17, + "height": 4, + "required_sha256": "e449fdee4a3226a9777d4125c4018215b7991f8bbe8536671a81beadaba5e6f1", + "support_sha256": "945f17cfc4e5b49d85ab4dfa14c749ef7c024f0562bf5d1e01ae3cd9bfc6283d" + }, + { + "index": 13, + "required_count": 3, + "support_count": 17, + "height": 4, + "required_sha256": "e449fdee4a3226a9777d4125c4018215b7991f8bbe8536671a81beadaba5e6f1", + "support_sha256": "e9428ef8fff3f84f58bad5030b799465eb240306be1b2c58413bd6b384724874" + }, + { + "index": 14, + "required_count": 3, + "support_count": 17, + "height": 4, + "required_sha256": "e449fdee4a3226a9777d4125c4018215b7991f8bbe8536671a81beadaba5e6f1", + "support_sha256": "2f4c2946b06df93adc2da55253d2e7ef7e86e43e1fe9f6b7b975a2bd4859e842" + }, + { + "index": 15, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "6fe24e0f40924ad609d7af2aa01ef1249d2ba7db81d5c1531ce987e52caff894", + "support_sha256": "749dce801094e2e55dc45a1f0834ea22e194d72c7d60fdf40fe6cd79d5f9f59d" + }, + { + "index": 16, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "757a175ce4f0cb814bfa1eb4f0924fd16defc486b4c63cae03821f71a38c9755", + "support_sha256": "f8a0feac9c5b3ea20d1863fc186cc82f9321a3a05cdacd9ce58f6bef55bc0f3f" + }, + { + "index": 17, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "2e1135d2ac657c474d917b5edeb5c451ecb4aea29fa3c71100a6d09b122289c8", + "support_sha256": "6db594edb3d9d0d92ef445a2544426b070f5042ee7742a3b8ad7a4b04515ceb5" + }, + { + "index": 18, + "required_count": 4, + "support_count": 13, + "height": 4, + "required_sha256": "cdeeba9717f050257d6d56f8153b289711e4f8c0a63f419f57719832272768fa", + "support_sha256": "3e7f25f7b417f0477b91b667ca67225068b6b529d46ea8c977d250965fce85d7" + }, + { + "index": 19, + "required_count": 4, + "support_count": 15, + "height": 5, + "required_sha256": "8d0d0c77559ba009c5b6581d245814abafc3345b766313e3723445846710c2df", + "support_sha256": "c7420ee8ad2a5ee64cd8fa02509f5e12c21fa6b631d6b725e3111c8c3e351548" + }, + { + "index": 20, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "3f30d65d168b59762c3593557972b5f784ca9f794ac66eaf4270617aefdcf1e2", + "support_sha256": "f6e8e791956f46f7972185b80c8649fc64a498ab080ae844f7756ca17361efab" + }, + { + "index": 21, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "e67833d11c16da30a78d4e7b1e57c703151afc95f6b88bd2f59a695c9ea3ebb9", + "support_sha256": "f8a0feac9c5b3ea20d1863fc186cc82f9321a3a05cdacd9ce58f6bef55bc0f3f" + }, + { + "index": 22, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "3cddd9060ffb5b5b9daa3079ee8ebaaac7ab378def837de545cef6501fa79551", + "support_sha256": "100ae63c366ad666ce81ec2ab1db2df0038cd4de046294c7444bf8f45d28147a" + }, + { + "index": 23, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "f9c0a4a27e7ef3e020270200155891027c8f790ce4c304b467f12cfa60e4edb2", + "support_sha256": "100ae63c366ad666ce81ec2ab1db2df0038cd4de046294c7444bf8f45d28147a" + }, + { + "index": 24, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "a62e070818810e5eb80bbc874364770a4765368f819dcf6831d192ac160adf80", + "support_sha256": "35884118f47caea57403776b106bfc3859ea370f50ee774b800019b52bf5a6c8" + }, + { + "index": 25, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "fd4a44871bb01c298d71ecc069b970fd29c0831c1e5262db2c5a3162674aa4c5", + "support_sha256": "c50200111f945a16778a2c9db403a2d9d1a4f39cec71c232ec27bd1f87dbe96c" + }, + { + "index": 26, + "required_count": 4, + "support_count": 15, + "height": 4, + "required_sha256": "46576f3a23c8ffdd313f5e32976e9e0e9bf70d6bba3be98f43a262c22bc344c3", + "support_sha256": "656a1ffff32274ac926e52114eb70488a3ab75be1a7b290f959df4f8bc82892d" + }, + { + "index": 27, + "required_count": 4, + "support_count": 11, + "height": 4, + "required_sha256": "81742715fda6689fa726998103f8709d4c218c41aa595c89c7699d14b3dfc96a", + "support_sha256": "97760bad22f71abec90a1477df334ffbd1cadd700ebe52ef1556d9ed5bd1d55e" + }, + { + "index": 28, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "c327907054fcf98c8c3ff3bba737ab8daed634872eb63e4b0ad755e20fdd7505", + "support_sha256": "f2beaa8d4a97c3a9882bc3569d9d7e87c885ced225ecbf6835216cf60de9cdff" + }, + { + "index": 29, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "8c125ba6b709560198a2107cf2382a528fa57d22fd2235ce40209a8f2fa46712", + "support_sha256": "684305e774b0dc425d3a59a894b6716d98f494bd4d4fdda70aa48f2d2285af4c" + }, + { + "index": 30, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "8a0afca71a094ace57719894a28a8152b730bb19a498ac886067cc5882db3fb0", + "support_sha256": "d4913f5890db09dea6f777a40ae0055edbff0e604670adbdd8dd7f93db4a5ae0" + }, + { + "index": 31, + "required_count": 3, + "support_count": 18, + "height": 4, + "required_sha256": "e449fdee4a3226a9777d4125c4018215b7991f8bbe8536671a81beadaba5e6f1", + "support_sha256": "0084e973966a4eafde4e7ebf9f9ebb0280bb2800baeb9717841c568b589a6410" + }, + { + "index": 32, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "fe364294a711842e8b818bd2a24b2aeab6d437382521083769b815fb5c1533d7", + "support_sha256": "c50200111f945a16778a2c9db403a2d9d1a4f39cec71c232ec27bd1f87dbe96c" + }, + { + "index": 33, + "required_count": 3, + "support_count": 17, + "height": 4, + "required_sha256": "e449fdee4a3226a9777d4125c4018215b7991f8bbe8536671a81beadaba5e6f1", + "support_sha256": "f2426812e5a64630c99f42e2d2cbec78bac941e77658c1e259af48e87f073cf5" + }, + { + "index": 34, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "2a840ae52cba22f647e08ff37ad54963af1a01bcc72246704371e883a3f70c86", + "support_sha256": "47114164d6c2ef8ef1d5847909e30a4dcdd970ad53d6f7cc3bb11da88b7bcf65" + }, + { + "index": 35, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "a001605908b6e2304861f71c370b236a51985da5262befb2d25a034cbea7c390", + "support_sha256": "76863e5f6c5e1b27ac95815c73d771dfd2d8530b8678586c1d404a231d4efce8" + }, + { + "index": 36, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "223f13dbcb4aa5f8dbeea10eb7ddccbbc71b792c6e2592d410946850437ed86c", + "support_sha256": "160cac1a91e0634c7b0c3cb87c4b0736cc044eef31152b0f69a57bf7470b3bd9" + }, + { + "index": 37, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "2e1135d2ac657c474d917b5edeb5c451ecb4aea29fa3c71100a6d09b122289c8", + "support_sha256": "7d496ba9b1af072867a67871f633949f54ded124479769c1b654ee21f9b15d64" + }, + { + "index": 38, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "b4e1c2d85fe08c8cd0877fb6d24f98e3251633d238baebf0f7316820013a2096", + "support_sha256": "76863e5f6c5e1b27ac95815c73d771dfd2d8530b8678586c1d404a231d4efce8" + }, + { + "index": 39, + "required_count": 4, + "support_count": 13, + "height": 4, + "required_sha256": "141a85882ed9b847e0d64750a73a3eee074dca975c842098c8ce7cbd300d139e", + "support_sha256": "3e7f25f7b417f0477b91b667ca67225068b6b529d46ea8c977d250965fce85d7" + }, + { + "index": 40, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "7df8e6da6374e1d67f70ff43f32ed5ade6842c19446c6825db2c8c6f6662de0a", + "support_sha256": "737b9b1617d62285b764fcdf6470154927c60a9c813e8ccc7506e90432e11854" + }, + { + "index": 41, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "2e1135d2ac657c474d917b5edeb5c451ecb4aea29fa3c71100a6d09b122289c8", + "support_sha256": "4eadad6cdbb2717bd9769be5e549858fcf627979878d584bad7f8f62f3af6562" + }, + { + "index": 42, + "required_count": 4, + "support_count": 11, + "height": 4, + "required_sha256": "141a85882ed9b847e0d64750a73a3eee074dca975c842098c8ce7cbd300d139e", + "support_sha256": "225e5fff310296eec840afd9627a242ff229df218fe51d29bf518c012c0c122c" + }, + { + "index": 43, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "54fa3d7382652f49e7cf387e010d39633ca115ca56185971abb1e7509067f2b3", + "support_sha256": "8b3e25ee4cc25c631eb11b3f42392b1e57e88e9096555d76fc4daef7c117efb6" + }, + { + "index": 44, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "141c029089eb4737be12a8fce061c7cb8b0effd7c3daed6ae33fc17faf744aad", + "support_sha256": "30b8d4dc69466981280c42a6f2b9cc7633156143cf313ca47bfdfd79f1e2aad5" + }, + { + "index": 45, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "1d6b2114b727d21e9c5476ee8f4059724702cd2fbe15fcf1f663484f9dc80e6d", + "support_sha256": "e8858428936547e639160c4ceeb40715fc3fd6fc9278ee9b9df45ccfd571b9bd" + }, + { + "index": 46, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "ebfa4187f0a0ad1b960a38a82b01ed3b42ff075b438ce97bc50fe8e9c882621d", + "support_sha256": "8fbcfc7af69a295730740b58b8e7ce6e642566d16390aaa6015849369f0b5695" + }, + { + "index": 47, + "required_count": 4, + "support_count": 18, + "height": 5, + "required_sha256": "ccb61cbf9cc207559b62755d7b1d828625dec0256be66d40fa6d2c23aa04aa2b", + "support_sha256": "ca34f03b079a4dab1bca7efd06ee96135cd6dff8a30792f960dd93ddb127460a" + }, + { + "index": 48, + "required_count": 4, + "support_count": 11, + "height": 4, + "required_sha256": "acc57e38519a06f568622d2896fd6a06732c1fccce0d01b0cf02d99077648f09", + "support_sha256": "225e5fff310296eec840afd9627a242ff229df218fe51d29bf518c012c0c122c" + }, + { + "index": 49, + "required_count": 4, + "support_count": 15, + "height": 4, + "required_sha256": "46576f3a23c8ffdd313f5e32976e9e0e9bf70d6bba3be98f43a262c22bc344c3", + "support_sha256": "d2ad4174d23a42f9a6fc7e33f510e8c61ac85f8922adc4b2ec4c28e8c6c00265" + }, + { + "index": 50, + "required_count": 4, + "support_count": 13, + "height": 4, + "required_sha256": "adc9850205ad9f76b540ea3952739bae2e18c6c923d94c7a439f26f138d11dcc", + "support_sha256": "3e7f25f7b417f0477b91b667ca67225068b6b529d46ea8c977d250965fce85d7" + }, + { + "index": 51, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "54fa3d7382652f49e7cf387e010d39633ca115ca56185971abb1e7509067f2b3", + "support_sha256": "749dce801094e2e55dc45a1f0834ea22e194d72c7d60fdf40fe6cd79d5f9f59d" + }, + { + "index": 52, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "141c029089eb4737be12a8fce061c7cb8b0effd7c3daed6ae33fc17faf744aad", + "support_sha256": "95f43976f036be6619378a4db6ddda558640935bd380fb72120b20f1ee5c9ab2" + }, + { + "index": 53, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "62ebc2f2fe83d6ce42ea03a4ea073cf35b5309ded415968871f3713c9bca9dcf", + "support_sha256": "95f43976f036be6619378a4db6ddda558640935bd380fb72120b20f1ee5c9ab2" + }, + { + "index": 54, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "af67b2f0d219f21bde4250636903b490e93bcc82b41bcdabc560ad103c9b1dc0", + "support_sha256": "95f43976f036be6619378a4db6ddda558640935bd380fb72120b20f1ee5c9ab2" + }, + { + "index": 55, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "a201e82bdd52af5dd7be4f5f03543b648b333b2c16faa05e6244957891f8fe18", + "support_sha256": "50423ac6c096437c841ddbf16e61da2c5ad90ba0c411e6a1af8a07c365c5643c" + }, + { + "index": 56, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "a201e82bdd52af5dd7be4f5f03543b648b333b2c16faa05e6244957891f8fe18", + "support_sha256": "23b75804bf35c23e08d1b5caa654b3a689f91a406bac5ffd32aa1732c52c0b7f" + }, + { + "index": 57, + "required_count": 4, + "support_count": 15, + "height": 4, + "required_sha256": "90998fcc5fe84883cabb8175e84bfaa46aeab0028c08ff3c179790d993d6aaf0", + "support_sha256": "4ae4991d78d991a0688dcb0a96a43f400860f804c51c6b20b55657e5bcdc87df" + }, + { + "index": 58, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "ca0809ce10d1ee88bff84ec515a69274de333d7606054808b084c43aadee79d7", + "support_sha256": "b8170f74efe370a36c2a9cd2ffe27640002f57c63d66269b0f437d05e6c5ac6a" + }, + { + "index": 59, + "required_count": 4, + "support_count": 22, + "height": 5, + "required_sha256": "08e377d7f740d4667230a385784936308d60dfecc4b5c66bf623fcaae256beb0", + "support_sha256": "eecbd033cbca8f26ad8f946acb33aefcc9a1340ad094445f87c7d0c2f42bf49e" + }, + { + "index": 60, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "c9a2986bd2f411618050c72eb62bca80c0deba010f498076c48c107cb6daaaec", + "support_sha256": "bf9f940240c05c753edd4db35f0c466e9700d7dabe0d3f485e46c235605a17f8" + }, + { + "index": 61, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "3e352053479907f73c2e94bc5f485b3752c527940d9794d360daafb1321b2844", + "support_sha256": "95f43976f036be6619378a4db6ddda558640935bd380fb72120b20f1ee5c9ab2" + }, + { + "index": 62, + "required_count": 4, + "support_count": 11, + "height": 3, + "required_sha256": "8d0d0c77559ba009c5b6581d245814abafc3345b766313e3723445846710c2df", + "support_sha256": "64000b37ac6a0e2413d20b6cac45362716927788214eea4d0354a6e9b7af2a99" + }, + { + "index": 63, + "required_count": 4, + "support_count": 16, + "height": 4, + "required_sha256": "acc57e38519a06f568622d2896fd6a06732c1fccce0d01b0cf02d99077648f09", + "support_sha256": "67628c31163403fdc32cacbfba94020f912afc3cf55e9b2f1b9c0cd89ab1cbb3" + }, + { + "index": 64, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "af67b2f0d219f21bde4250636903b490e93bcc82b41bcdabc560ad103c9b1dc0", + "support_sha256": "30b8d4dc69466981280c42a6f2b9cc7633156143cf313ca47bfdfd79f1e2aad5" + }, + { + "index": 65, + "required_count": 5, + "support_count": 16, + "height": 4, + "required_sha256": "fc93a3edc3dc9596af829cf5717f7e234ae6ebd90490560d2c7ab29ce7349dfe", + "support_sha256": "63cac1681f9d5f29a6debeb39903734c8c54618d9495b3a2d549e349c3f0a43f" + }, + { + "index": 66, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "fb454f4500226c210708c29e93ac6fe282896c8e6f48149025fd6e2061bbbfa8", + "support_sha256": "d01831d1751065f81b3d86b2ba8f75653dbca5579ee76f0af476fb047fef8050" + }, + { + "index": 67, + "required_count": 5, + "support_count": 16, + "height": 4, + "required_sha256": "75b25e1618e54d464dc6c4f30671eab2bf74878d4f74c441a308b71d4f0b1679", + "support_sha256": "818a9b438a1092cb47cbdab8f27c532acd565cfe47c7658589c84a121ce025cd" + }, + { + "index": 68, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "d753d320bcb93299623f3cb8d50dfdf3d8378fd41398b7ed02727f6098126c30", + "support_sha256": "b65166013d60f36226d9dbe4b7c8bb8eabd47a9cf88ee43cb1d34f842f9d73fb" + }, + { + "index": 69, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "1692cf8ac732f0870a550e623f4f8df5a5347206da0829649ce77586da5a0e3b", + "support_sha256": "558db9a4c7ad5003d5dbfcec34908ef35b62bf4fb3b7a367b681c02ef0d5fd20" + }, + { + "index": 70, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "a6681f5f527fd07bc5a1d1dca64a4993af49de695311c057d61f2bbe40c16dd2", + "support_sha256": "160cac1a91e0634c7b0c3cb87c4b0736cc044eef31152b0f69a57bf7470b3bd9" + }, + { + "index": 71, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "7db87cec2b96f47debb12601684d702504e42103f83751ade2d048f5cc8e8f7c", + "support_sha256": "8ed05667310b7629834d27ac2c01d87f10f674605186f06badfa3e38cc9436af" + }, + { + "index": 72, + "required_count": 5, + "support_count": 17, + "height": 5, + "required_sha256": "9b72f2f4d16d3c283cdb66e05bbb3c158eb2545d832adcd95d0898517bcb3523", + "support_sha256": "88df92d7ef91295dea23a4eb405ae616a818f77a6f9faf3df83fea92d7de4d07" + }, + { + "index": 73, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "f66b2c13f7579ed665bc412aab4ae82be9fcb212ef8f0168d282488718af012b", + "support_sha256": "c432093fa96895416e8da3037dba53123605adf191bd9b8c7dc02d5a2c24cb9d" + }, + { + "index": 74, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "77a94d80dd086be5e09c5ecc753712515a200ceaf30f52a227981721d9ec190c", + "support_sha256": "9b81864d6459213ec96160ebfbe9c9bb4085212dffa042dd38e4c16ca19f0e72" + }, + { + "index": 75, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "99cf20c5f4d3dc44609560f8195e9366be0bfa42230400374e52907aa1e35d51", + "support_sha256": "7fbdaba29351715c492db511694f31daceb43d9c8d80d7842889e439a200a7d9" + }, + { + "index": 76, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "d7f8f9ba4953ec56981c3813ebda9f3de8850389900e1c9f10d504353c8923f1", + "support_sha256": "f2beaa8d4a97c3a9882bc3569d9d7e87c885ced225ecbf6835216cf60de9cdff" + }, + { + "index": 77, + "required_count": 7, + "support_count": 10, + "height": 2, + "required_sha256": "b399a5c55dc3a222bea3269867e634a62b118511a6bf92df54b8b75d5c9a4027", + "support_sha256": "ae4bddba46f6ec33e666638584bc927892786a12078d15ab951f01472bda2217" + }, + { + "index": 78, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "fd4a44871bb01c298d71ecc069b970fd29c0831c1e5262db2c5a3162674aa4c5", + "support_sha256": "dc29af172b84bef3b05d5702dc6cef2c4f4d46318fb509e17e57c6644fd1bb90" + }, + { + "index": 79, + "required_count": 5, + "support_count": 18, + "height": 4, + "required_sha256": "ca0809ce10d1ee88bff84ec515a69274de333d7606054808b084c43aadee79d7", + "support_sha256": "d2750efbe019f8dac249af03341acf2fd3bdba27da60c3e98b012ea122b49e81" + }, + { + "index": 80, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "942d8da31b33169d9dae7fd7eef3c9fec9d5c23f99058bf01accb12e827fc2dc", + "support_sha256": "f2beaa8d4a97c3a9882bc3569d9d7e87c885ced225ecbf6835216cf60de9cdff" + }, + { + "index": 81, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "ad50d33f5bd9b4231b6376f49543a9d2d5bc7e5edb9a60941a8007ff3504d4aa", + "support_sha256": "6d2364f284c07ee1fce980a5a35b95fb33e239f38dc7cfe46ddb5bee3845fe4c" + }, + { + "index": 82, + "required_count": 4, + "support_count": 15, + "height": 4, + "required_sha256": "e83d16dd5b5e51ed69f73ad88f7c0b37c0cb124d51ec46324bae1bfd664cd9ba", + "support_sha256": "c910f736f5f62c8ef2c1b8cfbc692ecf1b0940b24da13b770a76208d942bcd51" + }, + { + "index": 83, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "17a3286675ef5907495972d3fcf4b5c7e7105e2a65963f8dea8eea7ba61046f5", + "support_sha256": "f2beaa8d4a97c3a9882bc3569d9d7e87c885ced225ecbf6835216cf60de9cdff" + }, + { + "index": 84, + "required_count": 5, + "support_count": 18, + "height": 5, + "required_sha256": "2a18624335da6fc47adf9abb6855fd921eeb2b52fd14bb6c0273e365886b0afc", + "support_sha256": "1a33245c5bd2ee709602a697dad31b7793b07e1561820bf69fa97fa12b092e4c" + }, + { + "index": 85, + "required_count": 4, + "support_count": 22, + "height": 6, + "required_sha256": "4d0144e5afaf071a5a58219a6fd1daf8b4793b46c179e74e7d26cffae4efd882", + "support_sha256": "8d23459354da7e428310e316a6d428d8d19894588ce0e5a5dae033e3f0c0b4ab" + }, + { + "index": 86, + "required_count": 8, + "support_count": 15, + "height": 4, + "required_sha256": "133b8fb6dd9ead337180f2a336a95dc69038cd79efb6d4a8817420dba780328d", + "support_sha256": "82fe0a83bd625c6dd02f52b9712ddddc0164951f9ecd81fa326935e1f66c851e" + }, + { + "index": 87, + "required_count": 5, + "support_count": 12, + "height": 3, + "required_sha256": "5555af87f769b0bfe3a8825784d896325fcf57561960291cf68ab128ef9f3820", + "support_sha256": "50169052cc52a904ca1d0e5bde03012dae3b0ed485e8f0ff6b192ea05a8271b0" + }, + { + "index": 88, + "required_count": 4, + "support_count": 15, + "height": 4, + "required_sha256": "90998fcc5fe84883cabb8175e84bfaa46aeab0028c08ff3c179790d993d6aaf0", + "support_sha256": "79a382c6a2193552c59871f59cc3f42d1bce70d968234359682f56c213901ad6" + }, + { + "index": 89, + "required_count": 4, + "support_count": 13, + "height": 4, + "required_sha256": "cdeeba9717f050257d6d56f8153b289711e4f8c0a63f419f57719832272768fa", + "support_sha256": "8cd7286851afe7ce3d9fc8d5f85edb79970d687a8b56133473693ed35ea036cb" + }, + { + "index": 90, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "7f61882400b290b433af28d38f811017ed9e84a3bced1b6435b44025ce1935df", + "support_sha256": "065b30de922d4db7459659a375e0a3ba79f1a4fb830040189b13ae2f1caa58f7" + }, + { + "index": 91, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "d7f8f9ba4953ec56981c3813ebda9f3de8850389900e1c9f10d504353c8923f1", + "support_sha256": "d0ea6649750e1b97916b8bd5c6572ed6f019641040c515edc44b8208a2d718f5" + }, + { + "index": 92, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "d99efb44a5abcec826925e2fed0465cc2b4555fb41dd0dbb29ba16fffd3c5fbf", + "support_sha256": "d0efa8b306d1443f1f459b110bf1d91f4b4cc6613a8baeb9ceadede1c2f3f950" + }, + { + "index": 93, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "7f61882400b290b433af28d38f811017ed9e84a3bced1b6435b44025ce1935df", + "support_sha256": "f0f12cbc7ff14a619c80854374494faa2cfb03801d3a7ba9db2ea80becee2427" + }, + { + "index": 94, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "ff632eca5340b1fbfede7438401dc871324e7dd73901504e52c328b63cdb10de", + "support_sha256": "d4913f5890db09dea6f777a40ae0055edbff0e604670adbdd8dd7f93db4a5ae0" + }, + { + "index": 95, + "required_count": 3, + "support_count": 24, + "height": 6, + "required_sha256": "b7497e98e90cbf829caf1f542d86d5b169d4caaa14b38223575745cf6da8f4f3", + "support_sha256": "bc04b033fc25ea160bdafe0a81ccc061acc6e7ebb490168b32f942c74d1d0d27" + }, + { + "index": 96, + "required_count": 7, + "support_count": 10, + "height": 2, + "required_sha256": "e3dbf31b326d5077bc22ae2feb9cc3eb2367aadabc987c454bd0e7c428359787", + "support_sha256": "566ae6bd8238af03454fcf9dbbb144adfd860e853ad8873f47e94e014aa0d2dd" + }, + { + "index": 97, + "required_count": 4, + "support_count": 11, + "height": 4, + "required_sha256": "adc9850205ad9f76b540ea3952739bae2e18c6c923d94c7a439f26f138d11dcc", + "support_sha256": "225e5fff310296eec840afd9627a242ff229df218fe51d29bf518c012c0c122c" + }, + { + "index": 98, + "required_count": 4, + "support_count": 11, + "height": 4, + "required_sha256": "5626dd9e3b0254ebaed20f2fd87f5069fa13b6b3b0c12023f465f15132806d7e", + "support_sha256": "97760bad22f71abec90a1477df334ffbd1cadd700ebe52ef1556d9ed5bd1d55e" + }, + { + "index": 99, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "69deb011326807d93adf0f1ce02168c971ed7afbfb1a85f0163dbb51b7f28925", + "support_sha256": "7d7c5231670275050326c50ae6f5d334da888df20a3163037e5ea27627be9369" + }, + { + "index": 100, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "ca0809ce10d1ee88bff84ec515a69274de333d7606054808b084c43aadee79d7", + "support_sha256": "82e78bfd5bbc4e5c7e69566381bdfd262ffc3b2d1d0523c2664cbfa060c20eb4" + }, + { + "index": 101, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "c1a8848ffad3a0baf8e59aaf4eaa2b31af5fb3b2e52a2a31a74cb5e06ee05fdf", + "support_sha256": "95f43976f036be6619378a4db6ddda558640935bd380fb72120b20f1ee5c9ab2" + }, + { + "index": 102, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "822af8d1104148c7349bee8de53877ce38886c8e6bbbac426d6ed33c77a0a35f", + "support_sha256": "d01831d1751065f81b3d86b2ba8f75653dbca5579ee76f0af476fb047fef8050" + }, + { + "index": 103, + "required_count": 5, + "support_count": 12, + "height": 3, + "required_sha256": "d409d6c28fe44dfa09acb61858b1880cef60e2c752a465ab9527e79379d05e2b", + "support_sha256": "b1b793cf72de0e24f21f1edd3863b9157dd35f7dd923ff3be68aa995166ebb9b" + }, + { + "index": 104, + "required_count": 4, + "support_count": 21, + "height": 5, + "required_sha256": "28b38860972421fd8f7b22f750256999212f6b21ca47f5097c26eb69c3f95c80", + "support_sha256": "9b355c1330adf3a87aa21cb5785406d17892e974e564043a6bda28d185158052" + }, + { + "index": 105, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "eabd7d391e6e684982ea8b90dfb2dea14d505d74a1e84bb93042c25881b9a519", + "support_sha256": "6cffa12689762b88ca2e411bd750d84fdfc508f00d55ab876245f1b2a3600019" + }, + { + "index": 106, + "required_count": 4, + "support_count": 13, + "height": 4, + "required_sha256": "92b3cd2020c841b6a9bbb85b713eff40feff5b21e256b07799a6680e4924017e", + "support_sha256": "8cd7286851afe7ce3d9fc8d5f85edb79970d687a8b56133473693ed35ea036cb" + }, + { + "index": 107, + "required_count": 4, + "support_count": 15, + "height": 5, + "required_sha256": "cc8dab421f8fc729c9b11796ec6181a1f91d1717b7f026b39866e96aab3e5818", + "support_sha256": "c7420ee8ad2a5ee64cd8fa02509f5e12c21fa6b631d6b725e3111c8c3e351548" + }, + { + "index": 108, + "required_count": 5, + "support_count": 12, + "height": 3, + "required_sha256": "bda0b7891725f677c1e9f7046cf2e9dadd3f0d0308a0ec12bba0cbdedd1bc5ba", + "support_sha256": "08c3eeafecb0025e8b205097c7997336924b829ae2cb1211563cb00e34ee3cab" + }, + { + "index": 109, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "7ec9e15e4121bf998747a247603ab19c50adfcfe924b87638630be5cfe081c41", + "support_sha256": "7d7c5231670275050326c50ae6f5d334da888df20a3163037e5ea27627be9369" + }, + { + "index": 110, + "required_count": 4, + "support_count": 20, + "height": 6, + "required_sha256": "85a4b793cfed64443749fc058430697632a5dbd91cccdabc3f04df648aabc4b2", + "support_sha256": "33f76a2fe7409a5c471affeb111563bd094fa245d72d073ed506647dfde5eb84" + }, + { + "index": 111, + "required_count": 4, + "support_count": 21, + "height": 5, + "required_sha256": "90998fcc5fe84883cabb8175e84bfaa46aeab0028c08ff3c179790d993d6aaf0", + "support_sha256": "7a1ec73bbee6db30d30f21b9b96dba086934899f20faf55208277202f49eaf3f" + }, + { + "index": 112, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "1a42d42d9ca272c4aacd3ca48f6225256f38f44f41d9e02426b28d43d4f492ae", + "support_sha256": "4a662e30f6f0bfbdbf7881f1e2e7bf898f7bbe1fefcb2b306adf22c931a2a851" + }, + { + "index": 113, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "b6a66505205a2f016f0d31489494b62506223d5bf486c2caca3556b2f25715b6", + "support_sha256": "7ff8b5e42472f85bf169f240588ef4cb09e223a2e3302cd24135e4954403d494" + }, + { + "index": 114, + "required_count": 5, + "support_count": 20, + "height": 5, + "required_sha256": "9f3e25ac4fd59704938b52650f2a3f8de720eb5c7b6b6ede6b1fe9179ad0d67d", + "support_sha256": "c50a05e1efb6a2a885a761f10f7c3e309fbb8f30b161518b9ea144e759e9bffd" + }, + { + "index": 115, + "required_count": 4, + "support_count": 21, + "height": 6, + "required_sha256": "d44500532a29af7be6fccb33d49559834fe0a107e0a52f116936dd28b0a1e129", + "support_sha256": "92d808aeae402f5807add896c7d2412aaeeee2d99753832186023d0b7b92a255" + }, + { + "index": 116, + "required_count": 3, + "support_count": 25, + "height": 7, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "7df97802019e30e22032ded3dcfeea25b09f121175dd21e71d77cac518312cab" + }, + { + "index": 117, + "required_count": 3, + "support_count": 25, + "height": 7, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "e957424184dec7e05cb56ca50c823eec75d71f94f3f2e3092ce4f33dc77d5515" + }, + { + "index": 118, + "required_count": 3, + "support_count": 27, + "height": 7, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "38be9ba517b691be0c76faa6e80b812cb1350de7b966e872438b7bbe03bf407a" + }, + { + "index": 119, + "required_count": 4, + "support_count": 21, + "height": 6, + "required_sha256": "85a4b793cfed64443749fc058430697632a5dbd91cccdabc3f04df648aabc4b2", + "support_sha256": "92d808aeae402f5807add896c7d2412aaeeee2d99753832186023d0b7b92a255" + }, + { + "index": 120, + "required_count": 3, + "support_count": 30, + "height": 8, + "required_sha256": "a14a0c93efdef71ea3d53914f9196ece68995f720990bfbdd5877f6863697556", + "support_sha256": "53a0e5428ac747d151e2b5564142791efe2e99532180fbeb8910f4af37d78b84" + }, + { + "index": 121, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "9bda604385f85ede6375bb737776e63ebfb53b06c0571463b62c37c3de2e9c84", + "support_sha256": "c50200111f945a16778a2c9db403a2d9d1a4f39cec71c232ec27bd1f87dbe96c" + }, + { + "index": 122, + "required_count": 4, + "support_count": 19, + "height": 5, + "required_sha256": "3a882ac00732a2af598d0c023dda1934aa452a4bc55e084afef9297fa5ffd926", + "support_sha256": "ec26ecf579630ea09336ed8459fe6ee3188c39aadd096798bbd8e9dfaf565f4e" + }, + { + "index": 123, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "cd0b671658a9db673933a304d86cfbe3f945023c59c2fa0764697a086cec627a", + "support_sha256": "132540dbc82ca44e284ce6b90670fc572507e2a092360129406ea55545f0c005" + }, + { + "index": 124, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "3262ffb18aa1e7a8cc3d6e950bf0bc31d48ffbbd6e55ad3da4327cb5d567861d", + "support_sha256": "19fc43a1cabc6da7b1579a1338913edb4228f6f074149d08f432699d014c3140" + }, + { + "index": 125, + "required_count": 4, + "support_count": 11, + "height": 4, + "required_sha256": "adc9850205ad9f76b540ea3952739bae2e18c6c923d94c7a439f26f138d11dcc", + "support_sha256": "64000b37ac6a0e2413d20b6cac45362716927788214eea4d0354a6e9b7af2a99" + }, + { + "index": 126, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "c327907054fcf98c8c3ff3bba737ab8daed634872eb63e4b0ad755e20fdd7505", + "support_sha256": "b9addde846672ee175d18b61b6c4253a19017c0d1faddeb56e2928f2c638e13a" + }, + { + "index": 127, + "required_count": 4, + "support_count": 16, + "height": 4, + "required_sha256": "708b5845b1d78bff93c1d76d7b707b3b6b9587e7d3efac8da9d5ea2002ab0b77", + "support_sha256": "712d165bb1ec07ff3459dae52f38bd04ad3e1b0900f579e9e7a2903b240abfde" + }, + { + "index": 128, + "required_count": 4, + "support_count": 16, + "height": 4, + "required_sha256": "708b5845b1d78bff93c1d76d7b707b3b6b9587e7d3efac8da9d5ea2002ab0b77", + "support_sha256": "ff131db74c3cd1d785af4b89602dbf36a6bbce640e0cddfccc7188a41684ffa4" + }, + { + "index": 129, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "c673c446da05dbc5791e88bcfbe11e190c3897884296862c2b82f402e68a77dd", + "support_sha256": "8b3e25ee4cc25c631eb11b3f42392b1e57e88e9096555d76fc4daef7c117efb6" + }, + { + "index": 130, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "0af697f23928d87d76a4429af211ce899ad1a319ab7b7838394d89e56c727853", + "support_sha256": "a0d1a75d3a9a271de7c2e41f51428d9f229d5d695f175045ab06743edb9c6014" + }, + { + "index": 131, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "14386ffcfb5fed03adcc748ed09eb8aba333eb13eb93b909d9c2a92b60aa6c0f", + "support_sha256": "4d0a2d840797e53496de644e74018697607054c757dace187d023db1726efb45" + }, + { + "index": 132, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "419f063e41245f000e8eb1662621e4cf41980b994df2166c0967b496a032dc41", + "support_sha256": "271f4749d30a851ba81aa114076c9bb049372e95aeed850e043dac5053c95055" + }, + { + "index": 133, + "required_count": 4, + "support_count": 13, + "height": 5, + "required_sha256": "8c857eb5533d8d09ba6fbc6a775b49f709bc47b059a47dd3b06efcdfc74afca3", + "support_sha256": "73580caa672ca4ef490299de959ac8e4ab861bb4dcfe5f5098b73158a69bd6a7" + }, + { + "index": 134, + "required_count": 4, + "support_count": 18, + "height": 6, + "required_sha256": "3f1c678ef9a5c9de5e4b2e87f1762db0ec3c056419b739c1534e9204c92fd67d", + "support_sha256": "35efd48bc1be1c08bb39af22d5b97a87fa70645d17bd5db6561f3feec894ed34" + }, + { + "index": 135, + "required_count": 3, + "support_count": 19, + "height": 6, + "required_sha256": "265b3f579658c0d7fd358fce117f7fb1aaf9694b018c3daa637718c1b6aded12", + "support_sha256": "bba83d4c0874d27b7d325181f9e981ac6ceb450da65566d0d1412fc1bd05cd1c" + }, + { + "index": 136, + "required_count": 4, + "support_count": 18, + "height": 6, + "required_sha256": "3a882ac00732a2af598d0c023dda1934aa452a4bc55e084afef9297fa5ffd926", + "support_sha256": "023d7bfe8ac706b5cebcf93ee884e392470b2d590133d5627f037ec8885406ce" + }, + { + "index": 137, + "required_count": 3, + "support_count": 19, + "height": 6, + "required_sha256": "ac0de9c14e79556f69d7d334af1f188b57fd6cd82ad4b12776f599a2f5137e3e", + "support_sha256": "44aff5280eb319345d56cf3ac92dcd456ec052a3f9c781cc550ae0bad1466a89" + }, + { + "index": 138, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "54fa3d7382652f49e7cf387e010d39633ca115ca56185971abb1e7509067f2b3", + "support_sha256": "160cac1a91e0634c7b0c3cb87c4b0736cc044eef31152b0f69a57bf7470b3bd9" + }, + { + "index": 139, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "3e352053479907f73c2e94bc5f485b3752c527940d9794d360daafb1321b2844", + "support_sha256": "344c4373e6b4ee8a99808eb2dd7802cfbeebe80d46f472f7d63d966f92499885" + }, + { + "index": 140, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "3e352053479907f73c2e94bc5f485b3752c527940d9794d360daafb1321b2844", + "support_sha256": "30b8d4dc69466981280c42a6f2b9cc7633156143cf313ca47bfdfd79f1e2aad5" + }, + { + "index": 141, + "required_count": 5, + "support_count": 13, + "height": 4, + "required_sha256": "f6a706b77d3422936868b82f3e5f31da6896acb28ea2a9ba718316040b55789e", + "support_sha256": "9745b59f3ebcda3a8ec8bb0176d95b2d387bbe4c483f8b4510a039ab997fa607" + }, + { + "index": 142, + "required_count": 4, + "support_count": 14, + "height": 5, + "required_sha256": "6b1e67f4b3e546a8f5c2b95c007a8baca46653df8da739b11c5f44d5d0621097", + "support_sha256": "b95caa1a5ad2206c27ab66f55ea5d1243da326ac790aa020004c8dfd38838640" + }, + { + "index": 143, + "required_count": 5, + "support_count": 12, + "height": 3, + "required_sha256": "7f61882400b290b433af28d38f811017ed9e84a3bced1b6435b44025ce1935df", + "support_sha256": "79c8aa4a87cf46cb2d9ff1f1bd6aa23c23c3e3e29452e5a382709999a0573f47" + }, + { + "index": 144, + "required_count": 4, + "support_count": 18, + "height": 5, + "required_sha256": "0089354c7302c82288fefdbf26c952a2035b2c3456fe766b5eba918c0d02291a", + "support_sha256": "1dda692e3722a81970a8cd7502f7756cffbaefdbd12b4908ac2b424b72709fc3" + }, + { + "index": 145, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "1cc464c362de9514df60c5d7492222fdb017c8589a7474e68e0598a488e16200", + "support_sha256": "9df6fcd24274b38c32ee8242097974cb664825bc412dd22339442528d6515a11" + }, + { + "index": 146, + "required_count": 7, + "support_count": 10, + "height": 2, + "required_sha256": "68ed96f8725537ec5436a0e0c55c2f59b4cfaf0e1812a4796d5057917d6ea087", + "support_sha256": "ae4bddba46f6ec33e666638584bc927892786a12078d15ab951f01472bda2217" + }, + { + "index": 147, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "ad50d33f5bd9b4231b6376f49543a9d2d5bc7e5edb9a60941a8007ff3504d4aa", + "support_sha256": "9df6fcd24274b38c32ee8242097974cb664825bc412dd22339442528d6515a11" + }, + { + "index": 148, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "beff5a6099fb0f398745ade0340db0c19f3805f4deba8696567cb87d1ca059ca", + "support_sha256": "d0ea6649750e1b97916b8bd5c6572ed6f019641040c515edc44b8208a2d718f5" + }, + { + "index": 149, + "required_count": 4, + "support_count": 11, + "height": 4, + "required_sha256": "141a85882ed9b847e0d64750a73a3eee074dca975c842098c8ce7cbd300d139e", + "support_sha256": "64000b37ac6a0e2413d20b6cac45362716927788214eea4d0354a6e9b7af2a99" + }, + { + "index": 150, + "required_count": 4, + "support_count": 13, + "height": 4, + "required_sha256": "adc9850205ad9f76b540ea3952739bae2e18c6c923d94c7a439f26f138d11dcc", + "support_sha256": "8cd7286851afe7ce3d9fc8d5f85edb79970d687a8b56133473693ed35ea036cb" + }, + { + "index": 151, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "5555af87f769b0bfe3a8825784d896325fcf57561960291cf68ab128ef9f3820", + "support_sha256": "41b3762123e09078073856028ff922327683c35f3942292f6ccfa22d3f291aad" + }, + { + "index": 152, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "e774a8ff2ba4f4e916dbde12e13efb058696dd4a91ec5842dcb0b2f2066f66e0", + "support_sha256": "4a662e30f6f0bfbdbf7881f1e2e7bf898f7bbe1fefcb2b306adf22c931a2a851" + }, + { + "index": 153, + "required_count": 7, + "support_count": 10, + "height": 2, + "required_sha256": "1336e0a9b6de325b57e4d65aff9903b64839ebff5a8b6b8fc08cc51152aa2bd0", + "support_sha256": "e86b087e6b709b1cbd1594af0d408eecb183dd5bef0aeb2ce6b5688d64298158" + }, + { + "index": 154, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "0b77e838277901a5c7d09966a154d124da4a0534b4885c9fc74e337a539f0e51", + "support_sha256": "8b3e25ee4cc25c631eb11b3f42392b1e57e88e9096555d76fc4daef7c117efb6" + }, + { + "index": 155, + "required_count": 4, + "support_count": 18, + "height": 5, + "required_sha256": "ccb61cbf9cc207559b62755d7b1d828625dec0256be66d40fa6d2c23aa04aa2b", + "support_sha256": "5a1118326d5f216eaa923452d192e2b2d5d66c8860af5c2e19b50e3605a84694" + }, + { + "index": 156, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "4b5c051686b9d43cabb6a8374b80c271cb818d29ca2daabd646a29dce55450b3", + "support_sha256": "c50200111f945a16778a2c9db403a2d9d1a4f39cec71c232ec27bd1f87dbe96c" + }, + { + "index": 157, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "7630ea403d3acc085c613d26c9966101b5b0d30406aa288d85386783c253259f", + "support_sha256": "bcd891c837c8b03c0ac2ea4a8688807cbb84e1698f8f2cb4fd0066e4b6b99f02" + }, + { + "index": 158, + "required_count": 4, + "support_count": 11, + "height": 3, + "required_sha256": "59833bbecd053d9e044b980f19fdfd7b81b6a914a60d4570921f1c60dfe2e36c", + "support_sha256": "97760bad22f71abec90a1477df334ffbd1cadd700ebe52ef1556d9ed5bd1d55e" + }, + { + "index": 159, + "required_count": 5, + "support_count": 12, + "height": 3, + "required_sha256": "86440170d400e2e3d5cf5405cba3ba81e41960d70c7eb7ad20492269ee80862b", + "support_sha256": "f2e642846e833e24acba744193865ce3f20053eae5f4196fdf16a8fcbfba6554" + }, + { + "index": 160, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "3d2fe1fbdd1158b57c8700e1984b839ec31f1fb8ddfcc80d01d4b9ae07ac8a7b", + "support_sha256": "7d496ba9b1af072867a67871f633949f54ded124479769c1b654ee21f9b15d64" + }, + { + "index": 161, + "required_count": 4, + "support_count": 18, + "height": 6, + "required_sha256": "d44500532a29af7be6fccb33d49559834fe0a107e0a52f116936dd28b0a1e129", + "support_sha256": "362d5c18a45280a4118f9b625fa59aa1b7a51213e90c7b6de9c1681b73f2c6a2" + }, + { + "index": 162, + "required_count": 4, + "support_count": 18, + "height": 6, + "required_sha256": "d44500532a29af7be6fccb33d49559834fe0a107e0a52f116936dd28b0a1e129", + "support_sha256": "2c6f40bc5ab85042a249ae8dcd6f0f09642247e3ed5c4f8838a9cb14ce17b1dc" + }, + { + "index": 163, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "cc8dab421f8fc729c9b11796ec6181a1f91d1717b7f026b39866e96aab3e5818", + "support_sha256": "a0d1a75d3a9a271de7c2e41f51428d9f229d5d695f175045ab06743edb9c6014" + }, + { + "index": 164, + "required_count": 6, + "support_count": 15, + "height": 5, + "required_sha256": "f17c8fe6296abefe310a00b0efbd46c5fc0ff5c1e96546be8d4e2df21e724cc6", + "support_sha256": "f60636f8ef999fde01a8782796a0b52fc63f1a0b965c184025b02da01b8cffb5" + }, + { + "index": 165, + "required_count": 4, + "support_count": 15, + "height": 4, + "required_sha256": "e83d16dd5b5e51ed69f73ad88f7c0b37c0cb124d51ec46324bae1bfd664cd9ba", + "support_sha256": "7b75c2fbc40fa9311fab29347ca2d27f7e7b68c742927a11188e58eaed28ec09" + }, + { + "index": 166, + "required_count": 4, + "support_count": 20, + "height": 6, + "required_sha256": "e99d83915898e27d7072404e882de8e3cc899c80ff2fe1d87b3f50ca1610940e", + "support_sha256": "9ab9067fef65439b6125a232056010fa5390b90d8cfa26e5ec0782747a88a1ee" + }, + { + "index": 167, + "required_count": 6, + "support_count": 17, + "height": 6, + "required_sha256": "479ba7b1d927ca3cbe08b2762d27fab143f2df52cc31444e396bcb6c0a619b65", + "support_sha256": "6ae8a6829c21df7fd522ca3619fd649b1a17e9699552eb316d9ba64ec5a20395" + }, + { + "index": 168, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "5a6e97a3a99c999259a3399beef48ed7b865ebb4fc925de8430c3db07e74d85e", + "support_sha256": "08c3eeafecb0025e8b205097c7997336924b829ae2cb1211563cb00e34ee3cab" + }, + { + "index": 169, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "8e9c655688b44d135de6e86caa3272c1d24e02f093c1e808743fedfaed6ce0a9", + "support_sha256": "b65166013d60f36226d9dbe4b7c8bb8eabd47a9cf88ee43cb1d34f842f9d73fb" + }, + { + "index": 170, + "required_count": 7, + "support_count": 10, + "height": 2, + "required_sha256": "7f187b3f1c46b3c2b9f24de18186eecb0f4e7bf0625b1f6298bd83c28b7a0d7b", + "support_sha256": "053bdc5ae8fc11afc188a7cd6ed6e727a7ae5048f33bed7e1edfbbd79426ad82" + }, + { + "index": 171, + "required_count": 4, + "support_count": 30, + "height": 8, + "required_sha256": "d44500532a29af7be6fccb33d49559834fe0a107e0a52f116936dd28b0a1e129", + "support_sha256": "8af0aaccca6381df7a92a8c91cb5779cb4b28e5f9806a9407686de418541665d" + }, + { + "index": 172, + "required_count": 3, + "support_count": 24, + "height": 6, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "297e25345ba56903e7efeebd1e99ac68eb65748d5802bb371c849a56ae61e7e6" + }, + { + "index": 173, + "required_count": 3, + "support_count": 24, + "height": 6, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "748b63875334b3ec1d58ed8c9f931492237ce8f0abdf03935b0dc0182e6743c0" + }, + { + "index": 174, + "required_count": 2, + "support_count": 41, + "height": 8, + "required_sha256": "61d1ae33e86588c85dbdef4beef4fb07795d1246b22f2dbbd12c2bd626e6b255", + "support_sha256": "3396f9c314e64509f9a1760ebfca38ba0746c83471b987c5d93df9f507562c19" + }, + { + "index": 175, + "required_count": 5, + "support_count": 15, + "height": 5, + "required_sha256": "2a132e3b8cdc4984e9c8999afd9d7f11beae38754a4f9c5a0787756051680875", + "support_sha256": "2a7531ebb6f7a934fc1ca121b1b6c4e908a07c0c4a700fe344c7640f2d7d2f5f" + }, + { + "index": 176, + "required_count": 6, + "support_count": 15, + "height": 5, + "required_sha256": "ccb3234d0580387e6d2b5f3e2fbc44da0931bc2a7a3ba8199a1556d358005588", + "support_sha256": "f358c3603d47b7f544fd9d0ac338a77dfaaf8b8f58cf2a22fe5f2e50444f08b2" + }, + { + "index": 177, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "14386ffcfb5fed03adcc748ed09eb8aba333eb13eb93b909d9c2a92b60aa6c0f", + "support_sha256": "9975877a46669957044d4b7239fdca29b2f7ef41f34ee7f43a2744ee69867716" + }, + { + "index": 178, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "79ee0cd52179c7019e110246bbaf675c2e0c450d600a7735a363fd2ac601f001", + "support_sha256": "06d490a5c12e6320c63e91b1ee1f105f2e5121fdab4102c5e4bcdc57af3bf1ae" + }, + { + "index": 179, + "required_count": 4, + "support_count": 13, + "height": 5, + "required_sha256": "8c857eb5533d8d09ba6fbc6a775b49f709bc47b059a47dd3b06efcdfc74afca3", + "support_sha256": "eb94fc8eb1974fd3ede4ac067c88e6de54f33dbf08b681132152c5fd76558d0e" + }, + { + "index": 180, + "required_count": 4, + "support_count": 18, + "height": 6, + "required_sha256": "3f1c678ef9a5c9de5e4b2e87f1762db0ec3c056419b739c1534e9204c92fd67d", + "support_sha256": "07900421ccc57706a7e472fd894c8d6ee658f653214ac6288a7da88051177b94" + }, + { + "index": 181, + "required_count": 3, + "support_count": 19, + "height": 6, + "required_sha256": "ac0de9c14e79556f69d7d334af1f188b57fd6cd82ad4b12776f599a2f5137e3e", + "support_sha256": "4c0c6d617d6e2ef452708489f9d82645476e71ba126428c48c98f0f60257774f" + }, + { + "index": 182, + "required_count": 3, + "support_count": 19, + "height": 6, + "required_sha256": "265b3f579658c0d7fd358fce117f7fb1aaf9694b018c3daa637718c1b6aded12", + "support_sha256": "93f603e4302b76870910bbebb7c10ce64200687e816c17dd5b63f81de2adb2d7" + }, + { + "index": 183, + "required_count": 4, + "support_count": 13, + "height": 5, + "required_sha256": "ac4688418480f7e9cf5d249a7645e709f1b56c7d005a8fc970bd291ed674aa9b", + "support_sha256": "f2a389ef9fbc22c0b37b8bca525910902ee26b1ce587a7dcd06774eed833034d" + }, + { + "index": 184, + "required_count": 4, + "support_count": 21, + "height": 6, + "required_sha256": "df35f5207d1073c12555f85d66ed74753583f7365c375e21972828f267b4f8c8", + "support_sha256": "4fae6a8a034451a91c40412f0e9ae4c23b66c877dfb52f55c0ff0c8b40de3445" + }, + { + "index": 185, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "a6c18e316a1842404848ed11af60d52d7062d3cbe36327acb71941ff6da513d3", + "support_sha256": "ace51c605cc4cfcb36d58284e93b0cf8a1f2e733b524db0c1c7dc8a2e8302497" + }, + { + "index": 186, + "required_count": 4, + "support_count": 15, + "height": 5, + "required_sha256": "56e80ede3fdee4020d104828bf6ed5dd7ee45c1b76df68f3fbb45672a1a2ab94", + "support_sha256": "77c0438e454dba2b508e8f3258988f1bb72a918775ab6c913c5eafc546705bf8" + }, + { + "index": 187, + "required_count": 4, + "support_count": 15, + "height": 5, + "required_sha256": "b6876aeab74d2dfc19309cb9214dd23dc7755df5a52f113e4da5dcdcfe7e5f19", + "support_sha256": "84b695bd05e800a29940071a7c9f0f472a5d4dfe0456e2c5f6afc1f05f100416" + }, + { + "index": 188, + "required_count": 3, + "support_count": 21, + "height": 6, + "required_sha256": "265b3f579658c0d7fd358fce117f7fb1aaf9694b018c3daa637718c1b6aded12", + "support_sha256": "985db87a2913134d84bf835a04c213fb686fd2f065db6e6d589e27c6a603d774" + }, + { + "index": 189, + "required_count": 3, + "support_count": 19, + "height": 6, + "required_sha256": "e449fdee4a3226a9777d4125c4018215b7991f8bbe8536671a81beadaba5e6f1", + "support_sha256": "782ce577ecc0eebe8948039216df3ef13a68cd2375551ce4653b97d22d6ae228" + }, + { + "index": 190, + "required_count": 3, + "support_count": 21, + "height": 6, + "required_sha256": "265b3f579658c0d7fd358fce117f7fb1aaf9694b018c3daa637718c1b6aded12", + "support_sha256": "5fc38641eaf95588c1c2fa78ed6e2aa51e7f57daea3f393c95cc2ef21bf62e30" + }, + { + "index": 191, + "required_count": 4, + "support_count": 15, + "height": 5, + "required_sha256": "8d0d0c77559ba009c5b6581d245814abafc3345b766313e3723445846710c2df", + "support_sha256": "5c92df3763646e140bb3a211c7ddea359d9e606b15ba96cd91fda1e4c8b4d7d2" + }, + { + "index": 192, + "required_count": 3, + "support_count": 19, + "height": 6, + "required_sha256": "e449fdee4a3226a9777d4125c4018215b7991f8bbe8536671a81beadaba5e6f1", + "support_sha256": "5970111b5ad9a3d78672264a25068f94ea944c92368405d67c6638709f26eced" + }, + { + "index": 193, + "required_count": 3, + "support_count": 21, + "height": 6, + "required_sha256": "e449fdee4a3226a9777d4125c4018215b7991f8bbe8536671a81beadaba5e6f1", + "support_sha256": "9e60f5d5ef5508b83d1aeb825060d5fc2fa28543120e06807348e4d9afc2b4c8" + }, + { + "index": 194, + "required_count": 4, + "support_count": 13, + "height": 4, + "required_sha256": "cdeeba9717f050257d6d56f8153b289711e4f8c0a63f419f57719832272768fa", + "support_sha256": "8df5c23249f7e06321ec4820d8089ebfe6357a0bec1a740c04d1cc7b39ade0c2" + }, + { + "index": 195, + "required_count": 4, + "support_count": 13, + "height": 4, + "required_sha256": "acc57e38519a06f568622d2896fd6a06732c1fccce0d01b0cf02d99077648f09", + "support_sha256": "8cd7286851afe7ce3d9fc8d5f85edb79970d687a8b56133473693ed35ea036cb" + }, + { + "index": 196, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "708f625edf420b5f2e5a547dd562641b291bba2f1dde1852dcd566a18a6a17f1", + "support_sha256": "ae5bfbeb7e3c280e343da7f62409fa7cb6ce012f6b40457f81a46f9f2b36d632" + }, + { + "index": 197, + "required_count": 4, + "support_count": 17, + "height": 5, + "required_sha256": "46576f3a23c8ffdd313f5e32976e9e0e9bf70d6bba3be98f43a262c22bc344c3", + "support_sha256": "aea7ac586442b15846c26d1d0eb57addf7e7c6494e0fad4ec1347287e55c072d" + }, + { + "index": 198, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "fb56a7a6f633b1582d0751674e5d5164592f0394bedc2c0eafe988ac5ac7421f", + "support_sha256": "0d575c60fd57ac88f59a724d783b4c6f1e6a74a9b35f6fc6b877fb4216dd87de" + }, + { + "index": 199, + "required_count": 6, + "support_count": 13, + "height": 4, + "required_sha256": "2eefda62a77a9c756105b72386495236fd724c9cbfbe0aae9aac7989b90dc2f1", + "support_sha256": "a1a688dd0c44db809aa41c14b4946fff3c4f4f1e82cf2b3fa6c9018a5aa918c0" + }, + { + "index": 200, + "required_count": 5, + "support_count": 8, + "height": 2, + "required_sha256": "0b77e838277901a5c7d09966a154d124da4a0534b4885c9fc74e337a539f0e51", + "support_sha256": "160cac1a91e0634c7b0c3cb87c4b0736cc044eef31152b0f69a57bf7470b3bd9" + }, + { + "index": 201, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "6bb211656cc44663f496a3ffc70c2fcfb0561b42b04aa0a04959b94f594fec9e", + "support_sha256": "dc29af172b84bef3b05d5702dc6cef2c4f4d46318fb509e17e57c6644fd1bb90" + }, + { + "index": 202, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "1cc464c362de9514df60c5d7492222fdb017c8589a7474e68e0598a488e16200", + "support_sha256": "950480fb0ecb0a206439a5556b026793db8c95ba2e3d84b508e230897f38807e" + }, + { + "index": 203, + "required_count": 5, + "support_count": 16, + "height": 6, + "required_sha256": "29cb3a9f97db7a677561a83f4368b87cc8492309c0d1da9598bdb5d05721d1eb", + "support_sha256": "100be665ee67bf447397e69d260cad89382e04b69f10250750984813586f47d1" + }, + { + "index": 204, + "required_count": 5, + "support_count": 22, + "height": 7, + "required_sha256": "7bb2c405fba658d02fd1fe11b7717877dd3048ff72dc3516a3862d10ee37af04", + "support_sha256": "d42b5f95ddd56f9366b1177d01891d797a3115036223ce20420f409e49171632" + }, + { + "index": 205, + "required_count": 6, + "support_count": 13, + "height": 3, + "required_sha256": "d220c37f7b309ebedd1a9644c530202199c344e3d63a4895d01aa2c9a82fb0df", + "support_sha256": "00fa2f15e73bdf3a3f6e6e2ea02379fae24e9f584cc665be7a574d00976043b7" + }, + { + "index": 206, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "fc93a3edc3dc9596af829cf5717f7e234ae6ebd90490560d2c7ab29ce7349dfe", + "support_sha256": "2dbaa9780166a404daa9f1aecf7d283d2825d7f63bc5b1cc9bbac3056d3d28d8" + }, + { + "index": 207, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "4b5c051686b9d43cabb6a8374b80c271cb818d29ca2daabd646a29dce55450b3", + "support_sha256": "dc29af172b84bef3b05d5702dc6cef2c4f4d46318fb509e17e57c6644fd1bb90" + }, + { + "index": 208, + "required_count": 6, + "support_count": 13, + "height": 4, + "required_sha256": "7630ea403d3acc085c613d26c9966101b5b0d30406aa288d85386783c253259f", + "support_sha256": "4da1e65ac72e4cb332ad7a3a9919d2896cefee22a57feefd75f643fc0c24f95e" + }, + { + "index": 209, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "6751c73d0fcb78129e5ddc83a5a1ac611b3973ea0a0c8f95cccb3157c6b4d348", + "support_sha256": "a0d1a75d3a9a271de7c2e41f51428d9f229d5d695f175045ab06743edb9c6014" + }, + { + "index": 210, + "required_count": 7, + "support_count": 10, + "height": 2, + "required_sha256": "ba90ae05df6f6d04e7b2a4327650236ea3368fe1d2d9ed116e0cd1c3e8f70496", + "support_sha256": "0958dcf24df882bdf026a2ba7d7a0056e33640f6fb5cdd60250b792e978d3462" + }, + { + "index": 211, + "required_count": 4, + "support_count": 20, + "height": 5, + "required_sha256": "e746cd659848a8c9a06245718c381437c6a6e71f17c054c1ce204e511086e33c", + "support_sha256": "0a9c72ac9a9fe096a911bee306db92d7dfbaa55b98296131c5dabf76064efee5" + }, + { + "index": 212, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "1a6799bdadcace23f4b66e1fe66543356e1a1a872088580ef2280d6c47c74250", + "support_sha256": "b9addde846672ee175d18b61b6c4253a19017c0d1faddeb56e2928f2c638e13a" + }, + { + "index": 213, + "required_count": 4, + "support_count": 14, + "height": 4, + "required_sha256": "90998fcc5fe84883cabb8175e84bfaa46aeab0028c08ff3c179790d993d6aaf0", + "support_sha256": "c8177775841f431010faab2924d48d8d0a6b6fcff4223f3f70ea227280e27f5d" + }, + { + "index": 214, + "required_count": 5, + "support_count": 17, + "height": 5, + "required_sha256": "5eaa0d3fcae896c780e81596b48c019c6247d044d5843407ea8e73057c75143e", + "support_sha256": "1906e426e933ef1bc567305cb01ac01bb99571cb5ae77114cf357000ff12312e" + }, + { + "index": 215, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "3b8935f9552086d483c1676e644116c3f3ce10b7dbbfa3c21c901ea66f45c523", + "support_sha256": "791104bb7311ba4f197d94875f6533fc0d864f651b7de87fb6d10af2758489f2" + }, + { + "index": 216, + "required_count": 4, + "support_count": 15, + "height": 4, + "required_sha256": "e83d16dd5b5e51ed69f73ad88f7c0b37c0cb124d51ec46324bae1bfd664cd9ba", + "support_sha256": "6e36ec0bc646f620b9988fba232f811a62dbbed40b28361130ceca2683ea0832" + }, + { + "index": 217, + "required_count": 4, + "support_count": 18, + "height": 6, + "required_sha256": "3a882ac00732a2af598d0c023dda1934aa452a4bc55e084afef9297fa5ffd926", + "support_sha256": "59bc80db71df2da814b463ce87bcb4338dc69c5e3056e57bfe171359d139781c" + }, + { + "index": 218, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "d0572e632060882b13f3d0ccb2a69fa23dc390248cea155dec5f1fa5f7d3b832", + "support_sha256": "62d2bfcc50f102c0367053937606a602a2445c3496eb2e664f6f0419102117a8" + }, + { + "index": 219, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "585999ef8eb35b31b8bb430785413b2afde2972d76ff6c35b0681baa45dc50f3", + "support_sha256": "e4bc400708fe2957cc5592d15540b9f18f72008fd4d6707c221e0118bed2d2da" + }, + { + "index": 220, + "required_count": 7, + "support_count": 10, + "height": 2, + "required_sha256": "c13c00ae15bf218d60813f023ab48a912ccd9824807676247d59a445f3986e0c", + "support_sha256": "f5e67efa2b4b497b40f750fa97033b267dece34098e743303010ee65c7f70b09" + }, + { + "index": 221, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "3a680c9a5f39613d147dcbf28286bb0fd0d672055eed8bdd7e12cc1a44531ae0", + "support_sha256": "cb5f03a707c76e17f6bb0936932162cd1c222ab8876c321e59055063b1867b64" + }, + { + "index": 222, + "required_count": 7, + "support_count": 12, + "height": 3, + "required_sha256": "766a23a489ddc781861ea1b28d3cd03cd02de7b76298911311232642ee4f132b", + "support_sha256": "b4fd48d28317c1cb44546d5c57fe3af06219108a34a37c5eb65a0c09f59327e5" + }, + { + "index": 223, + "required_count": 7, + "support_count": 12, + "height": 3, + "required_sha256": "097103463f1fe79d77f26ce172d04ed216913f9ea1939c75b46dbb8fd2905484", + "support_sha256": "935cea41940368ef9fc39f549a53b90d1eb254e81c7e90a95e36ce22767d6d25" + }, + { + "index": 224, + "required_count": 6, + "support_count": 9, + "height": 2, + "required_sha256": "36f44179edfd375b8eed9526e39e509a64ee332600d3dc86a5976b62de1d415c", + "support_sha256": "76863e5f6c5e1b27ac95815c73d771dfd2d8530b8678586c1d404a231d4efce8" + }, + { + "index": 225, + "required_count": 4, + "support_count": 19, + "height": 5, + "required_sha256": "8d0d0c77559ba009c5b6581d245814abafc3345b766313e3723445846710c2df", + "support_sha256": "1b24412fc8b455b2bafb731aa4490fc8e764f67a76ba12da3f838761ef7c7f14" + }, + { + "index": 226, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "cc4554cd404ebf2577d8165c3edec5e79ed076f24115c3f43e8803f69668965d", + "support_sha256": "6a53e33c8c6efd945614ca8173827205fc9a75c787b63dc8ffb3b1f9fbc5e08d" + }, + { + "index": 227, + "required_count": 6, + "support_count": 13, + "height": 4, + "required_sha256": "c64ab16f278a5c234caea7884ccc8d6d4a9360ae40e26a3d60a29c2567a9a3d6", + "support_sha256": "63260c277fbfa6429c60eb21fd832dcca983155ea7e1a11ff0abec250fc67784" + }, + { + "index": 228, + "required_count": 5, + "support_count": 18, + "height": 5, + "required_sha256": "07c2f01e1761d467289e93f3dd8ac3ddbad4b8d8fd7ab1220330a29e5663e6b3", + "support_sha256": "708e7c9e83d7b53f28feeb77729116897abdeeb8a576b10fae2f88128637e92f" + }, + { + "index": 229, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "42c69aff8cfbcc5ce31bfdf1a1a6a623c7655ce8f0d0c451e0d193d41a4575db", + "support_sha256": "8fbcfc7af69a295730740b58b8e7ce6e642566d16390aaa6015849369f0b5695" + }, + { + "index": 230, + "required_count": 4, + "support_count": 18, + "height": 5, + "required_sha256": "46da46e544fe03845a2614c11636b1b7b361a4a2a5ec989fa9c07f4e87748ae0", + "support_sha256": "5a1118326d5f216eaa923452d192e2b2d5d66c8860af5c2e19b50e3605a84694" + }, + { + "index": 231, + "required_count": 4, + "support_count": 19, + "height": 5, + "required_sha256": "90998fcc5fe84883cabb8175e84bfaa46aeab0028c08ff3c179790d993d6aaf0", + "support_sha256": "da23320e49589e690b575c949e17fffecbd1b1a8c35c1fdc07d74b77dc7d65f3" + }, + { + "index": 232, + "required_count": 4, + "support_count": 17, + "height": 5, + "required_sha256": "acc57e38519a06f568622d2896fd6a06732c1fccce0d01b0cf02d99077648f09", + "support_sha256": "7564308f777d322969326ec8a1404ca98440d8adbc68cb008067ce63cc778cb9" + }, + { + "index": 233, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "7f61882400b290b433af28d38f811017ed9e84a3bced1b6435b44025ce1935df", + "support_sha256": "41ce480d5da089eedc1c6c7649dcfe076c8f25b82d5bf7abe4350210af6415e2" + }, + { + "index": 234, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "2a18624335da6fc47adf9abb6855fd921eeb2b52fd14bb6c0273e365886b0afc", + "support_sha256": "c93f2ce1b283ee95a06dabade1a203466f44c73d5032d9af228c9edae4186ce7" + }, + { + "index": 235, + "required_count": 6, + "support_count": 13, + "height": 4, + "required_sha256": "2a8f16ebdff308e4597c539b6034b2d5fbd0e09d9677f1f72c5a715fd23e0c3f", + "support_sha256": "7f797c1dd63cca5e16befcab82182613c8aebc11ea4805971162ae9d91a29c2c" + }, + { + "index": 236, + "required_count": 6, + "support_count": 13, + "height": 3, + "required_sha256": "2a8f16ebdff308e4597c539b6034b2d5fbd0e09d9677f1f72c5a715fd23e0c3f", + "support_sha256": "ae933944ef06118ae0fa466967f11b85e7fdeba4d9587663cb80518a8c17797c" + }, + { + "index": 237, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "c9a2986bd2f411618050c72eb62bca80c0deba010f498076c48c107cb6daaaec", + "support_sha256": "818a9b438a1092cb47cbdab8f27c532acd565cfe47c7658589c84a121ce025cd" + }, + { + "index": 238, + "required_count": 5, + "support_count": 16, + "height": 6, + "required_sha256": "86440170d400e2e3d5cf5405cba3ba81e41960d70c7eb7ad20492269ee80862b", + "support_sha256": "1c5e9dca34d649662586af806dcd701316ec67dc9b32d58b4cc4148bf9285bd1" + }, + { + "index": 239, + "required_count": 6, + "support_count": 13, + "height": 3, + "required_sha256": "ae1c64284714185479fb1de3709bc552de79e4453e3e0e3cb1eb725eeb2b28b0", + "support_sha256": "318d18aaffc0cdec22469b6d8e1702467abbcd4b4f293fe952f57c686b9828c7" + }, + { + "index": 240, + "required_count": 6, + "support_count": 13, + "height": 4, + "required_sha256": "891b213f629f4be2e95d3794506798365fd77b278fefe5c5741e9a009fd1013b", + "support_sha256": "0c7d25f4914fd84d444234884ddf267ab513ed15f7087879f33c988410a97623" + }, + { + "index": 241, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "b9c31e8006b9a34b7168c15ec8b17e17d86bff317d1a38543d8c1baa8918be84", + "support_sha256": "c93f2ce1b283ee95a06dabade1a203466f44c73d5032d9af228c9edae4186ce7" + }, + { + "index": 242, + "required_count": 6, + "support_count": 13, + "height": 4, + "required_sha256": "42f7b22cdb9f4b2e04bdf1200c8a185e51753e4e1f8bacfc1d76a4897a6ffb45", + "support_sha256": "183a57460bbd62d45244c902058153f32772aeef200dd0b6cfdab4fc4171c1f0" + }, + { + "index": 243, + "required_count": 6, + "support_count": 23, + "height": 5, + "required_sha256": "6204da1930b759f2c448dfb03cce07b3c0c65da20f6bb41c9cf03481d49fc2b3", + "support_sha256": "23bfec42f8442f0b141fccc0d095c2b8b92cf98b1706573a578fd6b6de0e6277" + }, + { + "index": 244, + "required_count": 7, + "support_count": 10, + "height": 2, + "required_sha256": "6a83c36a6a91525f9f0ac6360d615fba6852b5c1b64b91a979f7547dba741b4d", + "support_sha256": "e86b087e6b709b1cbd1594af0d408eecb183dd5bef0aeb2ce6b5688d64298158" + }, + { + "index": 245, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "1ff3da29b00531f3654fb6b68dfd50e4c73dc1f3d2903a50a7393b06425b8a82", + "support_sha256": "a3e49ae6850ab0d5f25e18bcd04b1fefa5146ff7efa146a9aa81cb114257c52a" + }, + { + "index": 246, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "2fcbd5625ea59c98fb12ac22c67fa886129f9c3943402732f96b7e3c87aa1834", + "support_sha256": "150836850168ba7aff1c2ebadbca296ce0f4afff9c5aa7189524e9a01740196a" + }, + { + "index": 247, + "required_count": 5, + "support_count": 12, + "height": 3, + "required_sha256": "2c68f546408754dcc00e736076653540e33ee55542d3c0df764392d10b4695f0", + "support_sha256": "50169052cc52a904ca1d0e5bde03012dae3b0ed485e8f0ff6b192ea05a8271b0" + }, + { + "index": 248, + "required_count": 3, + "support_count": 24, + "height": 6, + "required_sha256": "5d0fcfbc32b9c0f150ef10fa990084167b1b371147fcb276336e4b1725659905", + "support_sha256": "9bfb2237b30c59f5906ceff78dccd62971452f31e1a51316ce5b025d2adfb4b7" + }, + { + "index": 249, + "required_count": 5, + "support_count": 18, + "height": 5, + "required_sha256": "5555af87f769b0bfe3a8825784d896325fcf57561960291cf68ab128ef9f3820", + "support_sha256": "af15af4e621be4f890a0096c0127760942714e2b6f279b77cc1321e496d1f558" + }, + { + "index": 250, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "7cd8fba75998ec962d8e84d072652c5b46551b8a23e897ffbd005025d9af768c", + "support_sha256": "fa7c6e87c94c1ce11ac8623b190ba7ceb743c0a42591eb260eef7a7bf4245218" + }, + { + "index": 251, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "66c6311582c91f9dacd280d0c4ebd7f67f5d50dd3bb21d67e2ec1982684ea71b", + "support_sha256": "74c07fa9a221235b2e30556e513a3288edce8a09fd800e7a595e0c01c476941e" + }, + { + "index": 252, + "required_count": 6, + "support_count": 20, + "height": 5, + "required_sha256": "d7d78177686638d813891b28d67155c06ddfcaac135b26ac5dca9f9709552e4a", + "support_sha256": "d7343a9cc8c285ffc1c7a9cd247b2e3dc8bde2bb6f63c4d9eb450ac4781c21ae" + }, + { + "index": 253, + "required_count": 5, + "support_count": 23, + "height": 6, + "required_sha256": "0a91794244a429c712355b145750ebf26f6bfbf09e114476d40d14354ca318c9", + "support_sha256": "8d6ca2680044e291003a48cd4aec2de2b3129219945a9ed2c3a742d37f3d42c2" + }, + { + "index": 254, + "required_count": 4, + "support_count": 17, + "height": 5, + "required_sha256": "fb893e94dedd650f09ede96a30737b17bfc33e12475b34293897685535e18dab", + "support_sha256": "95725d7526c54973661f890e086b67c8ba0f19f600ff23d18aae5a8a6b25d455" + }, + { + "index": 255, + "required_count": 5, + "support_count": 20, + "height": 6, + "required_sha256": "bde67be3cf930954ade7a93612abed24421c69abf33647c184dcb6ae6241a0a5", + "support_sha256": "dc2ea915cd4218c69d7d11f0bc68fa2a6325e2dfcf7f027884ebf349a7970341" + }, + { + "index": 256, + "required_count": 4, + "support_count": 21, + "height": 7, + "required_sha256": "d44500532a29af7be6fccb33d49559834fe0a107e0a52f116936dd28b0a1e129", + "support_sha256": "44a77de9cce5fac657ab454597c6fced4744c54d439254486c45763c5a82ad4d" + }, + { + "index": 257, + "required_count": 3, + "support_count": 27, + "height": 8, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "93279ed1638db9c9c854e245e86bf3078e3884463565b916f304678cf0036df4" + }, + { + "index": 258, + "required_count": 3, + "support_count": 30, + "height": 8, + "required_sha256": "8c65f188fd55edb653c6e5e1a232b5aa05690945ab4950a6920b0dc34f69cdd6", + "support_sha256": "69a77544bf6d800a69684a8008c98b58d74c1be257953b2e7e05987da372c2f1" + }, + { + "index": 259, + "required_count": 5, + "support_count": 16, + "height": 4, + "required_sha256": "795e43e935a27500b71d38ffb7e186b1ed4667e13f4f03698dd9f15df98d2cd4", + "support_sha256": "e1609e516fe647842cab98456f70b25da1412df3fd8269e0a5c27748bae74a73" + }, + { + "index": 260, + "required_count": 8, + "support_count": 17, + "height": 5, + "required_sha256": "fba5b944409eb91dc8b26a1f2085293a9a6edcadf5508815ee6c5aa647f3fd93", + "support_sha256": "630a3d0bef180f0a10d86349e2ed7554d69a95481688f363b2d857a4d6049cef" + }, + { + "index": 261, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "dc3219a2b207a74881e46b68d8d73a51be175f1cc8de5b0c2b86aa1d25ea76b0", + "support_sha256": "a0d1a75d3a9a271de7c2e41f51428d9f229d5d695f175045ab06743edb9c6014" + }, + { + "index": 262, + "required_count": 5, + "support_count": 12, + "height": 3, + "required_sha256": "44b4c5222857437543bcefd359728be3bb1d5c15facb617a449e4f1afe4c4d00", + "support_sha256": "08c3eeafecb0025e8b205097c7997336924b829ae2cb1211563cb00e34ee3cab" + }, + { + "index": 263, + "required_count": 5, + "support_count": 17, + "height": 4, + "required_sha256": "7ec9e15e4121bf998747a247603ab19c50adfcfe924b87638630be5cfe081c41", + "support_sha256": "766c8ad15ae9d2d023f42f07b7eb21cdf9bbf5d199fba6385b4b9f6764cdd776" + }, + { + "index": 264, + "required_count": 5, + "support_count": 18, + "height": 4, + "required_sha256": "acbf23c9df2fc088690447b270cf23b137f4388d221b0a38c3529c8c4b622a6d", + "support_sha256": "af75997fb4d39cd7baa75a1405260f28873824e608c3be9554db53d6651944cd" + }, + { + "index": 265, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "c5dcf5fe4ba999dfe72029b2ddf121510891fe48b48d762149a0c0233e6660ed", + "support_sha256": "f7a11261f24502f9a0a987e3fbae5ab26dddf20d118ecd462aca1860c8b32164" + }, + { + "index": 266, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "776b78606aa3a298fc238b2cf40260dea6c01b251f07cc100075bf7cb14744a7", + "support_sha256": "ec58963638559b9ab4164c7acd69000e30c997fa709ba7b6d15b5dfda8b91088" + }, + { + "index": 267, + "required_count": 4, + "support_count": 20, + "height": 6, + "required_sha256": "2011bd190c4c6f0361c80297e606eaddd2d49e00673617dcb9c04cc6bac9092b", + "support_sha256": "54651ddc6ec536552be7d59e8026d56f3fd8208940c1b234765bcde3604155ec" + }, + { + "index": 268, + "required_count": 3, + "support_count": 17, + "height": 4, + "required_sha256": "f078e5b63a09fa90b13c4183f6b28855317d0b8439c9414346dada6b8a46f94a", + "support_sha256": "945f17cfc4e5b49d85ab4dfa14c749ef7c024f0562bf5d1e01ae3cd9bfc6283d" + }, + { + "index": 269, + "required_count": 4, + "support_count": 17, + "height": 4, + "required_sha256": "fb893e94dedd650f09ede96a30737b17bfc33e12475b34293897685535e18dab", + "support_sha256": "fccf503388c12712628ea32a412baad33b83acb22ded979cc52dbaf18a668ba8" + }, + { + "index": 270, + "required_count": 4, + "support_count": 23, + "height": 6, + "required_sha256": "0a99937381cffcfbcea755205c1aa895649cb585320da42abc8d1680acbfd390", + "support_sha256": "8d1c68fc937a56eea1026e20714719556b51cc201e47964386853aaa46ecc24d" + }, + { + "index": 271, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "7ec9e15e4121bf998747a247603ab19c50adfcfe924b87638630be5cfe081c41", + "support_sha256": "c6787565b247ffc8afb608e400ce7ef5becf8a8e02c95d60c6bcf712f438afc4" + }, + { + "index": 272, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "36672839eaf0fe0bc0a640f23371eb84ed1fc07ab5947cd342c3d92f8b928a7e", + "support_sha256": "9df6fcd24274b38c32ee8242097974cb664825bc412dd22339442528d6515a11" + }, + { + "index": 273, + "required_count": 6, + "support_count": 17, + "height": 5, + "required_sha256": "25ddab9e2b0fb8fb1a3d9650a69c677fb0fab988e41cda6c7bf2394ebe145d19", + "support_sha256": "af2084dbe375978f8dc99d65cbb0c21b71db4d021f284a6aefc1e196cc0d279b" + }, + { + "index": 274, + "required_count": 4, + "support_count": 22, + "height": 5, + "required_sha256": "4d2dcad8a53c64938c36d83ad5d3e9d32d4e24a2a6ded328f4fd0eea258bdca3", + "support_sha256": "2a97e9aed72d4e02bc61aa0941975ec8d6d3928b1752dd3ce68eb44e8c007578" + }, + { + "index": 275, + "required_count": 4, + "support_count": 18, + "height": 6, + "required_sha256": "d8a9a68b4c07caa72ee0a278a71d78f924646475ad632ec15106b2f23b2479f8", + "support_sha256": "bea89d59d27775c747744717f56039af66b1cbd738125bbcb03e62a986391c92" + }, + { + "index": 276, + "required_count": 3, + "support_count": 28, + "height": 7, + "required_sha256": "17ace6cbce82efedddd90b3e1d3e31c87e5045e72b6c6bd10277bf9eeb09c01e", + "support_sha256": "32ae8aeb243585f73591aadbea13ba763a8bfe6c9e2973d3b83ae4b7b4aa8322" + }, + { + "index": 277, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "ad1ab29be15aef760e8fb2fb62c0276dbf617247f76610dffa3a37bb5a4b5f14", + "support_sha256": "08c3eeafecb0025e8b205097c7997336924b829ae2cb1211563cb00e34ee3cab" + }, + { + "index": 278, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "d99efb44a5abcec826925e2fed0465cc2b4555fb41dd0dbb29ba16fffd3c5fbf", + "support_sha256": "ed8ce8c4b38051ee0fff7de05304071cb06d384113ea6761e0623612625d406f" + }, + { + "index": 279, + "required_count": 5, + "support_count": 17, + "height": 5, + "required_sha256": "0a91794244a429c712355b145750ebf26f6bfbf09e114476d40d14354ca318c9", + "support_sha256": "5a19675415d8eb7325801a5d9931412d1470cbe9495e121cb546edd0f64a84a4" + }, + { + "index": 280, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "3988bcd1b55137a3ed92b6f0b280dd40bfdeea0d7be7793dc677720dcb981f4e", + "support_sha256": "895db45c0a05b7d81ca98c7c30ce5ff7df2691c3150b3f6aa97e337a3e17b0c5" + }, + { + "index": 281, + "required_count": 7, + "support_count": 10, + "height": 2, + "required_sha256": "fcf3bcd9405a9ec027d8201f852d99a15b1aa759880183797d2b2fbe748b55d9", + "support_sha256": "d8c2da969a2be4598f638000769a2236f69a1a1f52e31d74879274211a3b9699" + }, + { + "index": 282, + "required_count": 5, + "support_count": 17, + "height": 5, + "required_sha256": "5373d544e973f91046abdba8bf6f806a3ed6c6f2932d524ee193744c1891055f", + "support_sha256": "e5f2c0afd7a18e952609fa812f37e181658b43f0e2d108c9ef2cea75d577b8e9" + }, + { + "index": 283, + "required_count": 5, + "support_count": 19, + "height": 6, + "required_sha256": "6cec7e9576e8cfec0c7c2d4af1aa66b26f3b22df571f6797a654158a48bc2336", + "support_sha256": "f9bc69dc357bd8b7a186218d6076d99630dedb74a9e517f570ecb82584a77c75" + }, + { + "index": 284, + "required_count": 4, + "support_count": 23, + "height": 6, + "required_sha256": "f66aab8ebb551647eb8001b398e4fd4a28d17a5ac7fedf58575b47a16e8a0e7e", + "support_sha256": "6ca6e36ff4f5014eb303afac32be1fdd677ab6cde1189071dc104f1e4e448642" + }, + { + "index": 285, + "required_count": 4, + "support_count": 30, + "height": 8, + "required_sha256": "d44500532a29af7be6fccb33d49559834fe0a107e0a52f116936dd28b0a1e129", + "support_sha256": "f7ce87e2d5b59cd1d0b6c17164745a9d83c4a0dbdeafe5d04919c42f876080f4" + }, + { + "index": 286, + "required_count": 5, + "support_count": 27, + "height": 7, + "required_sha256": "5555af87f769b0bfe3a8825784d896325fcf57561960291cf68ab128ef9f3820", + "support_sha256": "bc9c947b2af18bf65128af488e11b60763a1779e51a1ef337e1ac0c6975faca3" + }, + { + "index": 287, + "required_count": 7, + "support_count": 25, + "height": 6, + "required_sha256": "e6b6a13ce6be4e9404bb5c6c3763942a3dfbe81245eb607c684708af9505ce81", + "support_sha256": "c9ab86d710e65b6bcd9719b136657770951d063d253cb1761e92c58e41eace9f" + }, + { + "index": 288, + "required_count": 7, + "support_count": 16, + "height": 4, + "required_sha256": "298b3d3069e1fa5181341e807f98adde00b569aee02f9a08a1780c13b201ef9c", + "support_sha256": "51341a1b6cca5d350b5d4ac4d26cf5d414971320f9c545ccf32766128c260acd" + }, + { + "index": 289, + "required_count": 6, + "support_count": 13, + "height": 4, + "required_sha256": "7761ebe5bc32536e31c6c8a7e0fdbe78d68456e234db636540dbfaa00f340159", + "support_sha256": "bd36773b17de3ce6f233a0ce2c5fad61ea15dfe6abb3d5f1dcdddb6fd73f36a8" + }, + { + "index": 290, + "required_count": 6, + "support_count": 19, + "height": 7, + "required_sha256": "6af0ec91844e43ccc8245e311b80b73b580e6d3536be14243f8ac629346d4874", + "support_sha256": "9258ac47b9a84d513f30da40dafa1b65b19160ab02179fa71c3440e932fb6e8b" + }, + { + "index": 291, + "required_count": 5, + "support_count": 16, + "height": 4, + "required_sha256": "7ec9e15e4121bf998747a247603ab19c50adfcfe924b87638630be5cfe081c41", + "support_sha256": "296457448cc82533d4caef0c9c8a2cdb4794ff865a8cbe88d0ea22c30b86a337" + }, + { + "index": 292, + "required_count": 4, + "support_count": 24, + "height": 6, + "required_sha256": "d44500532a29af7be6fccb33d49559834fe0a107e0a52f116936dd28b0a1e129", + "support_sha256": "f2672458495ab1a5bc67cd66d9f24d885485c8b3d62365af39e17b67f5f4b963" + }, + { + "index": 293, + "required_count": 4, + "support_count": 21, + "height": 5, + "required_sha256": "90998fcc5fe84883cabb8175e84bfaa46aeab0028c08ff3c179790d993d6aaf0", + "support_sha256": "175ed2017081306b00c10f17aaced4b7ab30f7817b7ca48e346daacf5ec24b43" + }, + { + "index": 294, + "required_count": 4, + "support_count": 22, + "height": 5, + "required_sha256": "d53b755390ea914b6c1fe2954550bdec4325dc8c0b4659b54bdc71b7c7b26cfd", + "support_sha256": "7eba5557ecf6d0b089ba319e621afe4811120f8c9441a3da49e338f384a4bde4" + }, + { + "index": 295, + "required_count": 5, + "support_count": 23, + "height": 7, + "required_sha256": "5062fb0335e8bd142d71269fb1f1763fee5abbd81915bb4c01d7935eff4b4691", + "support_sha256": "bf84608d0dea0323d72d113d6d95234096e581d7c84140da531b54e3cccb4edd" + }, + { + "index": 296, + "required_count": 6, + "support_count": 15, + "height": 5, + "required_sha256": "61f858520ad38e7d8504b1bf0fdfa243582828693c0053778a24cabd1c964e09", + "support_sha256": "048f42f6c331c9e7c9dee49f2f6be13853c6a733b4b17bba9a4056b60db85b0a" + }, + { + "index": 297, + "required_count": 3, + "support_count": 24, + "height": 7, + "required_sha256": "90d6958def63879298dde9490fac2a435e8851c90daf3e0e9a067b3173fbfc15", + "support_sha256": "f286feebcf68b49428f2e24cae7b84e93439078ec871e031832910e05120d37d" + }, + { + "index": 298, + "required_count": 3, + "support_count": 24, + "height": 7, + "required_sha256": "90d6958def63879298dde9490fac2a435e8851c90daf3e0e9a067b3173fbfc15", + "support_sha256": "c00a3644da76f238579be0dc33280f1f16cc04a35b42f0f6e95170e2ff8475c1" + }, + { + "index": 299, + "required_count": 4, + "support_count": 30, + "height": 5, + "required_sha256": "f878d0e8ab29445aa0de382bc82fe4fac76c301d363da189d71d6ad5a8d34d3c", + "support_sha256": "75f2e708643dda3da91acc69fe5dba0623c421c2e39e608a7224439b2a23ebcd" + }, + { + "index": 300, + "required_count": 3, + "support_count": 24, + "height": 6, + "required_sha256": "5d0fcfbc32b9c0f150ef10fa990084167b1b371147fcb276336e4b1725659905", + "support_sha256": "852644a8ff637615688b9253d3f31dc49604d665387c077da1bfae4136558427" + }, + { + "index": 301, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "31542ca457eedbed1035f023e6b8c70c528dd209cd64007d47221591d8b867d6", + "support_sha256": "17c9565745f5f7eb8ce5bfae4e9a7fd74e08312a236d32a49452d4f3a7f3dc2f" + }, + { + "index": 302, + "required_count": 4, + "support_count": 20, + "height": 6, + "required_sha256": "6b1e67f4b3e546a8f5c2b95c007a8baca46653df8da739b11c5f44d5d0621097", + "support_sha256": "962c61f781d170808c49de97e115c78815436bdb3eb80be5a7a6f4457dec3bf6" + }, + { + "index": 303, + "required_count": 4, + "support_count": 21, + "height": 6, + "required_sha256": "6b1e67f4b3e546a8f5c2b95c007a8baca46653df8da739b11c5f44d5d0621097", + "support_sha256": "e374346d6aca90419a4a42e17f31e4e018e311a5d83aa063568bdc5f5e785aac" + }, + { + "index": 304, + "required_count": 3, + "support_count": 17, + "height": 4, + "required_sha256": "f078e5b63a09fa90b13c4183f6b28855317d0b8439c9414346dada6b8a46f94a", + "support_sha256": "e9428ef8fff3f84f58bad5030b799465eb240306be1b2c58413bd6b384724874" + }, + { + "index": 305, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "48acd887eb62520d2e46ebea5bb6cf117f584a382637e9ce1f624ec980e14cb4", + "support_sha256": "57e405766d4c524367f5b3d6d2b88e30be71b2aebe80ccae9923ec41ec11be65" + }, + { + "index": 306, + "required_count": 5, + "support_count": 20, + "height": 5, + "required_sha256": "39e4bc2cbc9a074926a1e2f5cdad9ce11dad8eac58f7090c5636ad2caa407026", + "support_sha256": "462bc3a5b481af504b6298535d7cbd2862e8f161389365664d99f6ad637208e1" + }, + { + "index": 307, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "c9a2986bd2f411618050c72eb62bca80c0deba010f498076c48c107cb6daaaec", + "support_sha256": "08c3eeafecb0025e8b205097c7997336924b829ae2cb1211563cb00e34ee3cab" + }, + { + "index": 308, + "required_count": 4, + "support_count": 20, + "height": 5, + "required_sha256": "0877a115cc5954b9d722c9e2e73287e03b8b7cff19d4b1f58685db0947c899e4", + "support_sha256": "8ce4cae94351695a0d476044335294968413a23e83ebdd39126e9d42c34de0ce" + }, + { + "index": 309, + "required_count": 3, + "support_count": 29, + "height": 7, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "1739d58ec99cd331c160751c054d4dd9617356d136f7c1e5aba5bc4f0e3942b1" + }, + { + "index": 310, + "required_count": 5, + "support_count": 10, + "height": 3, + "required_sha256": "ca2a0ac0f074d01419478f017a4f67fa3af395c1027f517b1f893570d0066eae", + "support_sha256": "b9addde846672ee175d18b61b6c4253a19017c0d1faddeb56e2928f2c638e13a" + }, + { + "index": 311, + "required_count": 4, + "support_count": 11, + "height": 4, + "required_sha256": "687d8b9c619ae50d253e96e547f85040fc39ffa233ce9406ecd6a7f3fee48683", + "support_sha256": "0a6babc5f77ff61ca455b0a2b7571c962d1731a2ecf47484a0af21f053d65356" + }, + { + "index": 312, + "required_count": 6, + "support_count": 15, + "height": 5, + "required_sha256": "c12468b5920d3b3ed73214908c445754a483c61e39c36722b47b6775ce15ce4f", + "support_sha256": "8d28bdc4d26970a2987104e845bf9cabe171834633de0dc271b65e240f9f29a8" + }, + { + "index": 313, + "required_count": 5, + "support_count": 16, + "height": 6, + "required_sha256": "938ebd912f6e8abdbc061d428c1ee46758a52fad54a155c6b34a15bb09332603", + "support_sha256": "71e4eca7cbabd1a87df937088759caf8b990d4cd3eb32de32677de3fd492e1db" + }, + { + "index": 314, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "7f61882400b290b433af28d38f811017ed9e84a3bced1b6435b44025ce1935df", + "support_sha256": "05d041877fe41cd3f362fd049c74fb0ec892d64099c1693ffe4e4e75b14fe422" + }, + { + "index": 315, + "required_count": 5, + "support_count": 18, + "height": 6, + "required_sha256": "773eec64d276bbb5272b2578975d8b8b9da4f6013d7441cfee7dfca5ed4b382e", + "support_sha256": "f6e3c28fbf9a393f41092504642bb11f34583d2a4b31bc9397dee6d2f44db293" + }, + { + "index": 316, + "required_count": 4, + "support_count": 23, + "height": 6, + "required_sha256": "5695012690546d4e929eb27640a33e544d4b9f976434e7b357d2051e6ce556c6", + "support_sha256": "6ca6e36ff4f5014eb303afac32be1fdd677ab6cde1189071dc104f1e4e448642" + }, + { + "index": 317, + "required_count": 4, + "support_count": 28, + "height": 7, + "required_sha256": "fa02882fbd515e8af02a84707b5b843e833b152580eb1492f5cabeb004f6b829", + "support_sha256": "703f8c14550603f617ffdf9e3139b2c94f9bab9dbbf7f8e2da4a86dbc730d609" + }, + { + "index": 318, + "required_count": 4, + "support_count": 25, + "height": 7, + "required_sha256": "ccbbf19d4bba292bc26f99117b03cd91e0255d537869347dbb67bcd1e85e7432", + "support_sha256": "311a581cfd1d651f7119c3d1891843d2b9127d84ee35f3286e7fa1c6f8ddb39b" + }, + { + "index": 319, + "required_count": 4, + "support_count": 31, + "height": 8, + "required_sha256": "4f5084d49903939ad2776aa766a7b716ad217f32e6636b5a14419472f39b1412", + "support_sha256": "c7200eafe0569668bf9775a671bd5bff5e7fe72138528f1ceaaa5a10b5eb98c2" + }, + { + "index": 320, + "required_count": 5, + "support_count": 26, + "height": 7, + "required_sha256": "87e1bc398eae39ed79264259b444b55fd9c39402f18e46eb79460895fa96b4f2", + "support_sha256": "7769aa27814d7014cc7b02e727a9a4d756c753ddb42a9d248c39c87f8bdcdb48" + }, + { + "index": 321, + "required_count": 4, + "support_count": 27, + "height": 8, + "required_sha256": "32261c2c5d5b69372de88d2a521e16669142eb2032aae80e520d5f1296091c9f", + "support_sha256": "42a7719fba4df6a547315928a864870b50a954141e73fb7db21cd83ab0e9c762" + }, + { + "index": 322, + "required_count": 3, + "support_count": 33, + "height": 9, + "required_sha256": "06c7eb7c54b5dbc9eebe7161e1cfa73c8188aab37577aabff0270362dffe0530", + "support_sha256": "5de8425a980d90829cb76a06f2d73f1a9fa4f4b7655e33aac8b21a1663a171ea" + }, + { + "index": 323, + "required_count": 5, + "support_count": 30, + "height": 8, + "required_sha256": "af05a36840bf81a5221c0fc76f65715103d636a62985b1a246fd78a34d7b344c", + "support_sha256": "7a90b11d3c7369f44f8dd3dab8c218ebdd6dffe0b962936318d87b58c853e3ee" + }, + { + "index": 324, + "required_count": 4, + "support_count": 27, + "height": 7, + "required_sha256": "66e46ca2a7e10c08c93fb6cd5bc54da43968c1c3bae50f82a1df6f78915ac41e", + "support_sha256": "178b7fef02282c64a56cb20bb0bb749ecfb5254c3b409d679905b8669d25e185" + }, + { + "index": 325, + "required_count": 4, + "support_count": 29, + "height": 9, + "required_sha256": "9734a2ca926095da986a8f758be44dce707675e265dee5139deec1f655f4b515", + "support_sha256": "921398ffab61fb3c09dda3a04c7c8442b983b323c5cf2530c987b4b2f89976a3" + }, + { + "index": 326, + "required_count": 5, + "support_count": 30, + "height": 9, + "required_sha256": "07e7243a106053fb9886d619cbfa2c765ee884da009e0ee77c4e4e74b7013861", + "support_sha256": "2262bd379585590d27e9cda9baecc039e8850cce75f2a8d7ce626f6198c727f1" + }, + { + "index": 327, + "required_count": 5, + "support_count": 32, + "height": 9, + "required_sha256": "05fc7d09897160bdec11959a6763815f9f6f9419d7b7e755044319a500dd8620", + "support_sha256": "c252effbafc8c992385b0c88d1a1eace8821d2a21e42d0fd7726ccda8eefc207" + }, + { + "index": 328, + "required_count": 3, + "support_count": 33, + "height": 9, + "required_sha256": "391b1a6dc0fdb0b98a425dc75381d850ff663953e972a41648d50ad0d091375d", + "support_sha256": "9c4011d935c16bebf8250d42498f1131a51c9a0c290555ba63b6b51720054010" + }, + { + "index": 329, + "required_count": 4, + "support_count": 25, + "height": 7, + "required_sha256": "28b38860972421fd8f7b22f750256999212f6b21ca47f5097c26eb69c3f95c80", + "support_sha256": "311a581cfd1d651f7119c3d1891843d2b9127d84ee35f3286e7fa1c6f8ddb39b" + }, + { + "index": 330, + "required_count": 3, + "support_count": 33, + "height": 9, + "required_sha256": "391b1a6dc0fdb0b98a425dc75381d850ff663953e972a41648d50ad0d091375d", + "support_sha256": "5de8425a980d90829cb76a06f2d73f1a9fa4f4b7655e33aac8b21a1663a171ea" + }, + { + "index": 331, + "required_count": 5, + "support_count": 20, + "height": 6, + "required_sha256": "da3039980bb1ac322a8ccc263bff54879085133728f816278fc1afea23c3b5a2", + "support_sha256": "632891f304392b2606821ab63e11c689ff8636c43c2636f9baea238cb9165407" + }, + { + "index": 332, + "required_count": 4, + "support_count": 24, + "height": 7, + "required_sha256": "9cc34ecb5f7b3c93c341bf32d6366373193a470ad293bb87bc5164e9c9589eb0", + "support_sha256": "b29f1632e0009fb7d612ef5ef4dd276c39128aaf3a7c93901ac63ec83ae146b9" + }, + { + "index": 333, + "required_count": 4, + "support_count": 9, + "height": 3, + "required_sha256": "94c0058de5508940134f920def48d09131a4ab8358904e7a9b4f9f3551dd16b0", + "support_sha256": "a0d1a75d3a9a271de7c2e41f51428d9f229d5d695f175045ab06743edb9c6014" + }, + { + "index": 334, + "required_count": 3, + "support_count": 12, + "height": 4, + "required_sha256": "71c99eaf413b8f4178dae31f5d3593eff9fc40534749cffd18d6d7c037872acc", + "support_sha256": "86d35e9f833bf20e70f45f22883707f8574c8bd82f1c95752774a2f38bf160bc" + }, + { + "index": 335, + "required_count": 4, + "support_count": 18, + "height": 5, + "required_sha256": "12ad42d5cef0d1e8f4c6f055f6f1001b7d516551a035fb97611abc9d79e4e352", + "support_sha256": "3937de31965f4d5ef0179f188cf63214bdc42ce49bfe6ceccffc594ea7909d44" + }, + { + "index": 336, + "required_count": 5, + "support_count": 18, + "height": 6, + "required_sha256": "2e1135d2ac657c474d917b5edeb5c451ecb4aea29fa3c71100a6d09b122289c8", + "support_sha256": "cb7c2c595a17037cc6e03f27e8b1ac0eeda04f906a75cc9bb5912271f54273c4" + }, + { + "index": 337, + "required_count": 4, + "support_count": 24, + "height": 7, + "required_sha256": "213bba76d5e7f4a882164bbc4fffbf811239b9c22a41dca28efd2b59b1bd0924", + "support_sha256": "1e49bd8d7430dbfe6b5d956727f6f5f9b74433e158b1ad11fb888443b2b19f81" + }, + { + "index": 338, + "required_count": 3, + "support_count": 30, + "height": 8, + "required_sha256": "17ace6cbce82efedddd90b3e1d3e31c87e5045e72b6c6bd10277bf9eeb09c01e", + "support_sha256": "4860a9cf0abafe69c1108fe3f4f6d806c2cc75797977afc16524c1884632ee58" + }, + { + "index": 339, + "required_count": 5, + "support_count": 22, + "height": 7, + "required_sha256": "5555af87f769b0bfe3a8825784d896325fcf57561960291cf68ab128ef9f3820", + "support_sha256": "de0e52526a1b942f19b70d1e18a919525a8d798ba1f750ccbd220a4af45ac484" + }, + { + "index": 340, + "required_count": 5, + "support_count": 21, + "height": 6, + "required_sha256": "cac38c641a868578b6de1e2f97d16e9ca66ffbf4da4d19ccd4f2563f050eda77", + "support_sha256": "396d9bfd96eee1ddbea294f1b4e971e10bd7724d907d593a8023f5fc496125d6" + }, + { + "index": 341, + "required_count": 4, + "support_count": 28, + "height": 7, + "required_sha256": "13624a37222ec9c47fd2934294dee20f8e0f4e7537f53895c05b3178cdb771b8", + "support_sha256": "e602cafb1778b5bdc2b294b3f894f3cbafe7effeef145e42d6bb6ed45351b462" + }, + { + "index": 342, + "required_count": 7, + "support_count": 18, + "height": 5, + "required_sha256": "20a8cff8ea1fffd2d94950cc1fd71fc35ebc0f5ed6f6a5d0a299d293a704e487", + "support_sha256": "8b68ecbddc73ee028166b1c6dc9a7f7d42105c1cf9a3ce55cde5da9905c2ada7" + }, + { + "index": 343, + "required_count": 6, + "support_count": 19, + "height": 6, + "required_sha256": "0931f547231c2ad51c0ec789fcee8b746f7e045d2f2e6fa1d3df52ce0ae5801e", + "support_sha256": "0381a0018fb5aff08d865c796682001ca117864777428362effb30a39723b760" + }, + { + "index": 344, + "required_count": 5, + "support_count": 20, + "height": 7, + "required_sha256": "ad1ab29be15aef760e8fb2fb62c0276dbf617247f76610dffa3a37bb5a4b5f14", + "support_sha256": "7b66eafcdecbbe6115053bfe5af30c7d8aa8e9d75b13aead3db829278d3ea489" + }, + { + "index": 345, + "required_count": 4, + "support_count": 23, + "height": 8, + "required_sha256": "546363565cce2e7634244b94cd5ab900de698d0a535022770cee06dbffa541c8", + "support_sha256": "7a208b4a9dddee2a36cd37af54fc224efd791d7a2238793a33d3578c46e51d14" + }, + { + "index": 346, + "required_count": 6, + "support_count": 19, + "height": 6, + "required_sha256": "08b4d08c2949b3a981fe00a8a20da8932435c208c7bf9e0ab913fbc268213917", + "support_sha256": "3c61f5cebeaf48ee6f5f5104026cd7873c64d258cc22550956aef38a456ad836" + }, + { + "index": 347, + "required_count": 6, + "support_count": 18, + "height": 5, + "required_sha256": "c23a02156737ff0ab86803b8fa4db5053002c86ed63643bc6f343635aea66106", + "support_sha256": "f489164d56f759fb93aef804205ec4ce7515c3c1d002d1585e84b05195904747" + }, + { + "index": 348, + "required_count": 5, + "support_count": 16, + "height": 6, + "required_sha256": "98446bbb6b729d85e7eb6d4e1880891b4d37a57651b830a783aa4fc8c1b45afa", + "support_sha256": "71e4eca7cbabd1a87df937088759caf8b990d4cd3eb32de32677de3fd492e1db" + }, + { + "index": 349, + "required_count": 3, + "support_count": 26, + "height": 6, + "required_sha256": "27b5a821cdf3002871c0d8a44094865ae8b246decb8ecf1d4e786a121be899b9", + "support_sha256": "fc753c266a82d78aaaa6b65c227628429f61731be423474d15d5fdd4958cf441" + }, + { + "index": 350, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "0247ac96ec59a20d33d54ea1108d123d05c067d285f5189a38c74fba11ec31e7", + "support_sha256": "bcd891c837c8b03c0ac2ea4a8688807cbb84e1698f8f2cb4fd0066e4b6b99f02" + }, + { + "index": 351, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "36ad0d194819c8efad827d3bb078afae6148db24eeedeec883a818d37814d827", + "support_sha256": "28b7a31a06b3e22a246b3eafa7f18bfe8eaad09ac0751fccf02dc3f94b3a027c" + }, + { + "index": 352, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "7e1d836ffe515c5758ae7ce52e62ab83184d49417adb5667a0ca04ec338f2516", + "support_sha256": "ec42cf21cf6adddc058503159a2ccaee02b974dbb98a273171e2f0c465fcc101" + }, + { + "index": 353, + "required_count": 6, + "support_count": 37, + "height": 7, + "required_sha256": "b1b737a3b289285127d34a9cbf9f9a9e1179a7e26bb639a80e15b83022d8cd65", + "support_sha256": "4d2ecf00bb5d23d6a6bc8c169315efbea83cc11b7f20e65d2fe0f77272668573" + }, + { + "index": 354, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "938ebd912f6e8abdbc061d428c1ee46758a52fad54a155c6b34a15bb09332603", + "support_sha256": "21157aafd92b163b4cda0ba0da868e71fbe15a3d36d3de2083010030ea0726a3" + }, + { + "index": 355, + "required_count": 4, + "support_count": 19, + "height": 5, + "required_sha256": "f00308d4e08f3d621cb9495151876dd990aea563c71751042ca583edef524b8d", + "support_sha256": "b03bd991778ca9b9f32e28048422af96ae858ef5257648e129f10783c2ecbbc5" + }, + { + "index": 356, + "required_count": 4, + "support_count": 20, + "height": 5, + "required_sha256": "809643687c909c31d9f4e2b31d3c6908669c54b9798341456e92dd451c21b45a", + "support_sha256": "324c3f2edd2703f707253ed5a99dd28c454da962bd7c8ccb988b7ac3f16b51dc" + }, + { + "index": 357, + "required_count": 7, + "support_count": 16, + "height": 5, + "required_sha256": "d00e88c013b120f9cb7181e3094afa5e9d978163a99d3111e84ce5bc78787291", + "support_sha256": "2da77d18394a7f8c676df76137162d8b90bfffbb75527eb530efcafa8d38cebd" + }, + { + "index": 358, + "required_count": 8, + "support_count": 19, + "height": 6, + "required_sha256": "b5e1cfa453656f48a9872fa8c9ce304f66b5778033eeca4fdaf1bf84e730eedd", + "support_sha256": "8075599d5693c99e02e0dc84ea81ddbd582ec0e4cb45e1e52b5c97523cc7b60a" + }, + { + "index": 359, + "required_count": 4, + "support_count": 20, + "height": 5, + "required_sha256": "28b38860972421fd8f7b22f750256999212f6b21ca47f5097c26eb69c3f95c80", + "support_sha256": "d39773e89385972b4c5dbc3b79f9ca65a6fc3635039fe99a124a432b8eb6de50" + }, + { + "index": 360, + "required_count": 5, + "support_count": 21, + "height": 6, + "required_sha256": "9b72f2f4d16d3c283cdb66e05bbb3c158eb2545d832adcd95d0898517bcb3523", + "support_sha256": "90da3214e40f2cfc8b4e5e02d08f3c6307ebf8c93b7441c3093d6a20412abed6" + }, + { + "index": 361, + "required_count": 4, + "support_count": 23, + "height": 7, + "required_sha256": "5b567e73c2d9613dd04b04299c8f49e393c2b829174b64b7b8b712cedbbfd292", + "support_sha256": "67df35f7ab384eb71c05088b2b0c5c39bb85fbfdf5cfe1ccf016c5c3f2cb3231" + }, + { + "index": 362, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "c3f718a2b1e7d2e9a45f733779362c0ca58bf7d0e38690839a49df6588db7734", + "support_sha256": "b2fb990a7731031630064b7d45d48e61b51105031a0cc164a93a4db73059d522" + }, + { + "index": 363, + "required_count": 5, + "support_count": 20, + "height": 6, + "required_sha256": "27de664e89dc537da8811fc090e663633daa95b42a4618a907a59d616030f6cc", + "support_sha256": "c6900841968546c44af6edaf2a3f825dfa87cd550561d8aa2b329a52dff2285f" + }, + { + "index": 364, + "required_count": 5, + "support_count": 20, + "height": 6, + "required_sha256": "27de664e89dc537da8811fc090e663633daa95b42a4618a907a59d616030f6cc", + "support_sha256": "ba8a55eb8621ae0b24fbd77188c7da111854bdbeffb7adf49403e031e0a70226" + }, + { + "index": 365, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "198bc0d017873e88af640ab34297a2e9fd05b0c12521fe4a114980652daddf4b", + "support_sha256": "3f51c9bbe3f70661cdd2fce22430c1c0b94a3b02f5fa3e0cbcb6109937773a14" + }, + { + "index": 366, + "required_count": 4, + "support_count": 17, + "height": 5, + "required_sha256": "56e80ede3fdee4020d104828bf6ed5dd7ee45c1b76df68f3fbb45672a1a2ab94", + "support_sha256": "9591d3b99f9fb002fe33dd11fb195b4540275bf10636b47437affcc5c5c2800a" + }, + { + "index": 367, + "required_count": 3, + "support_count": 20, + "height": 6, + "required_sha256": "e449fdee4a3226a9777d4125c4018215b7991f8bbe8536671a81beadaba5e6f1", + "support_sha256": "63fe4fd74986f386220fc8ca7d3730b48fc40b79b5fe3c507bd742f99044c6b1" + }, + { + "index": 368, + "required_count": 3, + "support_count": 39, + "height": 9, + "required_sha256": "9b599caae7a4884a7dd9255285f1fe8237963a342b813d40fc12a0471107c87a", + "support_sha256": "89781195ff23c39c1f3404b3888e5f80e231f29e0af183ca15d3d670fb1e89fe" + }, + { + "index": 369, + "required_count": 3, + "support_count": 22, + "height": 6, + "required_sha256": "3cc9e0e55748a1613d99ae212d2c976dadada4d9aaf010e767c45826fd6cfcc2", + "support_sha256": "07b0ea591269d52ebddb49fc3fc8cddbab5cda5bdf7ab19e9d8a072a14cb55c5" + }, + { + "index": 370, + "required_count": 5, + "support_count": 18, + "height": 5, + "required_sha256": "da2cc00204e39e10bd9ebb5a005c0942cc0155ccf9b342ed64dc8f0150cb9d9b", + "support_sha256": "4b02b2ff30960140c2fa107d536bc745687300d48d4fa13fc66ca83d588b97a4" + }, + { + "index": 371, + "required_count": 5, + "support_count": 20, + "height": 6, + "required_sha256": "938ebd912f6e8abdbc061d428c1ee46758a52fad54a155c6b34a15bb09332603", + "support_sha256": "87c82eaf906c23bdec8f93dc4a15d0446deaf0c17930045654eb51bcf32e458e" + }, + { + "index": 372, + "required_count": 6, + "support_count": 27, + "height": 7, + "required_sha256": "334430bb8112c4b98f60059dbb180b9833970d294d8ba07340d82892779b85a4", + "support_sha256": "be606e1515629709655ac518f9ddb0dab892ebb2e30116cecf047ef79453baa2" + }, + { + "index": 373, + "required_count": 5, + "support_count": 28, + "height": 8, + "required_sha256": "5e442621fbd468371906d15ae9b96517b741eb0eb8e26fe82ce83a560d719259", + "support_sha256": "6de1b97409e947e4019e482817a5108b7391eeec58a8b2f8ef7856774a5d9dd2" + }, + { + "index": 374, + "required_count": 6, + "support_count": 11, + "height": 3, + "required_sha256": "4a5e5374f320766a37f55e1e0ff2621108b26b7cf1e6a02335b971583f7b7c7e", + "support_sha256": "74c07fa9a221235b2e30556e513a3288edce8a09fd800e7a595e0c01c476941e" + }, + { + "index": 375, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "58fe543a7ea5a75a9b3cd3db31e55512c2eb111ffb483c19260175d91f0c5efe", + "support_sha256": "4a48ffa27145c7d58c5a7b8b3a3e49bb2901887b3f701dce592d3d205cc62b20" + }, + { + "index": 376, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "446b5b6838ce88186e9cab0a23c27242722a1fb0c938824701f720a5d9ad9d05", + "support_sha256": "21157aafd92b163b4cda0ba0da868e71fbe15a3d36d3de2083010030ea0726a3" + }, + { + "index": 377, + "required_count": 4, + "support_count": 18, + "height": 5, + "required_sha256": "7c5cf66aa5e0204e34191170a71990f6173099334834cfba5534d5cb80eca96b", + "support_sha256": "2985e491b8b9eef0a19a0f84c7eccbcdade7a103792e5c6a764e8fc8ad92c680" + }, + { + "index": 378, + "required_count": 5, + "support_count": 18, + "height": 6, + "required_sha256": "e92c7e376fec917454ffd94db7e5d25375ae9ed8f81d443e3c53d8df846f565a", + "support_sha256": "e908ca3d16f8b58f106e251e01873c3d3fa553d462721c6da1c64da47752b2a0" + }, + { + "index": 379, + "required_count": 5, + "support_count": 23, + "height": 7, + "required_sha256": "82d199b5b4881636f3ba25bdb50467c012eaac1d34403b4b50a678c20ccc94ac", + "support_sha256": "10f668fba3e431a84aa1963de227e3fa05613bca581065fbee124d5042611c7e" + }, + { + "index": 380, + "required_count": 5, + "support_count": 27, + "height": 9, + "required_sha256": "665d9067b612668c747631ce8f7b2dc554766978f0b4d973ad6388e7fd4ec936", + "support_sha256": "adc0bad4acd50781203a6e0fcaf7de7cfd5dbf17fff55930ee0bf133ee0e5839" + }, + { + "index": 381, + "required_count": 5, + "support_count": 12, + "height": 4, + "required_sha256": "6585a2ba4973b044d69386c10cc6d74c43eb9de75b899810962656c466f5b7d4", + "support_sha256": "28b7a31a06b3e22a246b3eafa7f18bfe8eaad09ac0751fccf02dc3f94b3a027c" + }, + { + "index": 382, + "required_count": 8, + "support_count": 19, + "height": 5, + "required_sha256": "5875377d0709dabef762b327e3ad0603ea46f34386472080c520205669b0ef4b", + "support_sha256": "5dbf7690a22cfd786ddd7690c6dc8461009d05ae198fb0c5c2c89b6605c470d7" + }, + { + "index": 383, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "2330c771518ea1ce59de2bacabad67c8eb110f37bfd9a44cacab4c7e8c40fce8", + "support_sha256": "3cb6a92cfe61a676f2033146b190118eedf72ea5f95ffb1c4702a70154267836" + }, + { + "index": 384, + "required_count": 4, + "support_count": 21, + "height": 6, + "required_sha256": "27baea899d9743f1a67920f7d33c2031dbce11364182fcb020dde33bca9d78c9", + "support_sha256": "11818a393b3b71fdc37c8216b1d9ebb47b467b8bcefed2fa9f8827f530bafac6" + }, + { + "index": 385, + "required_count": 4, + "support_count": 31, + "height": 7, + "required_sha256": "27baea899d9743f1a67920f7d33c2031dbce11364182fcb020dde33bca9d78c9", + "support_sha256": "be9593f1c4a237d66550a7bbb98700fe0852addb9a3720741cc1c8b31452cb63" + }, + { + "index": 386, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "83841281bcc8340aec17c80adec4550af17749728b2473f692eea2475830218b", + "support_sha256": "3cb6a92cfe61a676f2033146b190118eedf72ea5f95ffb1c4702a70154267836" + }, + { + "index": 387, + "required_count": 6, + "support_count": 18, + "height": 6, + "required_sha256": "c5d1d6880e8abf4c426dc408facd65d9cf5ee8e8eedebab1b2730fded08b805f", + "support_sha256": "50817aa2f5ec4e60d4da3d6ea9cb014977e5e4176542048843ecfdbc9c51136f" + }, + { + "index": 388, + "required_count": 5, + "support_count": 21, + "height": 7, + "required_sha256": "2fb9eb01f52a4f852fb4ca34e5bcc0fd1580b26ccb94423da6c5b7c69bc16de4", + "support_sha256": "b8f88eab42e0455efbe983b858c6d096021a6bcc949e7a6f3bd370552c049609" + }, + { + "index": 389, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "d409d6c28fe44dfa09acb61858b1880cef60e2c752a465ab9527e79379d05e2b", + "support_sha256": "6962207f950822180518630213a8f99c697f173744ee779332c68db54d745a3d" + }, + { + "index": 390, + "required_count": 4, + "support_count": 22, + "height": 6, + "required_sha256": "e37abf053203cd45fa57c6ceddd7d61adb71ff51767fc2e14c86870e1a197998", + "support_sha256": "46cac931a4033583f52983be84393694a9d85cf8c635b20621389cf0c91aa964" + }, + { + "index": 391, + "required_count": 7, + "support_count": 16, + "height": 5, + "required_sha256": "38b3d40106d11bf9c79ede89db5b18ff1e0f596dc6ccec78cb478bb772d37ae3", + "support_sha256": "b1caa62488324a602f10420e97ad4508be189e2d002bdc04e1787b55e87a68e6" + }, + { + "index": 392, + "required_count": 6, + "support_count": 17, + "height": 6, + "required_sha256": "df668105967a501d18d82f8c034d97bf70fa8a95f3d3bdb8e16cf6bcffcb549c", + "support_sha256": "6c62c682c2a80ea095ebc115ca2932b34be8645409b17ece0749d5cdf541f355" + }, + { + "index": 393, + "required_count": 7, + "support_count": 20, + "height": 6, + "required_sha256": "2cdf00fb68828cd10ac5d84f1f07dac0e3fb3983258236240b9a680b1f8f2a63", + "support_sha256": "269885a2733e882868dfaf480f1b63c7f836282775a7c4ea998f4aa8626536cc" + }, + { + "index": 394, + "required_count": 5, + "support_count": 24, + "height": 7, + "required_sha256": "d99b710aefb0c656a67cc511f0b7a1cbe182a5726c1d7956175bfd482a86ca55", + "support_sha256": "ac16ef9ceb6240ca73cd4a114cbacbafdc5cef23ae2ee037f901a8d98f42dfb2" + }, + { + "index": 395, + "required_count": 4, + "support_count": 22, + "height": 8, + "required_sha256": "bf3316bd5fe228b13ea6523620e2230f12629a737df4f80dadc41ef624360de6", + "support_sha256": "8e9f8279b19f6227d1406accc70c1fbcc1a6eb858f3f3a4084b8b9609512f0b7" + }, + { + "index": 396, + "required_count": 3, + "support_count": 26, + "height": 9, + "required_sha256": "e59a95ca67f5194c7dc5a2b67d1276e06ec38a0f2a04fe8b02f5a8c2a5c6b8c3", + "support_sha256": "85f9ba623b199603cbd6f651d8f54a8e4ab6c8f47a405aa5a2519076ea9b1aaf" + }, + { + "index": 397, + "required_count": 3, + "support_count": 30, + "height": 9, + "required_sha256": "8c65f188fd55edb653c6e5e1a232b5aa05690945ab4950a6920b0dc34f69cdd6", + "support_sha256": "21aec956c3aac56216ede91fc33b524f2be168f8f222c6dba164b08d30fa791a" + }, + { + "index": 398, + "required_count": 3, + "support_count": 38, + "height": 9, + "required_sha256": "8c65f188fd55edb653c6e5e1a232b5aa05690945ab4950a6920b0dc34f69cdd6", + "support_sha256": "fbea05dfcb1ed3b6a8fdc84bb6450db153e225128ec00831cf72cde6c4e87f26" + }, + { + "index": 399, + "required_count": 2, + "support_count": 42, + "height": 10, + "required_sha256": "9cbf98a4cc84ee1509ba134f32d86a08b41395eed05c6eebc85fe56e9b5dfc8f", + "support_sha256": "d0096816c50a7b9516133cccf666f6dbb2be80be406938b3ef72ac2a766b2b0c" + }, + { + "index": 400, + "required_count": 4, + "support_count": 24, + "height": 9, + "required_sha256": "c6c425b75752ee8fb7a2087494ad0f2bf0a94ddd01370dc1ce424824ff782a4a", + "support_sha256": "e55899ebf2dc03db7bee5cb28d47eb8945d8cfcc2f39982c4f920205afc41c3a" + }, + { + "index": 401, + "required_count": 4, + "support_count": 33, + "height": 10, + "required_sha256": "16b0d2b93dbca4e23f724a8afefc221010c23f2f1f3a5eb97e5e482357870a77", + "support_sha256": "313970ada18d5a3537eb3675cd679c18cfc2f43dc22c41700dc6007b2e3e243b" + }, + { + "index": 402, + "required_count": 8, + "support_count": 15, + "height": 3, + "required_sha256": "de3f9723416e38ffe76c2a881f69a9b376663cc741a44e3cfcf41a8cbba5da7a", + "support_sha256": "648ed69db2f03497a4239ea78190852019a95b1d018d4f02e7878ac1a7d77590" + }, + { + "index": 403, + "required_count": 7, + "support_count": 24, + "height": 6, + "required_sha256": "f195910884d45eaa416ec95edd514809f6a1b359571572d323130310dfb32558", + "support_sha256": "11ee74e06189de350456ad18e847ce3d83d3bf0866b70277bac52bae0b51b73c" + }, + { + "index": 404, + "required_count": 6, + "support_count": 19, + "height": 7, + "required_sha256": "e05bd706d38189779312fd845d8a0870bb047c13288ea833aa89009cb56c29b0", + "support_sha256": "97f7087f55a1591b99d57962590c39f1d4a6754fe616ca3f98c10ea675bbc439" + }, + { + "index": 405, + "required_count": 5, + "support_count": 20, + "height": 8, + "required_sha256": "e5b4a641211d1efc2950a7d4528cf7da8840f6d1d99c6764f842cbf04aa3ddc7", + "support_sha256": "bf4af410292e6111fb82ecea1ca27a70bf605a580f399b46ac916238351842fe" + }, + { + "index": 406, + "required_count": 5, + "support_count": 27, + "height": 9, + "required_sha256": "17e3ddd34a0026041cb949247e6668daa97c47307b3fb587730bf5441f41ef94", + "support_sha256": "a02f5e78f26f40a322b756337a8efc60302ac6edde991912380d9ccba42727e0" + }, + { + "index": 407, + "required_count": 4, + "support_count": 23, + "height": 9, + "required_sha256": "cca95e69ebef4e9afc297041e167220dfd5f9f5acbafd51cbc988c23d5d9431b", + "support_sha256": "7f88ebac583ba152c89d5174711bb126d1ca58764dd3a192e44093f7f6cc7c08" + }, + { + "index": 408, + "required_count": 3, + "support_count": 28, + "height": 10, + "required_sha256": "1bc46cc1d98ede9f6c1bfd22045c6d7a898b05e5650a0253527c92c27d3d46c9", + "support_sha256": "0ec81d7c4f0700b93b8f2450e97aef9b8384d1d8cbb5e8052633ad8743c267d5" + }, + { + "index": 409, + "required_count": 3, + "support_count": 28, + "height": 10, + "required_sha256": "65858bbf73358ccc114d29da7172c7bc4bfa7b6fe83456b02f658f40b835fdd1", + "support_sha256": "0ec81d7c4f0700b93b8f2450e97aef9b8384d1d8cbb5e8052633ad8743c267d5" + }, + { + "index": 410, + "required_count": 3, + "support_count": 31, + "height": 10, + "required_sha256": "1bc46cc1d98ede9f6c1bfd22045c6d7a898b05e5650a0253527c92c27d3d46c9", + "support_sha256": "b5eb69a061b20eca0e1ad9be2a98816b78d622880dfbdefa499dfa0490af0b8c" + }, + { + "index": 411, + "required_count": 4, + "support_count": 28, + "height": 10, + "required_sha256": "06c2f47118418df50e98907f77af6346ec0df8f066c53b0e4a727e8d4d4856cf", + "support_sha256": "11a4ff917839720bad7d6d89ee2a76ff8105c6deb36093a31a8457d96bd954f0" + }, + { + "index": 412, + "required_count": 7, + "support_count": 22, + "height": 8, + "required_sha256": "aef375f2d8764c2fe91bfe440fc93fa1ee019ddbda66f5ee74f1e5a90f02ae4b", + "support_sha256": "676c7e7bbae64fe5819e85461cb34be5fe18f6a4e8b46bce811dd962b75e5be8" + }, + { + "index": 413, + "required_count": 6, + "support_count": 15, + "height": 5, + "required_sha256": "9a48920cc85d0eb3f04b33e7b25193b52a6de46f564718a43757b5f771ea330c", + "support_sha256": "a8566fcdea391b17956dd8eea94da2dca3be1c188608cec0af3e326d2e6077d7" + }, + { + "index": 414, + "required_count": 5, + "support_count": 16, + "height": 6, + "required_sha256": "78a26a79f8be9a137354388df1728386440aeb4fa5b096b502a5ca96c22a5ea2", + "support_sha256": "b1e87d5ea072364f14542e1798c5796cbe2ea6e9887cdc00530fe1bdd59e1e84" + }, + { + "index": 415, + "required_count": 6, + "support_count": 19, + "height": 7, + "required_sha256": "8287be9666c6eb1022c856552de834372bada118d35a86f248c4977372b439dc", + "support_sha256": "8818b807310615e009cd80ce1fa01323e5b635b85a3b676d09bfbfc283978857" + }, + { + "index": 416, + "required_count": 6, + "support_count": 17, + "height": 5, + "required_sha256": "0931f547231c2ad51c0ec789fcee8b746f7e045d2f2e6fa1d3df52ce0ae5801e", + "support_sha256": "bfef4eb470d4bf7efeb24c3eb30e3bbc2d2a9697841a6b62e596aa4c239921cc" + }, + { + "index": 417, + "required_count": 5, + "support_count": 18, + "height": 6, + "required_sha256": "3ba3fd2650ef1834877d0aa4a9790ff3b418fa26ad418fa83ca0acbce3d7721a", + "support_sha256": "6019c29482c014d21b14cff668cd2b7ea5c84ffcfa5e8b21f40ea8f483b7aa4e" + }, + { + "index": 418, + "required_count": 6, + "support_count": 21, + "height": 7, + "required_sha256": "494bc5176a27b181c7b7aa06d58e94cb19a9ad9ea6dc2724366fafdee685a0a0", + "support_sha256": "0bf16d7bb92a1f3641ff5c206dc974a3a7e0c5cf110c507274df7b707ac69aeb" + }, + { + "index": 419, + "required_count": 5, + "support_count": 22, + "height": 8, + "required_sha256": "448be2c890a6d5f5512fb00a9b50890cd1c73789786ece1da7d5b7a05b32fbbc", + "support_sha256": "212f923204ca6aa97f9a6be4e8f1d77df84ee430fee5a2ca9edd21211472b89a" + }, + { + "index": 420, + "required_count": 5, + "support_count": 22, + "height": 8, + "required_sha256": "0cc13e65843afcd5d613549a6c04eb296a0b9c32d6514c9febe5c323e5a32aec", + "support_sha256": "c4ae7306eb54042cdf99bcf7d6d27001e554fb5bcd0ba23b4cabc4f440c7508f" + }, + { + "index": 421, + "required_count": 4, + "support_count": 25, + "height": 9, + "required_sha256": "0a8216a68beccfd4aa9372688f88db400e646125f0c04ef12dec4d42e87157c0", + "support_sha256": "faf4f411907de114136feafff14c4268ce2aa09d00d2cb7ec2e41083a880a4a0" + }, + { + "index": 422, + "required_count": 4, + "support_count": 21, + "height": 7, + "required_sha256": "2c0e1e155e480bfecd86953d0137181c3f32f6cc1de045cad8db63c15c8ace9e", + "support_sha256": "f0786b260f210d85c9ddc41ca5f1459a93737dd2823e5142dfd7c803d78878f9" + }, + { + "index": 423, + "required_count": 6, + "support_count": 21, + "height": 6, + "required_sha256": "8249cd1401fd60f57c58b18ff4e513b27d05c50789b74be34d94d27c5e1d915f", + "support_sha256": "14eaf45d5be11a94b97ba66c3ea8006bcda1cd916d969c45d9fc3b03de0f80ca" + }, + { + "index": 424, + "required_count": 5, + "support_count": 14, + "height": 4, + "required_sha256": "7ec9e15e4121bf998747a247603ab19c50adfcfe924b87638630be5cfe081c41", + "support_sha256": "b2d4232d4a0e3cf3a9a65f3c9f216ede7e9c1f4f84bb81023d8aa17c517f35cd" + }, + { + "index": 425, + "required_count": 5, + "support_count": 14, + "height": 5, + "required_sha256": "bb4164623a714fbf61fd1ca8a86ad132c36f0102178727652fd4753a70e897fb", + "support_sha256": "c8342d52a7869525e13fc4ffa6dc43b26069c630ee9f5548fdcef9ca16f8daa2" + }, + { + "index": 426, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "6b3e0aca13ba5a85fcecaab5139c0fc6b20e661e988b3fa9b96793df0e713146", + "support_sha256": "b2e708509249834a60f4ac2bd1aea0292a9a1e652fbc52917b71473900bd8764" + }, + { + "index": 427, + "required_count": 4, + "support_count": 29, + "height": 11, + "required_sha256": "8d0d0c77559ba009c5b6581d245814abafc3345b766313e3723445846710c2df", + "support_sha256": "ed81408f474f37ca7db6cb5abb3f97566863654ffa159690f7b89b0dac57547a" + }, + { + "index": 428, + "required_count": 3, + "support_count": 32, + "height": 12, + "required_sha256": "fe3fd2e5c80b52d882b5ac0781750025d7c2f7177a724e62be536c7efbe3dafd", + "support_sha256": "85c62d2f982c5809fde7e6acd65647350786a9d91bb4b89567c4d4fd36ae55f1" + }, + { + "index": 429, + "required_count": 5, + "support_count": 20, + "height": 6, + "required_sha256": "ca0809ce10d1ee88bff84ec515a69274de333d7606054808b084c43aadee79d7", + "support_sha256": "da1b56ef0e847be3126485c29a41ba82590cc11554c3c2a3133cf8473d72b9cf" + }, + { + "index": 430, + "required_count": 4, + "support_count": 28, + "height": 7, + "required_sha256": "6571b1d2c8eb5aea56950370bc627683ec93d8c020b205eb34027fa76bc9321e", + "support_sha256": "1764ae1ad69fa8f5ff29df6bcea0e21e79041d64eb1ae4b40eb0b75a57848dba" + }, + { + "index": 431, + "required_count": 5, + "support_count": 28, + "height": 7, + "required_sha256": "6c3b6dcc27b81a7fffdacb19b04d932ec04ce50b0af45a90fc6a129e48a2827b", + "support_sha256": "063bfabd631262d078199a48c81fc8f526a9b9f6a620b37ac3c782d3139ed0ff" + }, + { + "index": 432, + "required_count": 6, + "support_count": 13, + "height": 4, + "required_sha256": "bfc2b771fcd61035dacd4170c9e71101a7647627856a1edbfe21e53c4e40580a", + "support_sha256": "4da1e65ac72e4cb332ad7a3a9919d2896cefee22a57feefd75f643fc0c24f95e" + }, + { + "index": 433, + "required_count": 7, + "support_count": 22, + "height": 5, + "required_sha256": "2a38943f156183df9fd9eb58c8c6ef713f249fa23fb6f997b086549b8de15c39", + "support_sha256": "4bc91669916826bc2ea0d95fa6ce36eb5f8cc25e1ece596214d9a1a011edb68c" + }, + { + "index": 434, + "required_count": 4, + "support_count": 35, + "height": 9, + "required_sha256": "8e0b94c10802d45d8c5e25eb9093ebe1a5cca2ee77d57878170ec6c8fb5b6d3d", + "support_sha256": "03a74069b8164fad1b6dc92bcd7492fac0d28aaea89b4a43ee6410e36842e8a9" + }, + { + "index": 435, + "required_count": 3, + "support_count": 19, + "height": 6, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "e2a49d3b9b05e5e8c1375a631652f7f4af527dccb50790ae9ab15dce878b4810" + }, + { + "index": 436, + "required_count": 3, + "support_count": 31, + "height": 7, + "required_sha256": "577eba75e7a3ce41c1a85dfcd9f02b357ee5e3c9a90dd42d8680d97337b47fb3", + "support_sha256": "b5d32e31df201cbbe500ab831eba3ec0f98e20cdbb6cc325b6e87af373be34be" + }, + { + "index": 437, + "required_count": 3, + "support_count": 31, + "height": 7, + "required_sha256": "65255871a86c74c526e3aa4936985db6b137552e9d5a2212e6664d83d829f555", + "support_sha256": "b5d32e31df201cbbe500ab831eba3ec0f98e20cdbb6cc325b6e87af373be34be" + }, + { + "index": 438, + "required_count": 4, + "support_count": 42, + "height": 8, + "required_sha256": "5e1087dd2d8de20bc7f3aaf870d5d6d4f2d62923262041e08e2cae09f9e5458d", + "support_sha256": "af4eded0c94677d3caf9cc95ff812982edac202bac3a4802db449e3649a9637b" + }, + { + "index": 439, + "required_count": 8, + "support_count": 19, + "height": 6, + "required_sha256": "e0cc9838241deef1666e7575fc945ee03be7c6d6e6dfbd6074d0c636e942ac0e", + "support_sha256": "49bf0912af0c30ad2e800253cf25919b46195a744f5bd398dc5447335aa46226" + }, + { + "index": 440, + "required_count": 6, + "support_count": 29, + "height": 8, + "required_sha256": "4bb2ace681d563538d582c9595e94502390ddb3d2628ceaadb8c7438fb375e4c", + "support_sha256": "bb603b52da93cd0ae2751ee5d78c728f84b90eeb4bf30dbe45295b7a05179584" + }, + { + "index": 441, + "required_count": 5, + "support_count": 31, + "height": 9, + "required_sha256": "3659c07bad2aa46506274f0e0dc4e196be8869fe5f920c39d03fb4276fd2ae54", + "support_sha256": "8e10a325a1e9479328dee577d949d6a8becce5aa1d9fce4fc53dd5fe831055b0" + }, + { + "index": 442, + "required_count": 5, + "support_count": 32, + "height": 9, + "required_sha256": "3659c07bad2aa46506274f0e0dc4e196be8869fe5f920c39d03fb4276fd2ae54", + "support_sha256": "22428a5e9f08c6889e50596f2b5d0ef943b8dbb1abfc636f6b486284e18bea73" + }, + { + "index": 443, + "required_count": 6, + "support_count": 23, + "height": 9, + "required_sha256": "f4d43382a701fd250bb637935b1dc7cddadb2044b3a76769589a746a515fff2b", + "support_sha256": "9f91ed4296a186aad0e8b8627119bc0d073a2c528b7e57b45591faac8aa96b4e" + }, + { + "index": 444, + "required_count": 5, + "support_count": 26, + "height": 10, + "required_sha256": "1a42d42d9ca272c4aacd3ca48f6225256f38f44f41d9e02426b28d43d4f492ae", + "support_sha256": "49b118b8543ce4ace30777782240aa765a6b8976cee3ba54146f8509989fd202" + }, + { + "index": 445, + "required_count": 7, + "support_count": 19, + "height": 5, + "required_sha256": "edc66d9697f7ae17886367e97665ba6d452ffcd8ca67ad085d807fcd19a73fc7", + "support_sha256": "7ec80180e07a5615a2552af83d675a738e63493efdda6081272199aac7616a92" + }, + { + "index": 446, + "required_count": 5, + "support_count": 21, + "height": 7, + "required_sha256": "fd046f878d393afd1a1d87757eb851fc8b7c4bf04cc636e5cce5baf9453bf374", + "support_sha256": "4b25e0006786155e3bcb09bb8083df00f01bc9debb959e61ff5b6a6758eabf81" + }, + { + "index": 447, + "required_count": 5, + "support_count": 21, + "height": 7, + "required_sha256": "448be2c890a6d5f5512fb00a9b50890cd1c73789786ece1da7d5b7a05b32fbbc", + "support_sha256": "6329a1624107bc90cab0e95d5b66e79e6f52c041f1e5a6bea68670193addef80" + }, + { + "index": 448, + "required_count": 4, + "support_count": 28, + "height": 8, + "required_sha256": "23b4d494e773e1f415bee4dd2c24780a74e006613ce34bb9a9b843c428fa371c", + "support_sha256": "d1d8d1e7e277c5e7ae0d6458d8730ae82eb6355657eb8cbcc28aa603faa99566" + }, + { + "index": 449, + "required_count": 3, + "support_count": 34, + "height": 9, + "required_sha256": "df699b95325119253cda671365c40b728f018d740050f14f858efdef704b57ad", + "support_sha256": "1b6623d009a5b195ed8e9a4dd2e6ae8bcf2b0cff49ac0c28393d62d764419bf6" + }, + { + "index": 450, + "required_count": 4, + "support_count": 29, + "height": 9, + "required_sha256": "8cd5b0204f86bd866f6901ab6212e0f943bb4d0383268edbde35b215fac35848", + "support_sha256": "87523428d3c1ec22e5fc246d52a63227e2ffa3f4a70260a8270a3e9026e23890" + }, + { + "index": 451, + "required_count": 6, + "support_count": 19, + "height": 5, + "required_sha256": "507ee1cb4e20b7f4279c1073b9d2c5a39101287942b2ed89d90d0b1523294603", + "support_sha256": "fff0a89a90930e85c5947d7190585169b256199ff5f92ac4009597fd2dc774af" + }, + { + "index": 452, + "required_count": 4, + "support_count": 33, + "height": 8, + "required_sha256": "5e1087dd2d8de20bc7f3aaf870d5d6d4f2d62923262041e08e2cae09f9e5458d", + "support_sha256": "9e568d129a056733c8efb0fab1d4f4e3edb76ca7b7649e58a58823673a5801cd" + }, + { + "index": 453, + "required_count": 5, + "support_count": 21, + "height": 7, + "required_sha256": "1cfb4453b6dea8c34b9d44634a3e31fc1855b11236932ae6a4888caa8123c61c", + "support_sha256": "ee63fc3907170248163c24544bde7da1018bb452391290e6dab49dee57aa66da" + }, + { + "index": 454, + "required_count": 4, + "support_count": 22, + "height": 8, + "required_sha256": "d853bfef084a4ee8ed4c0a8572f869da290a463da35fae31b454bfcc4fa0ae97", + "support_sha256": "bffc37216765a9afb02454eddae67d7d460135ecebb9e28d61a75445b3347698" + }, + { + "index": 455, + "required_count": 4, + "support_count": 24, + "height": 8, + "required_sha256": "9fd884dcf3228358998991c7170367ddd9b734e3edee5576ec9867dca850278e", + "support_sha256": "cbe6821a382c641c18e1d4b76160ce2990f4e922c5930f4928d50fbdd01d42f4" + }, + { + "index": 456, + "required_count": 4, + "support_count": 22, + "height": 8, + "required_sha256": "8d0d0c77559ba009c5b6581d245814abafc3345b766313e3723445846710c2df", + "support_sha256": "bffc37216765a9afb02454eddae67d7d460135ecebb9e28d61a75445b3347698" + }, + { + "index": 457, + "required_count": 3, + "support_count": 25, + "height": 9, + "required_sha256": "fe3fd2e5c80b52d882b5ac0781750025d7c2f7177a724e62be536c7efbe3dafd", + "support_sha256": "c88ae733ee4e0a488eb9569ae41f1102e8c9c3f62ac1eb12dd169e0d4b8ce14e" + }, + { + "index": 458, + "required_count": 3, + "support_count": 24, + "height": 9, + "required_sha256": "fe3fd2e5c80b52d882b5ac0781750025d7c2f7177a724e62be536c7efbe3dafd", + "support_sha256": "87457c1b207ac7f9cb6a1ce279d961371bf1ee5460c3d8890ad86783cb837f3e" + }, + { + "index": 459, + "required_count": 2, + "support_count": 40, + "height": 10, + "required_sha256": "35a8902c61bca0e7794993725c0400c8c26a91a2c9f718fcf39d6ccce5df8a19", + "support_sha256": "def56730f0fb85fa8cbcd090e56248e2283736207fce02b5eeffd27fffb3b524" + }, + { + "index": 460, + "required_count": 2, + "support_count": 37, + "height": 10, + "required_sha256": "87fa6c271bc269b2d333b70c12ae740f826e469299cd6a1e9d8892bd7a3535a3", + "support_sha256": "faf3221b133ad626210b4a0dd514f7ba68dbcee9f20323c42831357b6e92c595" + }, + { + "index": 461, + "required_count": 4, + "support_count": 32, + "height": 10, + "required_sha256": "f77a71b7fcd0335fa1bcf811cecb356b4f421cb9c03d034c91dc3bb5ae89e4a0", + "support_sha256": "2d2557fdef493c53175b9baab6a296d1ea713be454071a39f06c7b84f190e607" + }, + { + "index": 462, + "required_count": 2, + "support_count": 47, + "height": 13, + "required_sha256": "09665a01b5c57a8c2a4e7e39244935870ca4ba3fe9ae3c43f158ec14b44e09d0", + "support_sha256": "e40e15ef4918b1d8690945c9574e6582f5ba7d5e718858bad296fcbf5fc2bea3" + }, + { + "index": 463, + "required_count": 5, + "support_count": 53, + "height": 11, + "required_sha256": "e64913893b18468bb09d5598d96f88bdd7f66952a4e82d3d834a8b57ec01600e", + "support_sha256": "51efcabb3a5221eccd5e5e16a75307f94a1151a0a0f2ada280866ed59013f495" + }, + { + "index": 464, + "required_count": 5, + "support_count": 18, + "height": 5, + "required_sha256": "ffecd1e1d20b05797e4315a0eae8ca20f1dded5cf62dfb515f9fa167ea255cac", + "support_sha256": "841ca5ac3115e14e9d1157df20fc30b6aa0b3e694fd71f32c915d54ceea4cac9" + }, + { + "index": 465, + "required_count": 6, + "support_count": 26, + "height": 6, + "required_sha256": "f4d43382a701fd250bb637935b1dc7cddadb2044b3a76769589a746a515fff2b", + "support_sha256": "0a97411866e0d2e8cbe5f8bb7fab63ea3d5ebe7fc4161ebe7b246887c6d3608e" + }, + { + "index": 466, + "required_count": 5, + "support_count": 30, + "height": 7, + "required_sha256": "1a42d42d9ca272c4aacd3ca48f6225256f38f44f41d9e02426b28d43d4f492ae", + "support_sha256": "3854e58d38619dd544970f99e604a045db9b8363d56ccfd784753672647e28ab" + }, + { + "index": 467, + "required_count": 4, + "support_count": 62, + "height": 11, + "required_sha256": "4f96f7755761ea77a2400bf937065b761d53e87fca3d71e53a5992049ec643fb", + "support_sha256": "c09f60d6c3d509b29bd40588d6cef0f6bf2f2cc7d41de27d9f1e4ad89c532058" + }, + { + "index": 468, + "required_count": 4, + "support_count": 44, + "height": 11, + "required_sha256": "3c6d480f1b5a7e48a534188ac9bb6f801e4cbf8e6b41d5276a056d741c2b611f", + "support_sha256": "a41b0b8fd5b2fb765e9d7f7733c4f13196e6ab773fcdf115d5c6f2114a561b13" + }, + { + "index": 469, + "required_count": 5, + "support_count": 28, + "height": 7, + "required_sha256": "d262631ed9d5aae3987d53dd1fe5e05ec7b66857bb118040ff325bf9fc5a7a8b", + "support_sha256": "bab33d6ed7c764a9411401ec812c73daf6a80013f1f1f02ec1f8a1a63fed8d11" + }, + { + "index": 470, + "required_count": 5, + "support_count": 41, + "height": 9, + "required_sha256": "d861da7bc7bbe0fc335f0a87acca71f4853c0adb439877a8ccffe7e6021a10b9", + "support_sha256": "2b8a091b6c7b25c7c5a17223c8f1985cf934a41496ec53452fae51d14562b49a" + }, + { + "index": 471, + "required_count": 6, + "support_count": 19, + "height": 6, + "required_sha256": "d14b770876bbe48028dd6e4e7aa68c41f70fcf9ef95b71b18a9ee934cd95f7dd", + "support_sha256": "93de4ebb5c2b29ba1c8d7b32d1cc1784aaaef73fafc9577b12b496a1a0dee290" + }, + { + "index": 472, + "required_count": 5, + "support_count": 20, + "height": 7, + "required_sha256": "419f063e41245f000e8eb1662621e4cf41980b994df2166c0967b496a032dc41", + "support_sha256": "d3c8d6ff55442c777518bdca6db99308de6225397398629a71bd49e2b4884630" + }, + { + "index": 473, + "required_count": 4, + "support_count": 21, + "height": 8, + "required_sha256": "8c857eb5533d8d09ba6fbc6a775b49f709bc47b059a47dd3b06efcdfc74afca3", + "support_sha256": "a46d7fde00d766ffe9c42b000ebfb13fee2d6056fecc7d830171fcedc1f01f5c" + }, + { + "index": 474, + "required_count": 3, + "support_count": 24, + "height": 9, + "required_sha256": "ac0de9c14e79556f69d7d334af1f188b57fd6cd82ad4b12776f599a2f5137e3e", + "support_sha256": "7760f20ac378ba28f5f3434bea2641d2906193808c1518d9c161942b47d7bcfe" + }, + { + "index": 475, + "required_count": 2, + "support_count": 36, + "height": 10, + "required_sha256": "9cbf98a4cc84ee1509ba134f32d86a08b41395eed05c6eebc85fe56e9b5dfc8f", + "support_sha256": "2ccc88a886e08cb8428f95bc75e31a0c1afd4af38e8c694cd305463c9761abd2" + }, + { + "index": 476, + "required_count": 4, + "support_count": 34, + "height": 10, + "required_sha256": "f878d0e8ab29445aa0de382bc82fe4fac76c301d363da189d71d6ad5a8d34d3c", + "support_sha256": "ef6aa6805890819154e1b4f4a17aac3e254fac4891620c2a82369f67d903ed16" + }, + { + "index": 477, + "required_count": 3, + "support_count": 23, + "height": 9, + "required_sha256": "ac0de9c14e79556f69d7d334af1f188b57fd6cd82ad4b12776f599a2f5137e3e", + "support_sha256": "5fb19d2b280870abdc831c51048c1d7706b08890e4741e33e48f7d0f44fd554f" + }, + { + "index": 478, + "required_count": 4, + "support_count": 21, + "height": 8, + "required_sha256": "f060f1b028980150e56df33ff67b2a93e8fd3e97e45665d2442050b56e19db94", + "support_sha256": "a46d7fde00d766ffe9c42b000ebfb13fee2d6056fecc7d830171fcedc1f01f5c" + }, + { + "index": 479, + "required_count": 3, + "support_count": 35, + "height": 10, + "required_sha256": "27b5a821cdf3002871c0d8a44094865ae8b246decb8ecf1d4e786a121be899b9", + "support_sha256": "384d0c88bb7c2796fa7c54d692b9b8ca12adcacf00034e38a41088562d9a2f69" + }, + { + "index": 480, + "required_count": 2, + "support_count": 39, + "height": 10, + "required_sha256": "08be7f6ce37dcc59d92de4a362498b337f70a9912a9ea13281342c21135009e4", + "support_sha256": "6e31dce220c388aca770498af4eaa2f3fc55d0b29bc571b4a49fdc8f9610fe62" + }, + { + "index": 481, + "required_count": 2, + "support_count": 36, + "height": 10, + "required_sha256": "37066704f2a465a40eeadd2f694523acde6850144c39048a3d146d63d7ed3cce", + "support_sha256": "6fe2ec9f60f19c2ce733d57927e867292369e15bf621bf29a3929ebf351bf8cc" + }, + { + "index": 482, + "required_count": 4, + "support_count": 22, + "height": 8, + "required_sha256": "f060f1b028980150e56df33ff67b2a93e8fd3e97e45665d2442050b56e19db94", + "support_sha256": "90111fae41e1dd7b11929e962d49fad9a57b3c39486f119d59624a170a18e0d8" + }, + { + "index": 483, + "required_count": 2, + "support_count": 36, + "height": 10, + "required_sha256": "9cbf98a4cc84ee1509ba134f32d86a08b41395eed05c6eebc85fe56e9b5dfc8f", + "support_sha256": "8804b64b63834a8d03aa8a375e1f7d73fbe2492bb4ab033922d12afe2b027ea9" + }, + { + "index": 484, + "required_count": 5, + "support_count": 46, + "height": 8, + "required_sha256": "e64913893b18468bb09d5598d96f88bdd7f66952a4e82d3d834a8b57ec01600e", + "support_sha256": "9990942e8ae781f9fa6bb65e910bd515a558f296ee1e046ef97ea5da58714f58" + }, + { + "index": 485, + "required_count": 4, + "support_count": 60, + "height": 12, + "required_sha256": "56e80ede3fdee4020d104828bf6ed5dd7ee45c1b76df68f3fbb45672a1a2ab94", + "support_sha256": "111b4beba4b7c7704fb07e046c16605313fa722438572da46a6c1fe44cdbc190" + }, + { + "index": 486, + "required_count": 5, + "support_count": 24, + "height": 6, + "required_sha256": "e9f88c7d3f7c45965e0bba202fbe4d6668cceada4df31a327243a873a9151d37", + "support_sha256": "91047562d9f1d9f8e134babe663f590fcefc030300c64e42dbd907c335049673" + }, + { + "index": 487, + "required_count": 6, + "support_count": 27, + "height": 7, + "required_sha256": "ea8c83fd9bba273b189f14b4ea3717fc4af8f516b2c9607b6a1ddc08409547d9", + "support_sha256": "40b948d863b857ff6724d0d43abb65f822f0ca612d3559ad802c3263394d867d" + }, + { + "index": 488, + "required_count": 6, + "support_count": 35, + "height": 7, + "required_sha256": "b1b737a3b289285127d34a9cbf9f9a9e1179a7e26bb639a80e15b83022d8cd65", + "support_sha256": "3413ddadec172190a07f79a94ff7af19d171bf4ebb05e95633122a2c80e1b8b2" + }, + { + "index": 489, + "required_count": 4, + "support_count": 66, + "height": 12, + "required_sha256": "262407b7cc254f7cc8fc8168f680354ac074a61dd383dc14fbe9ee54375a0b3a", + "support_sha256": "1c293daed1097e72b23c9bc12c8e75a8d640e70c1a46a8fbaa7007bd0d0170ca" + }, + { + "index": 490, + "required_count": 3, + "support_count": 101, + "height": 13, + "required_sha256": "2e9d9fbd1a0eccb26a9547413b897e72f3b9fd722604cf14cb704c949cce3fe9", + "support_sha256": "a37f80dbb8b6ea88fdcd4a4675a5e5a4b0479ee0d9a6fa9a32c2dd02181e45ea" + }, + { + "index": 491, + "required_count": 4, + "support_count": 32, + "height": 10, + "required_sha256": "8e0b94c10802d45d8c5e25eb9093ebe1a5cca2ee77d57878170ec6c8fb5b6d3d", + "support_sha256": "16d0a5571e89dc8c8e31382e9d08455b3eb68db733c79b1c698d71e2d2a90097" + }, + { + "index": 492, + "required_count": 7, + "support_count": 20, + "height": 5, + "required_sha256": "f195910884d45eaa416ec95edd514809f6a1b359571572d323130310dfb32558", + "support_sha256": "d163f39744afb14cf397adee1792c116e5c1b3b5ea0733053d6c2c29b74ee388" + }, + { + "index": 493, + "required_count": 6, + "support_count": 30, + "height": 6, + "required_sha256": "e6734e3203098e9aee20b675cfd434597e75f36821e59565e03a7f06d6ad83d9", + "support_sha256": "c7f203a28afceb723ec6895983fe44546ab67a23192add4d9410aa12ec951c11" + }, + { + "index": 494, + "required_count": 6, + "support_count": 33, + "height": 8, + "required_sha256": "e6734e3203098e9aee20b675cfd434597e75f36821e59565e03a7f06d6ad83d9", + "support_sha256": "052d0baf8d32067d73a88bf95982c55e881b69390d088774b2f228748e1aa3d4" + }, + { + "index": 495, + "required_count": 5, + "support_count": 21, + "height": 5, + "required_sha256": "d906adb3465da18ac770d2b7980f1fb3400776316425f4fd1a9c4d9f462518ae", + "support_sha256": "9998faa7a6a4f785ce5370b0627b11ebd344eaaeab001c0d9c22e62887e55ec1" + }, + { + "index": 496, + "required_count": 6, + "support_count": 13, + "height": 4, + "required_sha256": "1b671371ec537f1286d25a4f89a32d16a8525a11e29d8b08c8cd77b870820a03", + "support_sha256": "3d488e66d34082284414a0c2540508865cbf75734489abe26b3e841dea2b577c" + }, + { + "index": 497, + "required_count": 6, + "support_count": 15, + "height": 5, + "required_sha256": "a82d75a8245885e67bbd231b2c69850adbe0f9c00acefec9091ca0dd8008e124", + "support_sha256": "09c2432031d5751bc259e45067c6f3009d414c0da12381029b8ed7a575435878" + }, + { + "index": 498, + "required_count": 6, + "support_count": 29, + "height": 6, + "required_sha256": "8e001a3d1d998c4bc514a86b2086ff17c733680a8907fb440ee3921a5cbe6b2e", + "support_sha256": "054aba24b0f0f7bf7ad81291c196e078f30880668a7cf1500000210cb21a9d1e" + }, + { + "index": 499, + "required_count": 5, + "support_count": 21, + "height": 7, + "required_sha256": "5373d544e973f91046abdba8bf6f806a3ed6c6f2932d524ee193744c1891055f", + "support_sha256": "bc2c279fa75854cfac4d11e2d10c73864391211aa6603685fd095b8a6972ef04" + }, + { + "index": 500, + "required_count": 7, + "support_count": 14, + "height": 4, + "required_sha256": "32b6d42c25cea1b7845d0d626b51820a9b5e6ddf8455de3e0ad6dd5ebbc3d4da", + "support_sha256": "a9df23dac1ff03f651282b39849b550c92307a6430ecc8f86d1a09b65936737f" + }, + { + "index": 501, + "required_count": 8, + "support_count": 17, + "height": 5, + "required_sha256": "faca007fdd24080108619b3cda86338f81b75effcea4832151e679b21646a3ee", + "support_sha256": "2b48285ea975ede44355ae744bd67f8ae1d059c984bcd45ed712597d99507350" + }, + { + "index": 502, + "required_count": 5, + "support_count": 19, + "height": 5, + "required_sha256": "4da4766f97dcb3d60efd0fbe5e56c75ad5b8dc907424b3ce1f097bada2d96009", + "support_sha256": "3a10fdf684731a98d17b4fa8fc96617749d6a44b7e3e861c9fa3f1d97501d766" + }, + { + "index": 503, + "required_count": 4, + "support_count": 20, + "height": 6, + "required_sha256": "0e4de524de0518477459231492c1886109809b25d4ff81e16d04a07d2d0d7b12", + "support_sha256": "152b64541af173d9d931b08541411b9629e130b53fa27b2241b964e9e6eef331" + }, + { + "index": 504, + "required_count": 5, + "support_count": 26, + "height": 7, + "required_sha256": "97e69a2bcfecdb65cce72f472f7a5e030133940fc4b6b2e9780ceb78bdf74cf1", + "support_sha256": "be8ae6f970b234688a3bfc9b0880d0c1e3083b991638d53b528395703bde393b" + }, + { + "index": 505, + "required_count": 6, + "support_count": 18, + "height": 5, + "required_sha256": "47df9d0fab04826e3193c9b5c1935748d7f5693ee677cecb487b4ccba2b654ab", + "support_sha256": "0f9ef8ea93328656d977105805313b4af6a73c1f0d7dd7678309f530c7cb27f7" + }, + { + "index": 506, + "required_count": 4, + "support_count": 21, + "height": 5, + "required_sha256": "4331266ae672db478dd8ded360fbe37436eb26afcade46835e7061cb305624f4", + "support_sha256": "77ced30f5849520d4ce4621aeb4a586848f453b886e7c845425db0bece860959" + }, + { + "index": 507, + "required_count": 3, + "support_count": 27, + "height": 7, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "1e0963657cfefa3987bef00d5569b343eea8564f6b238c0926b4b04c0f6785b3" + }, + { + "index": 508, + "required_count": 2, + "support_count": 39, + "height": 10, + "required_sha256": "4d02160efc55a57063a792b0f3f6dbd35005b53f7f11370e6dbfd6d607cbe16c", + "support_sha256": "0f0db0b1354c2a029c7aeb5d6fec26a5a03db1c91e63a0ec8a82e66815f28f5d" + }, + { + "index": 509, + "required_count": 3, + "support_count": 35, + "height": 10, + "required_sha256": "e671f7e38123310ae91ad10abbc900d7cf305d1301795a38237480d1b54d7428", + "support_sha256": "74ea7434a9218988c7c62c7c96df147ab3290c22ff055e360014b2f47935d593" + }, + { + "index": 510, + "required_count": 3, + "support_count": 32, + "height": 8, + "required_sha256": "df699b95325119253cda671365c40b728f018d740050f14f858efdef704b57ad", + "support_sha256": "6a496b13ce715e24251e9aeb2b126cf60fe7c09ecbe3f9e107edf9e4d3fc8f4f" + }, + { + "index": 511, + "required_count": 6, + "support_count": 27, + "height": 7, + "required_sha256": "08b4d08c2949b3a981fe00a8a20da8932435c208c7bf9e0ab913fbc268213917", + "support_sha256": "6b6e84e246d3c7a0012907cc5f59d6df41f3499c63990b79dc38d174f036f50d" + }, + { + "index": 512, + "required_count": 4, + "support_count": 37, + "height": 9, + "required_sha256": "4d0144e5afaf071a5a58219a6fd1daf8b4793b46c179e74e7d26cffae4efd882", + "support_sha256": "a504e418929ac3bfc6745292fc9795d69730453610edf3d6ab2b498397113a17" + }, + { + "index": 513, + "required_count": 6, + "support_count": 26, + "height": 8, + "required_sha256": "1853057b62b65a78f253cad14a3216ff8d93a82aa2611c2cc81a92270b842241", + "support_sha256": "4c018227dd53cdaa2ba22c682ab4466231c5867923b9774a5187fa55ad7b5097" + }, + { + "index": 514, + "required_count": 5, + "support_count": 28, + "height": 9, + "required_sha256": "3d9d75e8b337204fbae24b97aedd5f1b88719d54e109c09f0d16659743ff9983", + "support_sha256": "23b70ffe2fa20627293876bbb02fc936e5f147f448cc968e0c8775c39176f30e" + }, + { + "index": 515, + "required_count": 6, + "support_count": 15, + "height": 5, + "required_sha256": "8cd3c8e41a8f8877605853946269f6f8643ae0802eb5975dfca007f36d5ef53f", + "support_sha256": "a15d40b3eb80b2deeb3af56201bbe8cdbfb541ff2423e64ccf4b5cb70990e73e" + }, + { + "index": 516, + "required_count": 7, + "support_count": 21, + "height": 6, + "required_sha256": "c0c31d7483504823fc8f126cd0b2bbd6c463ee2462dbd360aa182da292909c4c", + "support_sha256": "c09775fb4333329d60b80f4528eea9ff642c391545ee4b3c2c47fe0e6b0b7484" + }, + { + "index": 517, + "required_count": 4, + "support_count": 40, + "height": 11, + "required_sha256": "4d0144e5afaf071a5a58219a6fd1daf8b4793b46c179e74e7d26cffae4efd882", + "support_sha256": "e416712cabdb722736b0731de6812bc1a833999d142b971270e8ffbf6f9b2cb6" + }, + { + "index": 518, + "required_count": 3, + "support_count": 26, + "height": 8, + "required_sha256": "8344b435aa51d4bdf964d86b9e56da16b21552e671a1e58b6eb9ea454536a574", + "support_sha256": "d7ca58153f91a010f1bcca698c2744bce7d33e5d791fce710947f8ec8f6ba658" + }, + { + "index": 519, + "required_count": 3, + "support_count": 33, + "height": 9, + "required_sha256": "577eba75e7a3ce41c1a85dfcd9f02b357ee5e3c9a90dd42d8680d97337b47fb3", + "support_sha256": "264bbf4b21b978ecfa5ba29e248076eb17232911eeaee92fc5ca18c46af7451a" + }, + { + "index": 520, + "required_count": 3, + "support_count": 46, + "height": 10, + "required_sha256": "1a25075d02a4c7aeb639190bf0db3fe25cc6cd3227d1b066e11129fe13396686", + "support_sha256": "c80437a9fb51a11c34fbaa61d1dc9913d225e78f9794e560514d83cc6786dbca" + }, + { + "index": 521, + "required_count": 5, + "support_count": 20, + "height": 6, + "required_sha256": "448be2c890a6d5f5512fb00a9b50890cd1c73789786ece1da7d5b7a05b32fbbc", + "support_sha256": "6730850da028932845819d275cffe5011333239d988cadeb81dcb6a5233e9808" + }, + { + "index": 522, + "required_count": 4, + "support_count": 21, + "height": 7, + "required_sha256": "546363565cce2e7634244b94cd5ab900de698d0a535022770cee06dbffa541c8", + "support_sha256": "7c4e3a02ec6ae3fe5c6a78eb2a1ffc3e738425f181d5c9ee11fca7e7b4762685" + }, + { + "index": 523, + "required_count": 3, + "support_count": 31, + "height": 8, + "required_sha256": "380a09ce41d014362316e24343724794a95b727e6ed9cfaba44e1538509480ea", + "support_sha256": "a90ec065d3473c7e517c82ea30ba6cf25555fe0166d9502920b82a3b6c929955" + }, + { + "index": 524, + "required_count": 3, + "support_count": 31, + "height": 8, + "required_sha256": "380a09ce41d014362316e24343724794a95b727e6ed9cfaba44e1538509480ea", + "support_sha256": "ff9757a1fe4d6f6bf6587fd53737409de1b89450c68b79653f5bdcdff544045f" + }, + { + "index": 525, + "required_count": 6, + "support_count": 20, + "height": 6, + "required_sha256": "494bc5176a27b181c7b7aa06d58e94cb19a9ad9ea6dc2724366fafdee685a0a0", + "support_sha256": "78ec8f41f15fb9f622ff431a9b4ac1b1726f31cc70f1a446bac664e2aad14d93" + }, + { + "index": 526, + "required_count": 5, + "support_count": 21, + "height": 7, + "required_sha256": "0cc13e65843afcd5d613549a6c04eb296a0b9c32d6514c9febe5c323e5a32aec", + "support_sha256": "8dd4130af69f9ac4cd07eae072d9015b63984275e350a95df1ae0bb0703c48ad" + }, + { + "index": 527, + "required_count": 4, + "support_count": 40, + "height": 11, + "required_sha256": "4d0144e5afaf071a5a58219a6fd1daf8b4793b46c179e74e7d26cffae4efd882", + "support_sha256": "99fb02951fdb9f22bb2ea502b2c77e68f719179a20bcb2297956ace5c51ebc89" + }, + { + "index": 528, + "required_count": 4, + "support_count": 33, + "height": 9, + "required_sha256": "f66aab8ebb551647eb8001b398e4fd4a28d17a5ac7fedf58575b47a16e8a0e7e", + "support_sha256": "78dc167be8ce6ab2d84f52cf61d9ed6f42446c832b43ad76c521789909212ff1" + }, + { + "index": 529, + "required_count": 6, + "support_count": 57, + "height": 10, + "required_sha256": "2099e9afc76893cdf26756b79914e7eb2d20fe2703a09d0b45632a057a557768", + "support_sha256": "eaf8ced937360240b53e66eb0319cfa4803089e28f8fb30dc47f1253629b9297" + }, + { + "index": 530, + "required_count": 4, + "support_count": 30, + "height": 8, + "required_sha256": "9667aa210e42cb0c8f8cbe62c7a022848e034011ab0b352b90d0593208bdd9df", + "support_sha256": "d549ab7649f47eb53e90a0a73c6c1dbd3291999206cb124504d832cc83c37d4f" + }, + { + "index": 531, + "required_count": 5, + "support_count": 33, + "height": 9, + "required_sha256": "b76995557e894849747b2b7da2c956fbd48bda23fd8035738ce98b555fc6c73e", + "support_sha256": "b7d2a75d740c8b7a499575da55410cbdc6decf9d4833ec356394415f718e54a9" + }, + { + "index": 532, + "required_count": 3, + "support_count": 37, + "height": 8, + "required_sha256": "7335db764d217f20be13fdc9522570c91e35fd3c36070706e21bb4d80f4daa7f", + "support_sha256": "29f0251e462b78751072872ca9e596d1af21d79d6bf91b572d4025f177fdc1c4" + }, + { + "index": 533, + "required_count": 4, + "support_count": 23, + "height": 8, + "required_sha256": "90998fcc5fe84883cabb8175e84bfaa46aeab0028c08ff3c179790d993d6aaf0", + "support_sha256": "79dc39d191851dcc749ef4e26fe443ae775056ad1303634701de8e97c86c514a" + }, + { + "index": 534, + "required_count": 4, + "support_count": 25, + "height": 8, + "required_sha256": "9cc34ecb5f7b3c93c341bf32d6366373193a470ad293bb87bc5164e9c9589eb0", + "support_sha256": "867c9d78d61e9474b065db844089ed690cc7f0a8936ad784b3e4a0d80185ca48" + }, + { + "index": 535, + "required_count": 3, + "support_count": 49, + "height": 10, + "required_sha256": "4e4df199fe0d2123ea3c5b6eaa132ae0e3ab26f43c4e58074ee8e51781c2a2ef", + "support_sha256": "d5a929f077a890ecab2bb841551e8e087b934e7b19d814af541b8fc9461b1ead" + }, + { + "index": 536, + "required_count": 3, + "support_count": 33, + "height": 9, + "required_sha256": "65207983091c637f5bde647f84cf755b89d2a7d5bbb9001c8cf082df57c1b809", + "support_sha256": "77fb37e10d32bc593e31e099f22a0a15b52df2b8e4662b7904e4533866789e51" + }, + { + "index": 537, + "required_count": 4, + "support_count": 35, + "height": 9, + "required_sha256": "4d0144e5afaf071a5a58219a6fd1daf8b4793b46c179e74e7d26cffae4efd882", + "support_sha256": "1a6f6b0660d9193a42c59f6166e7c130e6eb5cb6772c711c6bd7008a4b81c4c4" + }, + { + "index": 538, + "required_count": 6, + "support_count": 74, + "height": 13, + "required_sha256": "2db4431bb13df0bedb8e30257398aa114a417396bd26e5761280078f8e20a417", + "support_sha256": "18e279be6877c1e065704166ddea9a29c62a1378c3227595966b804b8e29539d" + }, + { + "index": 539, + "required_count": 10, + "support_count": 32, + "height": 9, + "required_sha256": "1ae73207cd9f94caa0d3a21aab0f78db4414850ec04d3364a34df0f09e22e062", + "support_sha256": "b9aa77ea28072fa1d1b21e1c1f09d2d28c4d91e27576cf816c61fc612a9b0e16" + }, + { + "index": 540, + "required_count": 9, + "support_count": 44, + "height": 10, + "required_sha256": "6c92f50859dcbbfaf0f6935533eda9d333e21d50581315cd0ff2672c6ab8c722", + "support_sha256": "23becc1739798e2815b48a8a101d03ed757ed1f18a937a9471cb92e02af68e66" + }, + { + "index": 541, + "required_count": 9, + "support_count": 35, + "height": 10, + "required_sha256": "05d1047ad6fdf43cb62921dc3cd740b51eab9ef3193160e1227159e610dec850", + "support_sha256": "e18545c06f4cb0b969eefda44cb946f600ba3a8a753f7b13aea21d1bbb0f7920" + }, + { + "index": 542, + "required_count": 8, + "support_count": 23, + "height": 7, + "required_sha256": "133b8fb6dd9ead337180f2a336a95dc69038cd79efb6d4a8817420dba780328d", + "support_sha256": "a79bc2515c6708ab5e68f3255b5d2d69d8d574e83a1eb16643626d8031306be1" + }, + { + "index": 543, + "required_count": 7, + "support_count": 55, + "height": 12, + "required_sha256": "6e7b40f21ee829df9bc27475729e89933aa8254ac1f20c8367f496a34b8b1897", + "support_sha256": "95b5fa0489869c55eb40bc0a143c27d42262e83c5bb939b6ce9756bec9243a31" + }, + { + "index": 544, + "required_count": 4, + "support_count": 25, + "height": 6, + "required_sha256": "f2e425377151ba76f91ff782de634b5a2494b6cce03bd45ed2d84e905b21ab2e", + "support_sha256": "f2a9e8b896a4ee1a3df4d0a4cb91426cfc9b6624af9fcbd84c80e9b8a71e5138" + }, + { + "index": 545, + "required_count": 3, + "support_count": 36, + "height": 10, + "required_sha256": "5965c8db29612288ae2d859c3330f507e568d7da32ec96eea65e0ec857b9de3c", + "support_sha256": "c5f5ade53265bb8039cea62f6e48c56be66f93a43dd0a94be2a74e5e840e0799" + }, + { + "index": 546, + "required_count": 3, + "support_count": 35, + "height": 10, + "required_sha256": "9d05e4198c742ebee555d606cbb55096e3da381f76ec885432222bcc0c69d523", + "support_sha256": "f802bfc2e2476f6e9c25b6b39361837cfde3d21c276db575c03ce79c5162488f" + }, + { + "index": 547, + "required_count": 4, + "support_count": 30, + "height": 8, + "required_sha256": "a3e37453804c3de57e436893dec8a9f89e0b6b797cbb928e8f966f4a787f14bf", + "support_sha256": "ce8b6e3cbb19b6198e1a6b39fbdc3fda16f706480b96c5a1600e658ab7b5aeda" + }, + { + "index": 548, + "required_count": 3, + "support_count": 39, + "height": 9, + "required_sha256": "9c6ce15ffe218ed543b08515bcc88d0aad47e87e9044a9a2060297fc75951634", + "support_sha256": "2d2770f500fddde5cb0c6f5e607cf99684faefaa1d4d06d9082ffa72550fbd73" + }, + { + "index": 549, + "required_count": 4, + "support_count": 37, + "height": 9, + "required_sha256": "cf078c96f3ff9ad3c1d07a743a2bc566ea6fd5702e1240f8c8e39c0c007fc686", + "support_sha256": "808ff4c4103846db341a76ccdcb37a1b0159c6b9913576a8387497f2cc3b715b" + }, + { + "index": 550, + "required_count": 3, + "support_count": 54, + "height": 11, + "required_sha256": "e1ec4c22ab83345c02c731799b1fcb5cfa0fa5cbf1fc4436f39ca6ae55c59379", + "support_sha256": "dbb2f872c3b219028ce8813d37f7121fa9e6fbbd0fc62f45af4806c9847a7880" + }, + { + "index": 551, + "required_count": 6, + "support_count": 47, + "height": 12, + "required_sha256": "dc011b87202e1b2901b7c293c3c372c081d3f28c4b7218ab2428b77b5af7cfef", + "support_sha256": "e01b7a934b22b943b22ec64ef65b55b20faea7de608f7874587856e31aae686c" + }, + { + "index": 552, + "required_count": 6, + "support_count": 85, + "height": 13, + "required_sha256": "1de5bf531bb443f05a8c4391556faf5fe59ed80a858734da9a9b1d8ec78b458c", + "support_sha256": "ae02f08841e6c6a0c1208e8f8132854b20f1a7928180b6c099f1917186b3c23c" + }, + { + "index": 553, + "required_count": 5, + "support_count": 102, + "height": 14, + "required_sha256": "fb149cc6d993aa9704b8ad595f1e61da403322948b3ce1b593d236183bb47fb4", + "support_sha256": "364d30d3c6687ce466a9464b3b79b1bcf3ab347cb2fd9d3d8aa8e008c39b3bdd" + }, + { + "index": 554, + "required_count": 6, + "support_count": 19, + "height": 7, + "required_sha256": "39ab9a5fefe1be94796a0a9f49c8e553ea1955df8a429f87df799967270d76a9", + "support_sha256": "7634f6c966eff8899b27dfce9e4c7c456be49124bb0b52d3f856691a0448de93" + }, + { + "index": 555, + "required_count": 4, + "support_count": 41, + "height": 13, + "required_sha256": "3ec3b17873a7047276e969e8b585fe8fa723080662807a61eb1175facd526b14", + "support_sha256": "58048c883e8463579a55d1f6a186d4aa46d5cfa8605199bbb12bcda0642ab80c" + }, + { + "index": 556, + "required_count": 4, + "support_count": 40, + "height": 10, + "required_sha256": "16b0d2b93dbca4e23f724a8afefc221010c23f2f1f3a5eb97e5e482357870a77", + "support_sha256": "a756bf640d1e605468f1bddb8c7c4bb94721cc2644185599ce55f47ef8c91c33" + }, + { + "index": 557, + "required_count": 5, + "support_count": 64, + "height": 14, + "required_sha256": "197f3eaf6a43e530e24ca5bccbda39b2fdb6d4b72f4b081ab65798e672fdee8c", + "support_sha256": "b7b5ff8b735b646fe4d6ccb52040121305e99918f7bdefe27c17e6c829abfeee" + }, + { + "index": 558, + "required_count": 4, + "support_count": 23, + "height": 8, + "required_sha256": "ae3ee26381a923e07dad2f67f29fe98b650527a0661257b5e5db8ca3bd23962f", + "support_sha256": "9cbd75795cb7f188fd151e2ebb31203a312036afab0c178eba92d30d8a97bdf7" + }, + { + "index": 559, + "required_count": 7, + "support_count": 32, + "height": 8, + "required_sha256": "df70b0029ed5f3fdcfa844aae286d6b573d71433fef07da5caad1d58868b4cb7", + "support_sha256": "2ec75aa17f42c083afd8978675882211b32280da2739c16148bfaa2c2b147994" + }, + { + "index": 560, + "required_count": 6, + "support_count": 52, + "height": 10, + "required_sha256": "a04c679f2e67c94db42706eec2c2fe3c39cedeedc1e87ff3119424e4c79e115b", + "support_sha256": "639bb4541a46806b70f32ac1e042383285ba83edf499bce34fdceae9b1527bf5" + }, + { + "index": 561, + "required_count": 5, + "support_count": 34, + "height": 9, + "required_sha256": "6455ee5527e84ff6e761beee0ea980e08ac484072ffad0f798445ebde11d0a83", + "support_sha256": "c098b0425d7f8cfcae847e54513290b0ec631f1710a760b90a0960776dda06cd" + }, + { + "index": 562, + "required_count": 3, + "support_count": 32, + "height": 9, + "required_sha256": "06c7eb7c54b5dbc9eebe7161e1cfa73c8188aab37577aabff0270362dffe0530", + "support_sha256": "59975fc661b7d106d0543311fdc5759a8c927c7754a6441ef0a0967fe613fced" + }, + { + "index": 563, + "required_count": 4, + "support_count": 47, + "height": 10, + "required_sha256": "93d8cd161f7f26cb3b3b2cec2d7f27a1a457e013e68bba9df12091b2b12b8057", + "support_sha256": "36f89acea38b7845a2264fe07200c0cec6c303ec5df5e4a995c9c05f7c79780c" + }, + { + "index": 564, + "required_count": 5, + "support_count": 70, + "height": 13, + "required_sha256": "334da6cbbaeb36c110edfd8774b5ae9986fd43983f3598b5b15b6247b07c35d1", + "support_sha256": "f13784a977fa02612a73edc6601f673cba097fab8d5b6fba1d8b9713b86f8d2a" + }, + { + "index": 565, + "required_count": 3, + "support_count": 21, + "height": 7, + "required_sha256": "90d6958def63879298dde9490fac2a435e8851c90daf3e0e9a067b3173fbfc15", + "support_sha256": "c004db06039cc82b990d36bbad20260555ef651198014a227ff9dce5e4dfbc5b" + }, + { + "index": 566, + "required_count": 2, + "support_count": 40, + "height": 8, + "required_sha256": "61d1ae33e86588c85dbdef4beef4fb07795d1246b22f2dbbd12c2bd626e6b255", + "support_sha256": "d0db0672a8146e13f3d03365419a254bc9cdfb2bb2d19ddc7295ee9410477659" + }, + { + "index": 567, + "required_count": 5, + "support_count": 59, + "height": 11, + "required_sha256": "7f072f2ad66a46c4a8da2b8010949d7b9a6271db04cb2072739c65a0febee3a1", + "support_sha256": "c4dd48ceab057e2497cc8b34c5f5d967f1e6b43c5a85beec98a271b27e602f47" + }, + { + "index": 568, + "required_count": 5, + "support_count": 75, + "height": 13, + "required_sha256": "334da6cbbaeb36c110edfd8774b5ae9986fd43983f3598b5b15b6247b07c35d1", + "support_sha256": "3e57d332757f7307169d0ca27f04d40badd6c0f5cced61cc251cced9b770499d" + }, + { + "index": 569, + "required_count": 6, + "support_count": 45, + "height": 10, + "required_sha256": "53db042f7ee64537508c348ad48759b5d7eacf9363ff9935e2e4fe430bd33bca", + "support_sha256": "503245931ae8ccb9f5e5ea892a7324809ded68ed50046cf7c12442040b9f054b" + }, + { + "index": 570, + "required_count": 6, + "support_count": 39, + "height": 9, + "required_sha256": "376102b5a73f9a3bffab064769f6254dada9aca22acf459ca45f73306224d0cf", + "support_sha256": "4db294a1631447c1e5f9c84108e2db049469f41bb7e28f1e348451d3354d78ea" + }, + { + "index": 571, + "required_count": 5, + "support_count": 49, + "height": 12, + "required_sha256": "c3fcf553dc90b6b3cc3076887a78d54b1774130ab96b7480018c944e94e3e886", + "support_sha256": "54441309a9bc8384177d923a7cbdc4802241ca94c0f398d026e0b96dc6305790" + }, + { + "index": 572, + "required_count": 6, + "support_count": 53, + "height": 13, + "required_sha256": "38bd7906bd7a11c5f4ed63e432452fcb95675baf6dfdb659076e137453de26a1", + "support_sha256": "e71e85dc8aa9507789875e3935ca781b56644ae8aa61820b12249907f9572363" + }, + { + "index": 573, + "required_count": 5, + "support_count": 71, + "height": 15, + "required_sha256": "557bdef6de01a7257d0dc19b692132b250e965002a3e21ab69bd2983ce05dc7d", + "support_sha256": "89987c6a8cc673f6fd315b356f29f6e5b9a4d931f30ebad0d345ea726dfde8e4" + }, + { + "index": 574, + "required_count": 5, + "support_count": 48, + "height": 9, + "required_sha256": "abe4406c3ed7cfbd9e1d149a31e169fff097d2fa4a48fb918338b7409e8d7aeb", + "support_sha256": "00f281148bb0f90ece66f40f297c353763716ece7c3b4d48469bcbad6bfed404" + }, + { + "index": 575, + "required_count": 6, + "support_count": 50, + "height": 10, + "required_sha256": "94a1f7f53fd21cd7b2274566cddc3aaef0adc1bd886823d27dea72be02419f51", + "support_sha256": "12444cf582b3d30b38be2a9d71de841b46e3dad147c415fd31b04ef57e9a0a4c" + }, + { + "index": 576, + "required_count": 7, + "support_count": 28, + "height": 7, + "required_sha256": "f8f61bcab9c4d80316d123782fe6d45d96c85a01599ad085e44c54ca5bcc98ed", + "support_sha256": "24338ce0dff9708cba10c41ab0c0809f94e1f2b0123dec0531d9f622fb77571c" + }, + { + "index": 577, + "required_count": 4, + "support_count": 25, + "height": 9, + "required_sha256": "8c857eb5533d8d09ba6fbc6a775b49f709bc47b059a47dd3b06efcdfc74afca3", + "support_sha256": "04e96a5007a8b854fc6867af2d115f44658415b7105a151b69fad1e7df8508da" + }, + { + "index": 578, + "required_count": 3, + "support_count": 34, + "height": 10, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "fb7dfe7586d59644886effa6c72ddd1b76b31c4faa15e5f3f4647d7b01d38633" + }, + { + "index": 579, + "required_count": 2, + "support_count": 50, + "height": 11, + "required_sha256": "ffcfcf71d3737d8c3125c8ec66c904e45dfe094c62fa8ec663daf59387c68fb7", + "support_sha256": "46667696af7aacc6a4c839304322518b0b09dfe2d65182302c5f13751f474787" + }, + { + "index": 580, + "required_count": 4, + "support_count": 32, + "height": 10, + "required_sha256": "d8a9a68b4c07caa72ee0a278a71d78f924646475ad632ec15106b2f23b2479f8", + "support_sha256": "98eba017e026ae04daa14bebaf5d6f76471d3ccb4ee2af06fc79c3b38ff25868" + }, + { + "index": 581, + "required_count": 2, + "support_count": 57, + "height": 11, + "required_sha256": "f00279a59f15005436fc15538cc554e93468ea50fe531e292c63a8e96829d91c", + "support_sha256": "772805b6cd800cfa15619766cd47cdb23e962cbc4ffdff821591167b90d8a0a8" + }, + { + "index": 582, + "required_count": 6, + "support_count": 61, + "height": 14, + "required_sha256": "883d322901a725c5744a7357b5c9aa7c6c9b7dc32522aa0851b5353d83219fbf", + "support_sha256": "0d5d7f6656fe3127b51cb6091f5d823d64c361472eb4b02aff25829834244f46" + }, + { + "index": 583, + "required_count": 5, + "support_count": 102, + "height": 15, + "required_sha256": "0245ef70bf6b5c92c461482143be4a5c46a7dd7eae725a048a0d0900b4beb4a5", + "support_sha256": "41939b1ed91e026fe3e2e814fbd1d77a2dd22761855bf37ab59d35a66779469a" + }, + { + "index": 584, + "required_count": 6, + "support_count": 29, + "height": 9, + "required_sha256": "23b6b1d9a4b58ae14c37bc9d2b281cf6aa774ed7c9f7d06bafe7ec25c1079e95", + "support_sha256": "8ba1972427bee1707fcdb234b16e64a8cc8997159133e6e2d17a46011cf46bb4" + }, + { + "index": 585, + "required_count": 4, + "support_count": 25, + "height": 10, + "required_sha256": "8c857eb5533d8d09ba6fbc6a775b49f709bc47b059a47dd3b06efcdfc74afca3", + "support_sha256": "75b8a98361b087ab3e397d9ad770d334efa4583e528dca643757d675008b4325" + }, + { + "index": 586, + "required_count": 3, + "support_count": 28, + "height": 11, + "required_sha256": "ac0de9c14e79556f69d7d334af1f188b57fd6cd82ad4b12776f599a2f5137e3e", + "support_sha256": "91571086568727e3d9133b8f170faff337d12fa42fdc13f75b0f972bf05f5bb1" + }, + { + "index": 587, + "required_count": 2, + "support_count": 35, + "height": 12, + "required_sha256": "9cbf98a4cc84ee1509ba134f32d86a08b41395eed05c6eebc85fe56e9b5dfc8f", + "support_sha256": "8d2cdaab53a9bd5d0297644458204b9200c58d1f38850724342bff4bcb3390dc" + }, + { + "index": 588, + "required_count": 5, + "support_count": 33, + "height": 12, + "required_sha256": "8a81f01d618341ffe75dc0a2052a925215a4aa670637036bfcd13ed7a3c574e6", + "support_sha256": "2ea1bf637854c2ff2a87933715f09f32b17fd1be3d95083cd64e3042b704b0ca" + }, + { + "index": 589, + "required_count": 3, + "support_count": 28, + "height": 11, + "required_sha256": "ac0de9c14e79556f69d7d334af1f188b57fd6cd82ad4b12776f599a2f5137e3e", + "support_sha256": "aa18741bb00214c6bf8a944a8cf1aba874c374bdbce69ad4fcf37019cc8cc9fb" + }, + { + "index": 590, + "required_count": 5, + "support_count": 39, + "height": 13, + "required_sha256": "3d9d75e8b337204fbae24b97aedd5f1b88719d54e109c09f0d16659743ff9983", + "support_sha256": "9f0691c2d55e09d64a748cbcde8967532ff548384c7abac9a05c53a3ccb40966" + }, + { + "index": 591, + "required_count": 6, + "support_count": 49, + "height": 13, + "required_sha256": "c2b96514e8e599797a20058df4126314a0255a54c8817c6e31710f2e9dd06eee", + "support_sha256": "29fe8dbd1ffb9ceaa033595fb2e8bc8d289a078a7fcb7c4038989cb92f3fe232" + }, + { + "index": 592, + "required_count": 5, + "support_count": 16, + "height": 5, + "required_sha256": "7cd8fba75998ec962d8e84d072652c5b46551b8a23e897ffbd005025d9af768c", + "support_sha256": "4a478511adc4cc9b0b2c424a1d9095c7ae706201715df5b3664ae407cb04e5fd" + }, + { + "index": 593, + "required_count": 5, + "support_count": 20, + "height": 7, + "required_sha256": "c0ac6e0c067bcc50d65feefaa9d60f30753a8d2fe151e6c35bc260df3c03c87c", + "support_sha256": "b99a4da2e7c1a2db8f4b74091004940910f6c9925012972497383e6e59b510ff" + }, + { + "index": 594, + "required_count": 6, + "support_count": 49, + "height": 10, + "required_sha256": "ea1dcb35b3a442126c374a86eeba3419dc04d06fdddc7821d08cc98d69da7230", + "support_sha256": "f7c85d195ea1b35d17bbb632d50bd52d40c1b410ec1a1f4f830be5347b09b7f7" + }, + { + "index": 595, + "required_count": 8, + "support_count": 27, + "height": 9, + "required_sha256": "aeea1cb7796e8084a644ebd4ebeca8a003f78c02028924ad5bc7da96e75ff1cd", + "support_sha256": "c53234d8e2c51da47aef7991b42f86a6d4e9c6f038544a49d6b9254627640175" + }, + { + "index": 596, + "required_count": 7, + "support_count": 37, + "height": 11, + "required_sha256": "81f577d3a06b6d623c3e36c28c953fa68595a5235a65622a2d433fdf0c615066", + "support_sha256": "442bed20f39358e77010a88d5b9d32145a1a0bcbfb490c3f753bc25c65061446" + }, + { + "index": 597, + "required_count": 6, + "support_count": 54, + "height": 13, + "required_sha256": "27ed1b7559ca3de61aceb188736c57939655df87b1d2e8a1cfcbebda38d0fb4e", + "support_sha256": "935baa63cb3760563be56b91b9b292d154a6659feb0d50a96a388e3033a7079f" + }, + { + "index": 598, + "required_count": 5, + "support_count": 79, + "height": 14, + "required_sha256": "fd8df58c987a0f9d0bc0b69e52f25eb38f7a4010f4cb7a936d9487222eb1f6df", + "support_sha256": "516497f2b6dfa745c850480cceddcfc04589efad1052b816b234f2559b64c25a" + }, + { + "index": 599, + "required_count": 5, + "support_count": 51, + "height": 12, + "required_sha256": "992e206fa52060cc011fcbc547040c5a738a4027f5438eeb089e766642807bea", + "support_sha256": "4e3ea391d06a63185a6d72f7e1f0d504b2118ee2e733eb51c965c5ce78623078" + }, + { + "index": 600, + "required_count": 4, + "support_count": 21, + "height": 6, + "required_sha256": "fa45969a6425d1be686b00a0bedfbd754e2e5d14b070f836a5d1bfd6601e6e21", + "support_sha256": "fe621681ec9782c59031eb55a61774de6ddd086d1c73c9c78c4eac5982bd802c" + }, + { + "index": 601, + "required_count": 7, + "support_count": 44, + "height": 11, + "required_sha256": "365f7d048abf3eab71ed54c2e5864a50d18eba71709b5ca58a0bf7228252edf2", + "support_sha256": "7d80ccc493bd6673a8833da9630635469d3b913ba9363039ca0eb68ab3c51e5b" + }, + { + "index": 602, + "required_count": 4, + "support_count": 126, + "height": 16, + "required_sha256": "8d6ba9795e2fced937e94e1726bbd4d3cf2e41dcb04e042d23abf594a03026f1", + "support_sha256": "65b854133632de58c96002dcf50d6643b782cedd80d253926ee9480afd2d66ee" + }, + { + "index": 603, + "required_count": 2, + "support_count": 44, + "height": 13, + "required_sha256": "09665a01b5c57a8c2a4e7e39244935870ca4ba3fe9ae3c43f158ec14b44e09d0", + "support_sha256": "781423f87e1c547597eb65ef0ca2f366270dcf502593725b80dbab776235129d" + }, + { + "index": 604, + "required_count": 4, + "support_count": 24, + "height": 8, + "required_sha256": "d44500532a29af7be6fccb33d49559834fe0a107e0a52f116936dd28b0a1e129", + "support_sha256": "d45aa7d7ccdf2ed64b97bf15ff4a1a2b65d4b805e0ddc5f5c58ee108c4f9ca2d" + }, + { + "index": 605, + "required_count": 2, + "support_count": 47, + "height": 12, + "required_sha256": "4d02160efc55a57063a792b0f3f6dbd35005b53f7f11370e6dbfd6d607cbe16c", + "support_sha256": "83e2b99f2e09f11c0955b4c6a517ad9bae7e471594d3028a5fecb585b9eb6122" + }, + { + "index": 606, + "required_count": 5, + "support_count": 22, + "height": 6, + "required_sha256": "2566046bbe2d7a652ec7ebd33ddd06510ed08ab824a47eef8c4b561a3c12640d", + "support_sha256": "84a795176dfa2d43a55864e630b762c996513ea10c89ddd19d64340c43b32857" + }, + { + "index": 607, + "required_count": 4, + "support_count": 45, + "height": 8, + "required_sha256": "4f96f7755761ea77a2400bf937065b761d53e87fca3d71e53a5992049ec643fb", + "support_sha256": "e0718b23d7d36739dd4ea6b51e829fe0b096f6cb12e1f4152ddeb196e9abc299" + }, + { + "index": 608, + "required_count": 4, + "support_count": 51, + "height": 10, + "required_sha256": "4f96f7755761ea77a2400bf937065b761d53e87fca3d71e53a5992049ec643fb", + "support_sha256": "0909e5a27132e393d212b5cdbd26bc5de13721020c01d4323fac5648d281677c" + }, + { + "index": 609, + "required_count": 6, + "support_count": 25, + "height": 6, + "required_sha256": "3b2daba79184bc0730fc750ff0ca5909516db81335bedcba901a20abf4de269b", + "support_sha256": "15a198ac6c89d619f9d91005293a2cac2165355fe42e7cb209dc2fa1627e0bc8" + }, + { + "index": 610, + "required_count": 5, + "support_count": 35, + "height": 7, + "required_sha256": "2566046bbe2d7a652ec7ebd33ddd06510ed08ab824a47eef8c4b561a3c12640d", + "support_sha256": "4033fe287fee1b8f6a6106b955b9d6f7176c8e429e1f16b7c8f48b3d67338e47" + }, + { + "index": 611, + "required_count": 3, + "support_count": 27, + "height": 6, + "required_sha256": "81f5c251e8f0a22e7ff66bcf54a447f803e8a005494c9bed19ab5e7d883b3a46", + "support_sha256": "c4d74b13a1277c449b70cc7788be325528929dbe0beb96dd15451fb7316899a7" + }, + { + "index": 612, + "required_count": 4, + "support_count": 16, + "height": 5, + "required_sha256": "5e0cf10436e02bdc702385bcd0daacbff29ed7299420d96e0ab6b4527fcbf636", + "support_sha256": "4b015cbcb5768e3867253f8164f899d66020e8921c1c0c94f88846d0fe4c43d7" + }, + { + "index": 613, + "required_count": 3, + "support_count": 43, + "height": 11, + "required_sha256": "cac874bdba56f356c7cd7e2e328671763a1c9cb56d7e0d5cee86157c8b3bd477", + "support_sha256": "7aeda16a808f41f2c129d5075d741bdcb5b9c8aa1ba000cba10457326b835798" + }, + { + "index": 614, + "required_count": 5, + "support_count": 42, + "height": 9, + "required_sha256": "f55ce41c823a1a7173ca490da44317023f0694c5abce7d9bd8f9645ddbd66828", + "support_sha256": "8e5c9f04cd350ff80724aca44f8285dacd7297255fa535a2ba6c3484dda3aa15" + }, + { + "index": 615, + "required_count": 5, + "support_count": 56, + "height": 11, + "required_sha256": "e8f429e4dbb46ce4d657416304004bd67dc8ffe4e3f4b677252d7caaf747b32f", + "support_sha256": "dedcdc169949f831ad1b680be251e8b814ecccf9e1c2a6c05f88ee794a32de12" + }, + { + "index": 616, + "required_count": 4, + "support_count": 36, + "height": 10, + "required_sha256": "2011bd190c4c6f0361c80297e606eaddd2d49e00673617dcb9c04cc6bac9092b", + "support_sha256": "dde0c5ebbff614727a5a9033007c84de2d206ac5968d052e9235af7ab3e1d414" + }, + { + "index": 617, + "required_count": 3, + "support_count": 49, + "height": 11, + "required_sha256": "991bffc2cc4b1ae7f677c990bff649cb6e3f93c84324919eebf71bb4d78ca942", + "support_sha256": "5e5fd74941582513fd9836d33eb0bef84d4952f1c6c4d4fd268eb2753c8bb118" + }, + { + "index": 618, + "required_count": 4, + "support_count": 71, + "height": 12, + "required_sha256": "4c876db4e6b34a7b7f1db538f31a2d826fb30cffd2c2a92ed53764751c90c3e6", + "support_sha256": "9bf7c52753412369b4827a7529268a9e3698ac4ab303a7c5b3704033c037b2c9" + }, + { + "index": 619, + "required_count": 3, + "support_count": 39, + "height": 8, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "5a9186d8a010e2313f4f2b510c3959f40b169f5c23db3bb785645ec708b62329" + }, + { + "index": 620, + "required_count": 3, + "support_count": 32, + "height": 7, + "required_sha256": "0b30f93277f4ddf4404eb07c9ad6652608ba11b77f8af79879eac7fba8b29b4b", + "support_sha256": "8c9be6316cb639d73e612549259f178e95af50165797e89f051a1e815c91f6dc" + }, + { + "index": 621, + "required_count": 4, + "support_count": 27, + "height": 7, + "required_sha256": "3c995e184ae2f4ad90ad945163f24b28fdfb05ff2a583444b8f6b37924aa4da6", + "support_sha256": "082c4a846d7fe370a56975cd651c1c1d7831bf6e12555726cb96093724d885d0" + }, + { + "index": 622, + "required_count": 3, + "support_count": 45, + "height": 9, + "required_sha256": "8344b435aa51d4bdf964d86b9e56da16b21552e671a1e58b6eb9ea454536a574", + "support_sha256": "ce95cac1f7038fddff26ac2c760ef79e272bd5781a06d50953df9ab5976bc8b8" + }, + { + "index": 623, + "required_count": 3, + "support_count": 157, + "height": 17, + "required_sha256": "80273ecb3d50b0fd00cf19c17ef08621eab14bda68e35f52fbc65b57f95a0ef8", + "support_sha256": "50abc757bf4c8e2281a9b1d17eca503e02ef31429679a1acb988893f7333623d" + }, + { + "index": 624, + "required_count": 3, + "support_count": 42, + "height": 11, + "required_sha256": "e26cb066fed1697e9deddd83c6ea54fa3b2b0e3e3d1f00e04ef330eaa53921c7", + "support_sha256": "fd8430bdf9dbd024d786908448a2f7d219a694ec3a31c76b1a6d131be6ea83fa" + }, + { + "index": 625, + "required_count": 3, + "support_count": 41, + "height": 11, + "required_sha256": "fe9f9468ef1f95438e1d98e278d2c896a9ef712e4a8ab99a00d17ba8af629e46", + "support_sha256": "5810d23ff8cb714967fba9d468e71b0f977d95c3324fdfd34add1026b6dcaaac" + }, + { + "index": 626, + "required_count": 5, + "support_count": 61, + "height": 11, + "required_sha256": "66700ebb0c31b2db2232cce4ef93635160b44de161bbc9d68d35ae2838aa9f4d", + "support_sha256": "f3d9f5e6cd9165c143ae2a815cfcab47e85724b5de33161ca6d577ce8b8ea4dc" + }, + { + "index": 627, + "required_count": 4, + "support_count": 76, + "height": 16, + "required_sha256": "666c673998bbea15d257970fb86fc2d546cfa2725581f92dd2475e60e30ee442", + "support_sha256": "c98dd858a1a2d9ee619e064440a4533629d6d5d3705ea0ec38eb5ecda162e951" + }, + { + "index": 628, + "required_count": 5, + "support_count": 33, + "height": 7, + "required_sha256": "3659c07bad2aa46506274f0e0dc4e196be8869fe5f920c39d03fb4276fd2ae54", + "support_sha256": "12fdfd7d5ddbeb70c3fdead3194277d4bfc12a13de86db9f61f2b2f110e30c7a" + }, + { + "index": 629, + "required_count": 4, + "support_count": 53, + "height": 9, + "required_sha256": "666c673998bbea15d257970fb86fc2d546cfa2725581f92dd2475e60e30ee442", + "support_sha256": "ca3aea03c3f2bd7546650e75bb2c5dbccacb9bd4ed38dc9b5bdf75feeb188299" + }, + { + "index": 630, + "required_count": 3, + "support_count": 118, + "height": 17, + "required_sha256": "e1073816ead2e5f035aecea595e40109f7410b706fabd381c511b6d7513a2805", + "support_sha256": "4ac715f19d18da70f90b1f47cc0abbb64571c7704a2fab5a7af8390ba5ab6b1b" + }, + { + "index": 631, + "required_count": 3, + "support_count": 34, + "height": 10, + "required_sha256": "19405a5cda8250fdc62c17ea020902c2873d4dd1fcf9f2109f63197f8ec612a1", + "support_sha256": "b645a942c00c40c3506f8c48c07bfdf9f9531fca505dba7dd20a3383d6ffccee" + }, + { + "index": 632, + "required_count": 3, + "support_count": 43, + "height": 12, + "required_sha256": "d6bbd13fc57811ffd43bdfb0f4a0e2b04bf5d2632ba9b9fb5e0f24535ca36de6", + "support_sha256": "8746b4c7a8ab0bbc03d476994ff0a67eb802b2111f6def9cd28cf756d14c8944" + }, + { + "index": 633, + "required_count": 4, + "support_count": 40, + "height": 7, + "required_sha256": "97c1544ace444c881d5bb0698b2126696ac6ab2fce7dd271d6f0aad307f8af17", + "support_sha256": "d901c0b4dbeed7308191816ed61c938fe2c66c85a64239d912ab81d24428637a" + }, + { + "index": 634, + "required_count": 3, + "support_count": 56, + "height": 13, + "required_sha256": "0ddef6baffb84981504c6db114bb5fdfd8b56b7af448edc5e646e67bcf4d9c67", + "support_sha256": "dfe59bba63edc7e68e6b6e05192e7848817d01afd3c82166972baf217e21d612" + }, + { + "index": 635, + "required_count": 2, + "support_count": 44, + "height": 12, + "required_sha256": "ade82fac18b83f3ea1b8d56029122dad7518aa014e2dc9a76b7aaea79cf2db6f", + "support_sha256": "628ba6c65653bf9488a3357bab11a4ed1126e68a6a0ef99640b712a55a6e0f0c" + }, + { + "index": 636, + "required_count": 3, + "support_count": 66, + "height": 14, + "required_sha256": "bb94caf25c0966c9d41ab46015b573f7c8037802cd7effb8b644ba1accc577b6", + "support_sha256": "ff54087dc3355623641ba4bcfe47204e4b3e429ab679109f6140630b3441c196" + }, + { + "index": 637, + "required_count": 4, + "support_count": 24, + "height": 7, + "required_sha256": "546363565cce2e7634244b94cd5ab900de698d0a535022770cee06dbffa541c8", + "support_sha256": "538633e9bd3258be6e91ed20568b380d97185abb96ed1237c9162b981bb2e583" + }, + { + "index": 638, + "required_count": 3, + "support_count": 34, + "height": 9, + "required_sha256": "5d0fcfbc32b9c0f150ef10fa990084167b1b371147fcb276336e4b1725659905", + "support_sha256": "af38fbf2259f04eeea8bdbeee5e7f607796cbe53c0453ee28da5e001f8ce2cbc" + }, + { + "index": 639, + "required_count": 3, + "support_count": 47, + "height": 11, + "required_sha256": "46baced015251fac1d5d0858779d078a97c02ef3a0ebaee3489d86f9f9606a57", + "support_sha256": "5c8cceecc621332bdb1ec79cbf19c65be2f6a7b3b51667e8ef076048294df15d" + }, + { + "index": 640, + "required_count": 5, + "support_count": 42, + "height": 9, + "required_sha256": "318359e0a0e287d4ab442e4baba3e4b8cb6c0a51555283f0d8fd835f94c30b6e", + "support_sha256": "6d4538dd14a30390b5593eb036b4a1d377d03c7b184b11dd14ff2a40f7333673" + }, + { + "index": 641, + "required_count": 3, + "support_count": 29, + "height": 6, + "required_sha256": "a14a0c93efdef71ea3d53914f9196ece68995f720990bfbdd5877f6863697556", + "support_sha256": "c650a349d6121b2240355902858bcd36037177f7d52701180fb98d432d9d5b76" + }, + { + "index": 642, + "required_count": 3, + "support_count": 43, + "height": 13, + "required_sha256": "8b6a6d22bcb67ce153dec183b320bbed35dd93ececea83777238027c81f7a8dd", + "support_sha256": "0f9779537080b20cb0e412d6b8b0fda2f247e7d0553105964923bb9280f31e7f" + }, + { + "index": 643, + "required_count": 3, + "support_count": 43, + "height": 13, + "required_sha256": "8b6a6d22bcb67ce153dec183b320bbed35dd93ececea83777238027c81f7a8dd", + "support_sha256": "0f253fb271c9217c2d090fae2541710f61faf636dbc8f32f0a163de144a8c5a2" + }, + { + "index": 644, + "required_count": 2, + "support_count": 72, + "height": 14, + "required_sha256": "f00279a59f15005436fc15538cc554e93468ea50fe531e292c63a8e96829d91c", + "support_sha256": "b2b24c920ac1368dd92e480b11a85e5d39b305a602bec6393a51947a92081c12" + }, + { + "index": 645, + "required_count": 2, + "support_count": 67, + "height": 14, + "required_sha256": "f00279a59f15005436fc15538cc554e93468ea50fe531e292c63a8e96829d91c", + "support_sha256": "a48706f85577d9ca2ff580301d235e381ca09b515feca544fdf13596ac33cdc1" + }, + { + "index": 646, + "required_count": 3, + "support_count": 37, + "height": 11, + "required_sha256": "19405a5cda8250fdc62c17ea020902c2873d4dd1fcf9f2109f63197f8ec612a1", + "support_sha256": "8a56891449d104b5c0a6907e8f2d06d5b3628653c409d49fa1c3084a91a77458" + }, + { + "index": 647, + "required_count": 2, + "support_count": 62, + "height": 13, + "required_sha256": "f00279a59f15005436fc15538cc554e93468ea50fe531e292c63a8e96829d91c", + "support_sha256": "69dc9f5d5d1a420a851129241ec8cf0fd03ebe2f7f1dc2b42b7b702a93d2cb10" + }, + { + "index": 648, + "required_count": 1, + "support_count": 87, + "height": 15, + "required_sha256": "b109da47934c8e73b2f03df38955ef98a87d50600542d1b6ce1ed31a7c83ef14", + "support_sha256": "5b92492f4da5eb63a822a23fcff704d367fc6cb3e1639de499d8d7cbbf55c8a1" + }, + { + "index": 649, + "required_count": 3, + "support_count": 45, + "height": 12, + "required_sha256": "8474f3311e63691e5b74907338567567866577b42b61b18d2914338a0015d7d1", + "support_sha256": "1dc92b5a8d7267982106224a2311703cd98084db3d63492ee9c75fc1bd3d7b81" + }, + { + "index": 650, + "required_count": 2, + "support_count": 58, + "height": 13, + "required_sha256": "332552f6dadd6ab56e5bf85fa856b20f263bf4674c8ad3d5fd485ea0a3234dfe", + "support_sha256": "46d8b6b16ebbe88bba868ead52a1294170695e9124a65c8f560cccbd7877052d" + }, + { + "index": 651, + "required_count": 4, + "support_count": 37, + "height": 8, + "required_sha256": "313769a8b20d3c75e0c21c9adfed7e09f27e0a8443670d0fad0e8b134cfe58a7", + "support_sha256": "22396c91bcac705c87cc15e3342c2cd7fe292a84fec65277b2b25b4e9efa88a8" + }, + { + "index": 652, + "required_count": 4, + "support_count": 34, + "height": 10, + "required_sha256": "f006beb81b1364cd6d88e9c6424bb28d396668c65b3b1ce81fe83acdaf4758b5", + "support_sha256": "0fc5d964a6fab6e21664603f3365709d4d5cbf5af981375a35528ac7f462acaf" + }, + { + "index": 653, + "required_count": 3, + "support_count": 38, + "height": 11, + "required_sha256": "19405a5cda8250fdc62c17ea020902c2873d4dd1fcf9f2109f63197f8ec612a1", + "support_sha256": "b83321c86e6135c923b80d61abddf09a59a5f7f54970e7870d3801200334005d" + }, + { + "index": 654, + "required_count": 2, + "support_count": 55, + "height": 12, + "required_sha256": "61d1ae33e86588c85dbdef4beef4fb07795d1246b22f2dbbd12c2bd626e6b255", + "support_sha256": "cc1a58272e87fcf550b807e361c59f635ccc85a696b75f61512f24461a9f1768" + }, + { + "index": 655, + "required_count": 3, + "support_count": 37, + "height": 9, + "required_sha256": "2f5461597f76bcc471e3694ff5d6e0cf6ba2dea72e1d3301110027d9c2d479b2", + "support_sha256": "847569a67cca037ced6d5a7fe08c4b3a0509b39964f30eae48f73842b08d4c58" + }, + { + "index": 656, + "required_count": 2, + "support_count": 98, + "height": 15, + "required_sha256": "49f38605ab0b5335a4951be0c28dcc025ad7528a603eae1cbeb832a9f1cf88db", + "support_sha256": "04398a7ecfcbe61234b5750fddf8bbfadb9465f268db4ad0fff97227c5c8637b" + }, + { + "index": 657, + "required_count": 3, + "support_count": 61, + "height": 13, + "required_sha256": "f637ad767dad3e226d1744645b0295e77dab59f30cd72acfc12a622afe6cd66c", + "support_sha256": "4e173ce2f2fda8ae796dd5cd8813a83b6f15271f036066903ce5a70753fa34e4" + }, + { + "index": 658, + "required_count": 4, + "support_count": 35, + "height": 8, + "required_sha256": "1bcac3cc114c1eaf2336458f24f3a618ce852fdf160e108c4bacc13dfa740f7f", + "support_sha256": "b93cc591a6866b645c11282c03b53518d7ac510748e1e745454ff512fb93f49c" + }, + { + "index": 659, + "required_count": 5, + "support_count": 38, + "height": 9, + "required_sha256": "77a0d734690e5524f92b7a47a145d617d6161be2ca8ffe398025ec314aecac89", + "support_sha256": "0a2af2a9759be00cd879a1815260bd2070a0ec9aa7bd06f21cc901a7746ba194" + }, + { + "index": 660, + "required_count": 3, + "support_count": 59, + "height": 11, + "required_sha256": "0b7e3a7b7a367d6768b1c9edf78335b147e9b9970bb028366d2f4b12762d1372", + "support_sha256": "8c7c6747dcfdfb80cff4f33d855710b3f0f3aa3dac3b963691036ef4ff408975" + }, + { + "index": 661, + "required_count": 2, + "support_count": 44, + "height": 8, + "required_sha256": "f00279a59f15005436fc15538cc554e93468ea50fe531e292c63a8e96829d91c", + "support_sha256": "ecfcbc75417b5a6cbd1b3642ebb5f9885b07d484364bd13005af32f5156104f1" + }, + { + "index": 662, + "required_count": 4, + "support_count": 40, + "height": 9, + "required_sha256": "3e684f50d3d78fd15715c52fedbc034927ecac5ed48a16b72cdd1dce78908210", + "support_sha256": "b0824c59d53d4ce2c44c1af30574c0d048d668c7a596a5e713c6669f265acbcf" + }, + { + "index": 663, + "required_count": 3, + "support_count": 51, + "height": 11, + "required_sha256": "7335db764d217f20be13fdc9522570c91e35fd3c36070706e21bb4d80f4daa7f", + "support_sha256": "aaa3ac0b52aa936b7fbeb4ad467c8ce1f6dac27fc32cd5d538d0dcd92aab3e7e" + }, + { + "index": 664, + "required_count": 3, + "support_count": 56, + "height": 11, + "required_sha256": "0b7e3a7b7a367d6768b1c9edf78335b147e9b9970bb028366d2f4b12762d1372", + "support_sha256": "cb3205f9d0edcf4f1f9dffefda70a50176ee00c6406df0602cc542a7ecd6726c" + }, + { + "index": 665, + "required_count": 4, + "support_count": 73, + "height": 13, + "required_sha256": "56f59bdaca07a9721d661f83fe3dfff198f8b7449704ca0b6397e15f9b68bace", + "support_sha256": "15d180e9ee0ef09de111c250b1e4d49df047d908e363f0c2478b44ef7416502c" + }, + { + "index": 666, + "required_count": 5, + "support_count": 22, + "height": 8, + "required_sha256": "24e1f4d7acf7f72a87e48427e506ebef2f3abf3be4d8f0fe65dd4028f7e6a10e", + "support_sha256": "7e33bcf4d27ff7741eb8c2437b055cb2e94caf8c8c59f90e278fbfe8e7e44262" + }, + { + "index": 667, + "required_count": 4, + "support_count": 28, + "height": 9, + "required_sha256": "3467d04be31ea11af07c7646fe841bf0968c77e55d9be28a430f53f39f14326a", + "support_sha256": "cf776d6c9d56c267debb8bada998c3ff34dbb3c1b267ca625f4c0d6d0aa8958d" + }, + { + "index": 668, + "required_count": 4, + "support_count": 28, + "height": 9, + "required_sha256": "3467d04be31ea11af07c7646fe841bf0968c77e55d9be28a430f53f39f14326a", + "support_sha256": "afd073d23d8205402b48a16fe55644707c4a59403d44a869de456dcbbb580308" + }, + { + "index": 669, + "required_count": 4, + "support_count": 69, + "height": 14, + "required_sha256": "37e2da8cfe08f2fc8f2d67b06e9f1c4904efd60af32c939c8f4d2f124004af48", + "support_sha256": "98b7f11c6419d8a32b8c18f7b2a76395a51876d270ca11d670a300fd0adebf59" + }, + { + "index": 670, + "required_count": 3, + "support_count": 97, + "height": 15, + "required_sha256": "1fa211bf7f721615d00c244054930cdd9e6fc8c9c7283485bcc754fa52a0e367", + "support_sha256": "c8072203724541e08d96913cc21a7c1262e4b0ea9d8f8a35d8fe129c82352f22" + }, + { + "index": 671, + "required_count": 5, + "support_count": 24, + "height": 7, + "required_sha256": "3659c07bad2aa46506274f0e0dc4e196be8869fe5f920c39d03fb4276fd2ae54", + "support_sha256": "1bba12f59a0120c51a2927b0d7f2917b2fdfb0d9609a81f3233ed37f9aa78aa9" + }, + { + "index": 672, + "required_count": 5, + "support_count": 18, + "height": 5, + "required_sha256": "829b032c8f139633960be0f4f25623a083b495be8f39b18879ef4321e7b1982c", + "support_sha256": "01a9756bc8c23c91a69ca0bb901591f82e26461a058ec1e3f37b5a5ce324d492" + }, + { + "index": 673, + "required_count": 6, + "support_count": 40, + "height": 9, + "required_sha256": "142c71b53a4ba6e9dfb93990ac787899ccb57d382b74d2bf9cd297e9fe1d30fd", + "support_sha256": "8635f548a02f0ac875f9fa0dd40a53168987e61de693210eaaa7fff737e61b18" + }, + { + "index": 674, + "required_count": 5, + "support_count": 42, + "height": 10, + "required_sha256": "8d5ad0484771172eaea9a2c2f93bad45a77a2281566c2bee23217c5000a2b8d1", + "support_sha256": "45099007b7bd5873ee55ab3fdbe6d1d58a5a9e6a82a714cd7e916f3e706d1faf" + }, + { + "index": 675, + "required_count": 3, + "support_count": 105, + "height": 13, + "required_sha256": "c98a47516a64e5b768d9ba2ed4045f018ce5954768903e77c2fed70490403694", + "support_sha256": "6e6a038ced643f5cd3feecf3deff9b2fcb0e606d125376ee20c1b176a1b8cd6b" + }, + { + "index": 676, + "required_count": 3, + "support_count": 36, + "height": 11, + "required_sha256": "f878fbfaefc545f7afe82538112dfaa98c4877ed4eadcf99014dad6497e1f51a", + "support_sha256": "7cc615b78a16a0c95d9447dd71967ebce5ba11f656b0f851ed3f13e61b6fcc1b" + }, + { + "index": 677, + "required_count": 2, + "support_count": 49, + "height": 12, + "required_sha256": "08be7f6ce37dcc59d92de4a362498b337f70a9912a9ea13281342c21135009e4", + "support_sha256": "4978dadb6571c72c4b185d95b2539a94587770e133f74f454026c4acc1b75a42" + }, + { + "index": 678, + "required_count": 5, + "support_count": 32, + "height": 8, + "required_sha256": "af05a36840bf81a5221c0fc76f65715103d636a62985b1a246fd78a34d7b344c", + "support_sha256": "3aac12128e2d2c6bf2951a38342a462e3e665da23afd129edc58f26c9b396e57" + }, + { + "index": 679, + "required_count": 6, + "support_count": 19, + "height": 5, + "required_sha256": "23788f816cfac67e60cfb288bf00a8f0d06cd6a4779cbced5d2cf86560996851", + "support_sha256": "f4a371a021ec37f09ebc697b05e72e9cc2aa259e3057598f2ddcfa56853b6711" + }, + { + "index": 680, + "required_count": 4, + "support_count": 22, + "height": 7, + "required_sha256": "a98ff18b08cf374cc1a67932e6a5a6bd29d6f7d9a6c2c2633b8668cd7c9a47c5", + "support_sha256": "2047573a7e03e65fc5e79cb429500aecbeb833b75660c46e5436c34b58824e26" + }, + { + "index": 681, + "required_count": 5, + "support_count": 31, + "height": 7, + "required_sha256": "2d774f574c7fa41e3982245a25d62e6e02e8926cecf150a46fc09b5a2fed472f", + "support_sha256": "e765d56a436f5ab1fe53485098b6be82dd19ccaaf9261b860ae7c575ade7b561" + }, + { + "index": 682, + "required_count": 2, + "support_count": 73, + "height": 15, + "required_sha256": "332552f6dadd6ab56e5bf85fa856b20f263bf4674c8ad3d5fd485ea0a3234dfe", + "support_sha256": "ad1cbd06319684c6c5b50246d48d4dc2f652cf2fbdfa1c2442b63198a88bbe54" + }, + { + "index": 683, + "required_count": 3, + "support_count": 77, + "height": 16, + "required_sha256": "716385ab35059872648af6d0fd03418a3d73dd42a0b4d4cbaf31874a3cae4ef0", + "support_sha256": "ee6e52ecb0dce8c0c518fc0d97a31123c19d0f60e6f5cfa2bc8fefc2165ecbd5" + }, + { + "index": 684, + "required_count": 2, + "support_count": 170, + "height": 18, + "required_sha256": "9911e1db9b267c73b45f14960744d2e146e5acf7b0ccabed8f1de9779ffc2627", + "support_sha256": "49a7ce672eba0f482c7652cd1d05e296268ba99743c76749eda46f85ce165a4b" + }, + { + "index": 685, + "required_count": 4, + "support_count": 50, + "height": 11, + "required_sha256": "c8a9aa088c0fa37b5ab51d24239b93d8e4ade90d5ab5ac556ab767ef52d4f032", + "support_sha256": "cf533e9d41abf3e70f78e8a194b30dfbeec877c14bf301ff1f67f019198232ad" + }, + { + "index": 686, + "required_count": 4, + "support_count": 41, + "height": 9, + "required_sha256": "162af3072e15719c6353d71878fe9a801cbb5a5ed3691ffe76ef91ead089d44d", + "support_sha256": "2acafde0de545dbbcfcdcf8deeafb41e02c7d0bc88bc42085497d291f1a5f038" + }, + { + "index": 687, + "required_count": 3, + "support_count": 60, + "height": 12, + "required_sha256": "3650d7331a39fb47d9778b8e83bfb1de4f8b7b439ab8e92b4e8ed7d3123b2a5b", + "support_sha256": "3bd41b5f62d8090ab84d5e55436fcea07d1948acb311d9cffbea397c0f3c5410" + }, + { + "index": 688, + "required_count": 5, + "support_count": 35, + "height": 9, + "required_sha256": "271c72423f772837edc3b6b486344f76ec2c845683aca9e3e6a8c57ddfd6b4e6", + "support_sha256": "0a6a94b35b50d471f976eb09eee7c2b16417c5c36e977096bb6e6df1b676856f" + }, + { + "index": 689, + "required_count": 3, + "support_count": 55, + "height": 11, + "required_sha256": "72e4281e5351dbdd78ea4fec43a69016099803f0ef5aee92df354d88a4fa67d3", + "support_sha256": "ea553569a89fc7573e6d46322ff436b70244742fbd3a35bb5d883d2f09a65ae1" + }, + { + "index": 690, + "required_count": 4, + "support_count": 61, + "height": 13, + "required_sha256": "cc11c753ce39b566b1b3323e71c2cbeedcf8ffc92eaf03ee5eacc792486252c7", + "support_sha256": "25d97405f9b65c270d7dc60946616622c84c81b38c734c22f93ed5fa497a6dc1" + }, + { + "index": 691, + "required_count": 3, + "support_count": 80, + "height": 18, + "required_sha256": "8344b435aa51d4bdf964d86b9e56da16b21552e671a1e58b6eb9ea454536a574", + "support_sha256": "e412f572262e338f553a5fd75b8d6e5dc1d3b8656eb6e8241660503d637ecc98" + }, + { + "index": 692, + "required_count": 5, + "support_count": 65, + "height": 13, + "required_sha256": "11c704dc56335be937f99317700cbc19a97bf04863e29bdfd4ab6980fdd20bfa", + "support_sha256": "989ef1a5605fca6d2a8525a6511f006b4bc2e0b13b4ea4d2fcd991aee12f0285" + }, + { + "index": 693, + "required_count": 4, + "support_count": 95, + "height": 14, + "required_sha256": "9894e481e8826871d54ca4f8d9d850dfb433d739ec38421970d6a281a504f642", + "support_sha256": "16a9ab06ca5f68f636eabb79c0360873cd9d9a44450eb86066cec1fbfa7d93a1" + }, + { + "index": 694, + "required_count": 2, + "support_count": 126, + "height": 19, + "required_sha256": "bc9130d01e96c9ed08911d12957b3e84460d5b168f64a2d8d54b42536e758d70", + "support_sha256": "ad01504be88bc5a47ff2e34e746c2d0c88b3d8374a87f7adb25ff82403199324" + }, + { + "index": 695, + "required_count": 2, + "support_count": 75, + "height": 13, + "required_sha256": "a01730a99df0d83efb1f394033a339475f0ffad2bd22fa8b22bbbecf5da0900f", + "support_sha256": "dca3fae03d20cf87ae93ba75bac91944bfa25b4ee02e8fb2be07342b926c56e6" + }, + { + "index": 696, + "required_count": 2, + "support_count": 81, + "height": 13, + "required_sha256": "bc9130d01e96c9ed08911d12957b3e84460d5b168f64a2d8d54b42536e758d70", + "support_sha256": "c1f79803880fa83f88410c973de6f9599cff1281fdfdb9f8f0d90447dc747982" + }, + { + "index": 697, + "required_count": 3, + "support_count": 64, + "height": 14, + "required_sha256": "90d6958def63879298dde9490fac2a435e8851c90daf3e0e9a067b3173fbfc15", + "support_sha256": "1c96fbdd226d80bdc1b4a201f97968df55d1de7f930aee059de018adc1d076c8" + }, + { + "index": 698, + "required_count": 2, + "support_count": 92, + "height": 15, + "required_sha256": "f00279a59f15005436fc15538cc554e93468ea50fe531e292c63a8e96829d91c", + "support_sha256": "a9a083c2ebf5c076f710292f99d6e3f2c560e03b6eb9a9b67ff36b0eba379de9" + }, + { + "index": 699, + "required_count": 3, + "support_count": 103, + "height": 15, + "required_sha256": "e1ec4c22ab83345c02c731799b1fcb5cfa0fa5cbf1fc4436f39ca6ae55c59379", + "support_sha256": "4a78af429683a7b2870f5adeab68cf21e3f54053f146942b7c2050b21f4292a1" + }, + { + "index": 700, + "required_count": 4, + "support_count": 54, + "height": 11, + "required_sha256": "fe8d39b0c327a841be1b07918aa0c42a462b1a45c884236b3825cc1b99cd8a17", + "support_sha256": "17087f4e1b59681c379f9538e329b6250492dede2b6458468f21338d71105c0e" + }, + { + "index": 701, + "required_count": 2, + "support_count": 151, + "height": 18, + "required_sha256": "5d16303546ba1094d7953638672ca5614c072644fe730461554bc9c5c7589418", + "support_sha256": "f23eca32f944f0a22afaee73e9406908ce78984b06d696d0235e02fce8943c5a" + }, + { + "index": 702, + "required_count": 4, + "support_count": 32, + "height": 10, + "required_sha256": "0338756a029dd6843ae5e9584a9de5f103edec5871787b56d7ca734f2ba7ba7f", + "support_sha256": "421494a6f23fd9efccd1d3066df539812fb19f8eb67d8fa8890e09f6979a1098" + }, + { + "index": 703, + "required_count": 6, + "support_count": 41, + "height": 8, + "required_sha256": "4e4e991613d4ec95d2f948a0c690d3ce0c77e9eff75523f9e0b5b99f8ddc3fb0", + "support_sha256": "7075c79b2fa111bb23043b48bc3577827fc5ed29d1130a401fdb4449802bd0af" + }, + { + "index": 704, + "required_count": 4, + "support_count": 44, + "height": 10, + "required_sha256": "89dbf546eab3877d3645a5b213c810785755fc19c303bb996a7d42a1b9a9fdff", + "support_sha256": "8ef4d72e06a54c3891653d836b7faf1c3681ffbf2863c8e4990b45d8e4ce54e8" + }, + { + "index": 705, + "required_count": 3, + "support_count": 59, + "height": 14, + "required_sha256": "2f5461597f76bcc471e3694ff5d6e0cf6ba2dea72e1d3301110027d9c2d479b2", + "support_sha256": "d0c2d0741bfe9bf9bc77c8aff7c421a7f7c87f7b5894bf028b5678b76468b9b7" + }, + { + "index": 706, + "required_count": 3, + "support_count": 79, + "height": 16, + "required_sha256": "f7d3359edb32a019cc50dcb804785e8bd478011749aa86c86615505e50a70cc6", + "support_sha256": "43ed1de5e02ebcda3c1c18695dd51bc98cfd56d35a7d55e6671b82d5077a131c" + }, + { + "index": 707, + "required_count": 2, + "support_count": 115, + "height": 17, + "required_sha256": "60fb9bb3f888bef65f46411f5bc2dfc9f3476c03c9092a486cdf3d41cf12ddc3", + "support_sha256": "7c62869f12243ea56dfc068d3a46de4e50a8d804b773563001dcf6c6d5174832" + }, + { + "index": 708, + "required_count": 1, + "support_count": 225, + "height": 20, + "required_sha256": "b118b148e6dbbec33d3c8d6043b8535b23795fe887422865bd7564f19bc8c6a5", + "support_sha256": "4c9351c62204dd1cd7ebdb9906de548a240d020edd6c47a8401e9c3d1755a6aa" + }, + { + "index": 709, + "required_count": 2, + "support_count": 77, + "height": 13, + "required_sha256": "bc9130d01e96c9ed08911d12957b3e84460d5b168f64a2d8d54b42536e758d70", + "support_sha256": "19661fed7421e3ce4e7d22d66fd2c1614792a2744444890432e48f3f3de610ba" + }, + { + "index": 710, + "required_count": 2, + "support_count": 45, + "height": 11, + "required_sha256": "08be7f6ce37dcc59d92de4a362498b337f70a9912a9ea13281342c21135009e4", + "support_sha256": "f2873f20afee242cdc6e695babd36ba81b15bf0c9b4c62aab4b01e63274f9826" + }, + { + "index": 711, + "required_count": 2, + "support_count": 70, + "height": 14, + "required_sha256": "f8368df7ed12be7828aa578a99ed7586f60420a3f6586de4c6686d904cd2f622", + "support_sha256": "dca27136a31c87ae307ee32aa45c4bb60fb61b37dcef3e3bedd2961534f24a3e" + }, + { + "index": 712, + "required_count": 1, + "support_count": 96, + "height": 15, + "required_sha256": "546548f79da4b7ffc15028508641550646fb3c0abc655a94d6729ccdf26bebc1", + "support_sha256": "c26ef307efd032dba80b82c376a38b1f30616764c93bdfacb9b6a2a406547167" + }, + { + "index": 713, + "required_count": 1, + "support_count": 98, + "height": 15, + "required_sha256": "546548f79da4b7ffc15028508641550646fb3c0abc655a94d6729ccdf26bebc1", + "support_sha256": "e4498d7cb9e8dbf5f7f9948f57f3bc6aeae3d81c67a3ad0853eded40eeb85b9c" + }, + { + "index": 714, + "required_count": 4, + "support_count": 24, + "height": 6, + "required_sha256": "ef272c91cda1ded9afdcab2dd9df999e15c942e65801838c19194bd36a95d71f", + "support_sha256": "160af63df093fc06ecf17423a29720c7852a1518bcbd03aade2fa9e1f273a028" + }, + { + "index": 715, + "required_count": 2, + "support_count": 79, + "height": 12, + "required_sha256": "60fb9bb3f888bef65f46411f5bc2dfc9f3476c03c9092a486cdf3d41cf12ddc3", + "support_sha256": "c7772d3ef8a4aa9b2b245be42a8f297cee265c6f51f979847e1f03b6d1075342" + }, + { + "index": 716, + "required_count": 3, + "support_count": 51, + "height": 11, + "required_sha256": "e1ec4c22ab83345c02c731799b1fcb5cfa0fa5cbf1fc4436f39ca6ae55c59379", + "support_sha256": "518a5d1145efa5961714ccb39782d2b6c7dfb226bd62408fb917bbc51dcb9a55" + }, + { + "index": 717, + "required_count": 2, + "support_count": 79, + "height": 12, + "required_sha256": "aac21842a195db9b24f56448d274517a8a20cfcb11ff7183e7766e245b78d177", + "support_sha256": "9e404269c0ddbf3247c2c050eb311dc5a31be59db5545e918607b5e32410cb8f" + }, + { + "index": 718, + "required_count": 2, + "support_count": 81, + "height": 15, + "required_sha256": "bc9130d01e96c9ed08911d12957b3e84460d5b168f64a2d8d54b42536e758d70", + "support_sha256": "235f342214cc060f11f3031ab5624421d26fdbb7a0dcbce4066966fa82aa0929" + }, + { + "index": 719, + "required_count": 3, + "support_count": 55, + "height": 15, + "required_sha256": "7335db764d217f20be13fdc9522570c91e35fd3c36070706e21bb4d80f4daa7f", + "support_sha256": "b9bf206c92bd080a470a672af9474d8262fa03a86c9ceed8b9bdebba62ecc3cf" + }, + { + "index": 720, + "required_count": 4, + "support_count": 62, + "height": 13, + "required_sha256": "2410a6f7a5f811462dbf2819fb4e7da545e749931a30c13fc069ee6c7336ab60", + "support_sha256": "9b89a9d4a25ed36d8d751d93c0494ae5ed601d786bd31c1c12f879cc6012aa4a" + }, + { + "index": 721, + "required_count": 5, + "support_count": 37, + "height": 10, + "required_sha256": "01d056d1af5a45a24f69c36e41806b6e65ac9c1100d328dec2a0dcc1ab18d198", + "support_sha256": "9da813f8aab758535a2d3d29ea037259b4f6635cc60972d45e3b71e2bf980d30" + }, + { + "index": 722, + "required_count": 5, + "support_count": 35, + "height": 10, + "required_sha256": "5c63f4a83fb8df234f48c73ff74eae7778083fadd182f42286b22af177fa2acd", + "support_sha256": "e41bfd52b37f899b4d4c66799dea32d642ce51b04060a0bfd2e51e65b8b5a4d1" + }, + { + "index": 723, + "required_count": 3, + "support_count": 68, + "height": 12, + "required_sha256": "b4af72a205b2a04361b230ab6dfe9abb9b9dd917507b0b19f5d5bdc64d0da633", + "support_sha256": "d39bf8f08effef4a536cf58ef0cff6822fdc84c4b6c190f43fa5c586d49438ca" + }, + { + "index": 724, + "required_count": 2, + "support_count": 115, + "height": 16, + "required_sha256": "a45541231690e0b975b679e1f6c3ef1a8a385e643d4524f7e065d681df7c70f5", + "support_sha256": "2071bb6bb48c72a410662f6b18bdf70b145728b35c88611a80b4db3184dc7557" + }, + { + "index": 725, + "required_count": 1, + "support_count": 167, + "height": 20, + "required_sha256": "5ebce5f34f467535e176833965968d5fcbf1ee60789dd08b4e19971c4c88defc", + "support_sha256": "d750ca97d7282eacf7dacd9dd4ae14e7c184b372fb3fa3463dffb0f4c3ca57a0" + }, + { + "index": 726, + "required_count": 1, + "support_count": 169, + "height": 20, + "required_sha256": "5ebce5f34f467535e176833965968d5fcbf1ee60789dd08b4e19971c4c88defc", + "support_sha256": "31162b1b886f03356e4a4f9f163584aaf986ee0262d38d511564315805263b5f" + }, + { + "index": 727, + "required_count": 0, + "support_count": 251, + "height": 21, + "required_sha256": "37517e5f3dc66819f61f5a7bb8ace1921282415f10551d2defa5c3eb0985b570", + "support_sha256": "6320dabfae66fe64b26c8ad648ce4fc947198f18ef7dfc3cf7caee654388c500" + } + ], + "final_children": [ + { + "position": 0, + "card": 648, + "symmetry": 0, + "translation": [ + 4, + 3 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 87, + "support_sha256": "86d1040acc003c3ec6f1d68ff8fb19d5e9ac1350c4423d118989b3951271d34d", + "common_cells_other_than_pivot": 86 + }, + { + "position": 1, + "card": 648, + "symmetry": 1, + "translation": [ + 3, + 4 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 87, + "support_sha256": "3071d13ddd5899e5f76d4bf0d89e2bc12a21d45fa29e18f3aca519cc0c5febbb", + "common_cells_other_than_pivot": 56 + }, + { + "position": 2, + "card": 648, + "symmetry": 3, + "translation": [ + 3, + 12 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 87, + "support_sha256": "bab4f94770cbe979bfdd7a607eade89de179f4a19aa2a7b5ce4e7d498b3107ca", + "common_cells_other_than_pivot": 44 + }, + { + "position": 3, + "card": 648, + "symmetry": 4, + "translation": [ + 4, + 13 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 87, + "support_sha256": "e0d1aed28989938c418a309f4009cf36cfc399fda9beaa40baf189b045631331", + "common_cells_other_than_pivot": 35 + }, + { + "position": 4, + "card": 708, + "symmetry": 1, + "translation": [ + 0, + 0 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 225, + "support_sha256": "cdfe7a402263189db810c5b2aac548df581bcdbc3f04ea0cd9a51ed3614a6ba3", + "common_cells_other_than_pivot": 34 + }, + { + "position": 5, + "card": 708, + "symmetry": 2, + "translation": [ + 16, + 0 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 225, + "support_sha256": "2c76cc595f12131708121368133cfe1ab90f0896837002d8e0b28b24b7be737b", + "common_cells_other_than_pivot": 33 + }, + { + "position": 6, + "card": 708, + "symmetry": 4, + "translation": [ + 0, + 16 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 225, + "support_sha256": "2edb9668d40c4afddd006acb180430bcceaea296a9c7e88c4062d4920f23b47b", + "common_cells_other_than_pivot": 32 + }, + { + "position": 7, + "card": 708, + "symmetry": 7, + "translation": [ + 16, + 16 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 225, + "support_sha256": "ceb0e0a056a770c4381c03cb895b203d4a29e0d8272290c3599e9fb7e2af975e", + "common_cells_other_than_pivot": 31 + }, + { + "position": 8, + "card": 712, + "symmetry": 0, + "translation": [ + 3, + 3 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 96, + "support_sha256": "0d1cc1f3fcb916c784249128348a695dc0d0731d35ddf39e6718682a729d3894", + "common_cells_other_than_pivot": 30 + }, + { + "position": 9, + "card": 712, + "symmetry": 1, + "translation": [ + 3, + 3 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 96, + "support_sha256": "6297bdb947a3c9003451f265a09d3eac10854e79f144d488e8ce008a303b0a5c", + "common_cells_other_than_pivot": 29 + }, + { + "position": 10, + "card": 712, + "symmetry": 2, + "translation": [ + 13, + 3 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 96, + "support_sha256": "2865e97e7033aff70c5ce5edbc550d8d3ab56abba20682d28f40207f90eced50", + "common_cells_other_than_pivot": 28 + }, + { + "position": 11, + "card": 712, + "symmetry": 3, + "translation": [ + 3, + 13 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 96, + "support_sha256": "b65d351ca9f00e325c413a5e848a6c3996e069385e63597ca3d7eced22d5970d", + "common_cells_other_than_pivot": 27 + }, + { + "position": 12, + "card": 712, + "symmetry": 4, + "translation": [ + 3, + 13 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 96, + "support_sha256": "f20b6da92f6342729c3520684466b86b9747be98319aa08ae0e6664fa3eeabc3", + "common_cells_other_than_pivot": 26 + }, + { + "position": 13, + "card": 712, + "symmetry": 5, + "translation": [ + 13, + 3 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 96, + "support_sha256": "d7393a01fab202f38d84c240446eae8807ad1618ec907feab0525fa860f83bb9", + "common_cells_other_than_pivot": 24 + }, + { + "position": 14, + "card": 712, + "symmetry": 6, + "translation": [ + 13, + 13 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 96, + "support_sha256": "78c4f678f534ebe5c8fd3f30b8b511d13e73a180567c267efecb850a4ed38b03", + "common_cells_other_than_pivot": 23 + }, + { + "position": 15, + "card": 712, + "symmetry": 7, + "translation": [ + 13, + 13 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 96, + "support_sha256": "55f4a1c746d03460c606425906b9aa5d0d28f9a5f67daf7e3693a4ce19f56a8a", + "common_cells_other_than_pivot": 21 + }, + { + "position": 16, + "card": 713, + "symmetry": 2, + "translation": [ + 13, + 3 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 98, + "support_sha256": "fe9513264340b0c8d10c0ded5bbecec9611a92173d781cb17914d46cdc613acb", + "common_cells_other_than_pivot": 19 + }, + { + "position": 17, + "card": 713, + "symmetry": 3, + "translation": [ + 3, + 13 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 98, + "support_sha256": "d5d68609efa3688511ceb31b6e5994f79e5ac39fa6e85afbeb94a309b4f50b5f", + "common_cells_other_than_pivot": 16 + }, + { + "position": 18, + "card": 713, + "symmetry": 4, + "translation": [ + 3, + 13 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 98, + "support_sha256": "895d75b4f8fa6b32eba3be46d764330657552b9fd023630167d240e0de21fe44", + "common_cells_other_than_pivot": 14 + }, + { + "position": 19, + "card": 713, + "symmetry": 5, + "translation": [ + 13, + 3 + ], + "height": 15, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 98, + "support_sha256": "28cb57593c2e8b21b67059dfabc3a925c39a9c5c3744858eb5f76f0ca585d087", + "common_cells_other_than_pivot": 12 + }, + { + "position": 20, + "card": 725, + "symmetry": 0, + "translation": [ + 1, + 1 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 167, + "support_sha256": "785b4d5998dc2d012a50be6e036171db40ca17ef703266cecf8e9cad514fff76", + "common_cells_other_than_pivot": 11 + }, + { + "position": 21, + "card": 725, + "symmetry": 1, + "translation": [ + 1, + 1 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 167, + "support_sha256": "c38cb6a80f7e90ba086eeb22b660cfb7682c63ca1cef7da54c7c591465ddd76b", + "common_cells_other_than_pivot": 10 + }, + { + "position": 22, + "card": 725, + "symmetry": 2, + "translation": [ + 15, + 1 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 167, + "support_sha256": "08dc9a903e3d3e52855b8d3f0a856efbd29b4bad0dc1367427b2add30d9f51e1", + "common_cells_other_than_pivot": 9 + }, + { + "position": 23, + "card": 725, + "symmetry": 3, + "translation": [ + 1, + 15 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 167, + "support_sha256": "64ac37d3dda4e14b941a0f362624c14f25f0e4a8de4686e92e59e690d02635ba", + "common_cells_other_than_pivot": 8 + }, + { + "position": 24, + "card": 725, + "symmetry": 4, + "translation": [ + 1, + 15 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 167, + "support_sha256": "4d597aedddd4d8bc194a239fb5cced6f4f4a261e89d918dd41019287644fcfb5", + "common_cells_other_than_pivot": 7 + }, + { + "position": 25, + "card": 725, + "symmetry": 5, + "translation": [ + 15, + 1 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 167, + "support_sha256": "c078b91a822883fd95cb9f94aad7d28b6d52e97d3e81e9addc955e1ebd5b2fa3", + "common_cells_other_than_pivot": 6 + }, + { + "position": 26, + "card": 725, + "symmetry": 6, + "translation": [ + 15, + 15 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 167, + "support_sha256": "a793bf6c071e0d6079db0f21101bea023b576b3c0c2c87bb12aea534f63dd9ff", + "common_cells_other_than_pivot": 5 + }, + { + "position": 27, + "card": 725, + "symmetry": 7, + "translation": [ + 15, + 15 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 167, + "support_sha256": "e362e5c8b2c2a2ed361145cc570d58c04a3c36ec0f8097289997e4cb03e2b122", + "common_cells_other_than_pivot": 4 + }, + { + "position": 28, + "card": 726, + "symmetry": 1, + "translation": [ + 1, + 1 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 169, + "support_sha256": "8548426b1ae010b2bb0d9e4f1c226f1e448e508555e1a6983b6a52a9f5e7a33b", + "common_cells_other_than_pivot": 3 + }, + { + "position": 29, + "card": 726, + "symmetry": 2, + "translation": [ + 15, + 1 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 169, + "support_sha256": "f9997b546256ed283b8ae6c7d4f4b8b021d069405c1a825676cc368b7826904e", + "common_cells_other_than_pivot": 2 + }, + { + "position": 30, + "card": 726, + "symmetry": 4, + "translation": [ + 1, + 15 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 169, + "support_sha256": "c500e2163ea8a1ea3454c4b164eae97a9839481c83169535882507ae7c5e1875", + "common_cells_other_than_pivot": 1 + }, + { + "position": 31, + "card": 726, + "symmetry": 6, + "translation": [ + 15, + 15 + ], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "support_count": 169, + "support_sha256": "30a9426d15f098199cad0a749cb8ea87ad04791095010e9bcb00376268819cc9", + "common_cells_other_than_pivot": 0 + } + ], + "successive_intersections": [ + { + "card": 648, + "placements": 4, + "remaining_cells_other_than_pivot": 35 + }, + { + "card": 708, + "placements": 4, + "remaining_cells_other_than_pivot": 31 + }, + { + "card": 712, + "placements": 8, + "remaining_cells_other_than_pivot": 21 + }, + { + "card": 713, + "placements": 4, + "remaining_cells_other_than_pivot": 12 + }, + { + "card": 725, + "placements": 8, + "remaining_cells_other_than_pivot": 4 + }, + { + "card": 726, + "placements": 4, + "remaining_cells_other_than_pivot": 0 + } + ], + "limits": [ + "Reconstruction checks this exact finite certificate, not a complete strategy search.", + "The game-strategy implication and quantifier order require the separate Lean theorem.", + "The 728-card theorem certificate is distinct from the historical 616-row comparator.", + "The 21-move bound and finite-board result are already stated in the source paper.", + "No claim of a 20-move strategy, novelty, or improved agent reasoning." + ] +} diff --git a/evidence/snaky-finite-v1/proof/Audit.lean b/evidence/snaky-finite-v1/proof/Audit.lean new file mode 100644 index 0000000..71438ae --- /dev/null +++ b/evidence/snaky-finite-v1/proof/Audit.lean @@ -0,0 +1,20 @@ +import SnakyBinding +#print axioms FiniteCongruenceChecks.SnakyFinite.FiniteWins.false_impossible +#print axioms FiniteCongruenceChecks.SnakyFinite.FiniteWins.zero_iff +#print axioms FiniteCongruenceChecks.SnakyFinite.fresh_cell +#print axioms FiniteCongruenceChecks.SnakyFinite.finite_immediate +#print axioms FiniteCongruenceChecks.SnakyFinite.finite_compose +#print axioms FiniteCongruenceChecks.SnakyFinite.envelope_card +#print axioms FiniteCongruenceChecks.SnakyFinite.square_card +#print axioms FiniteCongruenceChecks.SnakyFinite.envelope_subset_square +#print axioms FiniteCongruenceChecks.SnakyFinite.square_membership +#print axioms FiniteCongruenceChecks.SnakyFinite.board_wins +#print axioms FiniteCongruenceChecks.SnakyFinite.envelope_wins +#print axioms FiniteCongruenceChecks.SnakyFinite.square_wins +#print axioms FiniteCongruenceChecks.SnakyFinite.Binding.target_exact +#print axioms FiniteCongruenceChecks.SnakyFinite.Binding.envelope_exact +#print axioms FiniteCongruenceChecks.SnakyFinite.Binding.square_exact +#print axioms FiniteCongruenceChecks.SnakyFinite.Binding.inputs_exact +#print axioms FiniteCongruenceChecks.SnakyFinite.Binding.counts_exact +#print axioms FiniteCongruenceChecks.SnakyFinite.Binding.checked_envelope +#print axioms FiniteCongruenceChecks.SnakyFinite.Binding.checked_square diff --git a/evidence/snaky-finite-v1/proof/axioms.log b/evidence/snaky-finite-v1/proof/axioms.log new file mode 100644 index 0000000..fb91ffe --- /dev/null +++ b/evidence/snaky-finite-v1/proof/axioms.log @@ -0,0 +1,21 @@ +'FiniteCongruenceChecks.SnakyFinite.FiniteWins.false_impossible' depends on axioms: [propext, + Classical.choice, + Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.FiniteWins.zero_iff' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.fresh_cell' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.finite_immediate' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.finite_compose' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.envelope_card' depends on axioms: [propext, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.square_card' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.envelope_subset_square' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.square_membership' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.board_wins' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.envelope_wins' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.square_wins' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.Binding.target_exact' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.Binding.envelope_exact' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.Binding.square_exact' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.Binding.inputs_exact' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.Binding.counts_exact' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.Binding.checked_envelope' depends on axioms: [propext, Classical.choice, Quot.sound] +'FiniteCongruenceChecks.SnakyFinite.Binding.checked_square' depends on axioms: [propext, Classical.choice, Quot.sound] diff --git a/evidence/snaky-finite-v1/proof/build.log b/evidence/snaky-finite-v1/proof/build.log new file mode 100644 index 0000000..ae60da2 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/build.log @@ -0,0 +1 @@ +Build completed successfully (9103 jobs). diff --git a/evidence/snaky-finite-v1/proof/changed-envelope.lean b/evidence/snaky-finite-v1/proof/changed-envelope.lean new file mode 100644 index 0000000..008f711 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/changed-envelope.lean @@ -0,0 +1,25 @@ +-- Generated by scripts/snaky_proof.py generate; checked without rewriting. +import SnakyFinite +namespace FiniteCongruenceChecks.SnakyFinite.Binding +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 +private def target : Finset Cell := ([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell).toFinset +private def envelope : Finset Cell := ([(0, 3), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11), (0, 12), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (9, 16), (10, 0), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (10, 16), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (11, 15), (11, 16), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (12, 16), (13, 1), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (13, 15), (14, 1), (14, 2), (14, 3), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 11), (14, 12), (14, 13), (14, 14), (15, 3), (15, 4), (15, 5), (15, 6), (15, 7), (15, 8), (15, 9), (15, 10), (15, 11), (15, 12), (15, 13), (15, 14), (16, 4), (16, 5), (16, 6), (16, 7), (16, 8), (16, 9), (16, 10), (16, 11)] : List Cell).toFinset +private def square : Finset Cell := (Finset.Icc (0 : ℤ) 16).product (Finset.Icc (0 : ℤ) 16) +private def initialM : Finset Cell := ([] : List Cell).toFinset +private def initialB : Finset Cell := ([] : List Cell).toFinset +private def targetWin (M : Finset Cell) : Prop := ∃ (r : Fin 8) (t : Cell), target.image (placement r t) ⊆ M +theorem target_exact : snaky = target := by decide +kernel +theorem envelope_exact : envelope_727 = envelope := by decide +kernel +theorem square_exact : square17 = square := by decide +kernel +theorem inputs_exact : initialM = ∅ ∧ initialB = ∅ ∧ (727 : Nat) = 727 := by decide +kernel +theorem counts_exact : envelope.card = 251 ∧ square.card = 289 := by decide +kernel +private theorem win_exact : HasSnaky = targetWin := by + funext M + simp only [HasSnaky, targetWin, target_exact] +theorem checked_envelope : FiniteWins envelope targetWin 21 initialM initialB := by + rw [← envelope_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.envelope_wins +theorem checked_square : FiniteWins square targetWin 21 initialM initialB := by + rw [← square_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.square_wins +end FiniteCongruenceChecks.SnakyFinite.Binding diff --git a/evidence/snaky-finite-v1/proof/changed-envelope.log b/evidence/snaky-finite-v1/proof/changed-envelope.log new file mode 100644 index 0000000..5e6ba01 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/changed-envelope.log @@ -0,0 +1,6 @@ +/tmp/snaky-recovery-c3af350005f413554aea03db8cbf2c4c2d09e31b/runs/snaky-proof/changed-envelope.lean:12:55: error: (kernel) application type mismatch + id (Eq.refl true) +argument has type + true = true +but function has type + decide (envelope_727 = envelope) = true → decide (envelope_727 = envelope) = true diff --git a/evidence/snaky-finite-v1/proof/changed-square.lean b/evidence/snaky-finite-v1/proof/changed-square.lean new file mode 100644 index 0000000..bdf669b --- /dev/null +++ b/evidence/snaky-finite-v1/proof/changed-square.lean @@ -0,0 +1,25 @@ +-- Generated by scripts/snaky_proof.py generate; checked without rewriting. +import SnakyFinite +namespace FiniteCongruenceChecks.SnakyFinite.Binding +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 +private def target : Finset Cell := ([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell).toFinset +private def envelope : Finset Cell := ([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11), (0, 12), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (9, 16), (10, 0), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (10, 16), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (11, 15), (11, 16), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (12, 16), (13, 1), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (13, 15), (14, 1), (14, 2), (14, 3), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 11), (14, 12), (14, 13), (14, 14), (15, 3), (15, 4), (15, 5), (15, 6), (15, 7), (15, 8), (15, 9), (15, 10), (15, 11), (15, 12), (15, 13), (15, 14), (16, 4), (16, 5), (16, 6), (16, 7), (16, 8), (16, 9), (16, 10), (16, 11)] : List Cell).toFinset +private def square : Finset Cell := (Finset.Icc (0 : ℤ) 15).product (Finset.Icc (0 : ℤ) 16) +private def initialM : Finset Cell := ([] : List Cell).toFinset +private def initialB : Finset Cell := ([] : List Cell).toFinset +private def targetWin (M : Finset Cell) : Prop := ∃ (r : Fin 8) (t : Cell), target.image (placement r t) ⊆ M +theorem target_exact : snaky = target := by decide +kernel +theorem envelope_exact : envelope_727 = envelope := by decide +kernel +theorem square_exact : square17 = square := by decide +kernel +theorem inputs_exact : initialM = ∅ ∧ initialB = ∅ ∧ (727 : Nat) = 727 := by decide +kernel +theorem counts_exact : envelope.card = 251 ∧ square.card = 289 := by decide +kernel +private theorem win_exact : HasSnaky = targetWin := by + funext M + simp only [HasSnaky, targetWin, target_exact] +theorem checked_envelope : FiniteWins envelope targetWin 21 initialM initialB := by + rw [← envelope_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.envelope_wins +theorem checked_square : FiniteWins square targetWin 21 initialM initialB := by + rw [← square_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.square_wins +end FiniteCongruenceChecks.SnakyFinite.Binding diff --git a/evidence/snaky-finite-v1/proof/changed-square.log b/evidence/snaky-finite-v1/proof/changed-square.log new file mode 100644 index 0000000..b49af24 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/changed-square.log @@ -0,0 +1,13 @@ +/tmp/snaky-recovery-c3af350005f413554aea03db8cbf2c4c2d09e31b/runs/snaky-proof/changed-square.lean:13:47: error: (kernel) application type mismatch + id (Eq.refl true) +argument has type + true = true +but function has type + decide (square17 = square) = true → decide (square17 = square) = true +/tmp/snaky-recovery-c3af350005f413554aea03db8cbf2c4c2d09e31b/runs/snaky-proof/changed-square.lean:15:69: error: (kernel) application type mismatch + id (Eq.refl true) +argument has type + true = true +but function has type + decide (Finset.card envelope = 251 ∧ Finset.card square = 289) = true → + decide (Finset.card envelope = 251 ∧ Finset.card square = 289) = true diff --git a/evidence/snaky-finite-v1/proof/changed-target.lean b/evidence/snaky-finite-v1/proof/changed-target.lean new file mode 100644 index 0000000..421a6a3 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/changed-target.lean @@ -0,0 +1,25 @@ +-- Generated by scripts/snaky_proof.py generate; checked without rewriting. +import SnakyFinite +namespace FiniteCongruenceChecks.SnakyFinite.Binding +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 +private def target : Finset Cell := ([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (5, 1)] : List Cell).toFinset +private def envelope : Finset Cell := ([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11), (0, 12), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (9, 16), (10, 0), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (10, 16), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (11, 15), (11, 16), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (12, 16), (13, 1), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (13, 15), (14, 1), (14, 2), (14, 3), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 11), (14, 12), (14, 13), (14, 14), (15, 3), (15, 4), (15, 5), (15, 6), (15, 7), (15, 8), (15, 9), (15, 10), (15, 11), (15, 12), (15, 13), (15, 14), (16, 4), (16, 5), (16, 6), (16, 7), (16, 8), (16, 9), (16, 10), (16, 11)] : List Cell).toFinset +private def square : Finset Cell := (Finset.Icc (0 : ℤ) 16).product (Finset.Icc (0 : ℤ) 16) +private def initialM : Finset Cell := ([] : List Cell).toFinset +private def initialB : Finset Cell := ([] : List Cell).toFinset +private def targetWin (M : Finset Cell) : Prop := ∃ (r : Fin 8) (t : Cell), target.image (placement r t) ⊆ M +theorem target_exact : snaky = target := by decide +kernel +theorem envelope_exact : envelope_727 = envelope := by decide +kernel +theorem square_exact : square17 = square := by decide +kernel +theorem inputs_exact : initialM = ∅ ∧ initialB = ∅ ∧ (727 : Nat) = 727 := by decide +kernel +theorem counts_exact : envelope.card = 251 ∧ square.card = 289 := by decide +kernel +private theorem win_exact : HasSnaky = targetWin := by + funext M + simp only [HasSnaky, targetWin, target_exact] +theorem checked_envelope : FiniteWins envelope targetWin 21 initialM initialB := by + rw [← envelope_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.envelope_wins +theorem checked_square : FiniteWins square targetWin 21 initialM initialB := by + rw [← square_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.square_wins +end FiniteCongruenceChecks.SnakyFinite.Binding diff --git a/evidence/snaky-finite-v1/proof/changed-target.log b/evidence/snaky-finite-v1/proof/changed-target.log new file mode 100644 index 0000000..9a18d1f --- /dev/null +++ b/evidence/snaky-finite-v1/proof/changed-target.log @@ -0,0 +1,3 @@ +/tmp/snaky-recovery-c3af350005f413554aea03db8cbf2c4c2d09e31b/runs/snaky-proof/changed-target.lean:11:44: error: Tactic `decide` proved that the proposition + snaky = target +is false diff --git a/evidence/snaky-finite-v1/proof/dependencies.log b/evidence/snaky-finite-v1/proof/dependencies.log new file mode 100644 index 0000000..21039d9 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/dependencies.log @@ -0,0 +1,4 @@ +Current branch: HEAD +Using cache from origin: (some leanprover-community/mathlib4) +No files to download +Already decompressed 8908 file(s) diff --git a/evidence/snaky-finite-v1/proof/kernel.log b/evidence/snaky-finite-v1/proof/kernel.log new file mode 100644 index 0000000..1c03f54 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/kernel.log @@ -0,0 +1,179 @@ +replaying SnakyBinding +replaying SnakyFinite +replaying SnakySemantics +replaying FiniteCards.Height11Part03 +replaying FiniteCards.Height14Part01 +replaying FiniteCards.Height13Part07 +replaying FiniteCards.Height17Part01 +replaying FiniteCards.Height08Part03 +replaying FiniteCards.Height13Part05 +replaying FiniteCards.Height10Part01 +replaying FiniteCards.Height10Part04 +replaying FiniteCards.Height07Part05 +replaying FiniteCards.Height04Part01 +replaying FiniteCards.Height11Part05 +replaying FiniteCards.Height08Part02 +replaying FiniteCards.Height20Part01 +replaying FiniteCards.Height21Part01 +replaying FiniteCards.Height02Part01 +replaying FiniteCards.Height18Part01 +replaying FiniteCards.Height17Part02 +replaying FiniteCards.Height16Part01 +replaying FiniteCards.Height03Part03 +replaying FiniteCards.Height10Part06 +replaying FiniteCards.Height05Part04 +replaying FiniteCards.Height09Part07 +replaying FiniteCards.Height05Part07 +replaying FiniteCards.Height19Part01 +replaying FiniteCards.Height18Part02 +replaying FiniteCards.Height08Part01 +replaying FiniteCards.Height15Part04 +replaying FiniteCards.Height06Part01 +replaying FiniteCards.Height06Part04 +replaying FiniteCards.Height09Part08 +replaying FiniteCards.Height10Part07 +replaying FiniteCards.Height09Part03 +replaying FiniteCards.Height01Part01 +replaying FiniteCards.Height09Part06 +replaying FiniteCards.Height09Part04 +replaying FiniteCards.Height04Part04 +replaying FiniteCards.Height14Part04 +replaying FiniteCards.Height09Part02 +replaying FiniteCards.Height13Part01 +replaying FiniteCards.Height05Part06 +replaying FiniteCards.Height05Part02 +replaying FiniteCards.Height08Part05 +replaying FiniteCards.Height07Part02 +replaying FiniteCards.Height15Part02 +replaying FiniteCards.Height13Part03 +replaying FiniteCards.Height08Part04 +replaying FiniteCards.Height09Part05 +replaying FiniteCards.Height06Part02 +replaying FiniteCards.Height07Part06 +replaying FiniteCards.Height16Part03 +replaying FiniteCards.Height14Part03 +replaying FiniteCards.Height05Part03 +replaying FiniteCards.Height11Part02 +replaying FiniteCards.Height12Part03 +replaying FiniteCards.Height07Part03 +replaying FiniteCards.Height06Part06 +replaying FiniteCards.Height02Part02 +replaying FiniteCards.Height16Part02 +replaying FiniteCards.Height06Part03 +replaying FiniteCards.Height10Part03 +replaying FiniteCards.Height13Part06 +replaying FiniteCards.Height04Part05 +replaying FiniteCards.Height05Part01 +replaying FiniteCards.Height12Part02 +replaying FiniteCards.Height04Part03 +replaying FiniteCards.Height12Part01 +replaying FiniteCards.Height15Part03 +replaying FiniteCards.Height13Part02 +replaying FiniteCards.Height06Part05 +replaying FiniteCards.Height11Part01 +replaying FiniteCards.Height11Part04 +replaying FiniteCards.Height10Part05 +replaying FiniteCards.Height09Part01 +replaying FiniteCards.Height15Part01 +replaying FiniteCards.Height04Part02 +replaying FiniteCards.Height13Part04 +replaying FiniteCards.Height10Part02 +replaying FiniteCards.Height12Part05 +replaying FiniteCards.Height14Part02 +replaying FiniteCards.Height07Part04 +replaying FiniteCards.Height05Part05 +replaying FiniteCards.Height03Part02 +replaying FiniteCards.Height03Part01 +replaying FiniteCards.Height07Part01 +replaying FiniteCards.Height11Part06 +replaying FiniteCards.Height12Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part07 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height17Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part05 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height20Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height21Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height18Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height17Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part06 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part07 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height19Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height18Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part08 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part07 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part06 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part05 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part05 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part06 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part06 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part03 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part05 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part05 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part06 +replaying OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +replaying OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +replaying OAI.GameTheory.SnakyTwentyOne.Semantics.Geometry +replaying OAI.GameTheory.SnakyTwentyOne.Semantics.Game +replaying OAI.GameTheory.SnakyTwentyOne.Model diff --git a/evidence/snaky-finite-v1/proof/nonempty-input.lean b/evidence/snaky-finite-v1/proof/nonempty-input.lean new file mode 100644 index 0000000..a656ab5 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/nonempty-input.lean @@ -0,0 +1,25 @@ +-- Generated by scripts/snaky_proof.py generate; checked without rewriting. +import SnakyFinite +namespace FiniteCongruenceChecks.SnakyFinite.Binding +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 +private def target : Finset Cell := ([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell).toFinset +private def envelope : Finset Cell := ([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11), (0, 12), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (9, 16), (10, 0), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (10, 16), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (11, 15), (11, 16), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (12, 16), (13, 1), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (13, 15), (14, 1), (14, 2), (14, 3), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 11), (14, 12), (14, 13), (14, 14), (15, 3), (15, 4), (15, 5), (15, 6), (15, 7), (15, 8), (15, 9), (15, 10), (15, 11), (15, 12), (15, 13), (15, 14), (16, 4), (16, 5), (16, 6), (16, 7), (16, 8), (16, 9), (16, 10), (16, 11)] : List Cell).toFinset +private def square : Finset Cell := (Finset.Icc (0 : ℤ) 16).product (Finset.Icc (0 : ℤ) 16) +private def initialM : Finset Cell := ([(8, 8)] : List Cell).toFinset +private def initialB : Finset Cell := ([] : List Cell).toFinset +private def targetWin (M : Finset Cell) : Prop := ∃ (r : Fin 8) (t : Cell), target.image (placement r t) ⊆ M +theorem target_exact : snaky = target := by decide +kernel +theorem envelope_exact : envelope_727 = envelope := by decide +kernel +theorem square_exact : square17 = square := by decide +kernel +theorem inputs_exact : initialM = ∅ ∧ initialB = ∅ ∧ (727 : Nat) = 727 := by decide +kernel +theorem counts_exact : envelope.card = 251 ∧ square.card = 289 := by decide +kernel +private theorem win_exact : HasSnaky = targetWin := by + funext M + simp only [HasSnaky, targetWin, target_exact] +theorem checked_envelope : FiniteWins envelope targetWin 21 initialM initialB := by + rw [← envelope_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.envelope_wins +theorem checked_square : FiniteWins square targetWin 21 initialM initialB := by + rw [← square_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.square_wins +end FiniteCongruenceChecks.SnakyFinite.Binding diff --git a/evidence/snaky-finite-v1/proof/nonempty-input.log b/evidence/snaky-finite-v1/proof/nonempty-input.log new file mode 100644 index 0000000..8341072 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/nonempty-input.log @@ -0,0 +1,3 @@ +/tmp/snaky-recovery-c3af350005f413554aea03db8cbf2c4c2d09e31b/runs/snaky-proof/nonempty-input.lean:14:77: error: Tactic `decide` proved that the proposition + initialM = ∅ ∧ initialB = ∅ ∧ 727 = 727 +is false diff --git a/evidence/snaky-finite-v1/proof/summary.json b/evidence/snaky-finite-v1/proof/summary.json new file mode 100644 index 0000000..155ecd7 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/summary.json @@ -0,0 +1,1683 @@ +{ + "schema_version": 1, + "status": "passed", + "claim": { + "schema_version": 1, + "namespace": "finite-congruence-atlas/snaky-finite-v1", + "id": "context:family-187:snaky:finite-board-21:v1", + "kind": "finite_board_strategy", + "evidence_status": "lean_proof_with_recorded_kernel_replay", + "statement": "Maker can force Snaky within 21 actual claims on the exact 251-cell envelope, and on the square with integer coordinates 0 through 16 in both directions.", + "scope": "One exact 728-card certificate, two specified finite boards, empty initial position; all legal board-contained Breaker replies.", + "assumptions": [ + "Maker moves first; players alternate claiming one fresh cell of the selected board.", + "Maker wins by owning a translated, rotated or reflected copy of the six specified target cells.", + "The game ends when Maker wins; no Breaker reply after victory is required.", + "Lean's kernel and only the standard axioms listed in the receipt are trusted." + ], + "limits": [ + "This formalizes the source paper's existing 21-Maker-claim finite-board corollaries. It does not establish a new bound, optimality, or a smallest board.", + "The formal result is a finite-board strategy-tree guarantee, not an extracted or benchmarked executable policy.", + "The 728-card theorem certificate is distinct from the historical 616-card comparator reconstruction.", + "The independent Python certificate reconstruction is tested computation, not a formally verified implementation.", + "Saved receipt replay checks recorded sources, commands, artifacts and bindings. It is not a new kernel execution or an authenticated attestation.", + "No general translation correctness or improved agent reasoning is established. Model benchmarks and training remain paused." + ], + "values": { + "target": [ + [ + 0, + 0 + ], + [ + 1, + 0 + ], + [ + 2, + 0 + ], + [ + 3, + 0 + ], + [ + 3, + 1 + ], + [ + 4, + 1 + ] + ], + "card_index": 727, + "envelope": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 0, + 12 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 1, + 12 + ], + [ + 1, + 13 + ], + [ + 2, + 1 + ], + [ + 2, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 2, + 14 + ], + [ + 2, + 15 + ], + [ + 3, + 1 + ], + [ + 3, + 2 + ], + [ + 3, + 3 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 3, + 14 + ], + [ + 3, + 15 + ], + [ + 4, + 0 + ], + [ + 4, + 1 + ], + [ + 4, + 2 + ], + [ + 4, + 3 + ], + [ + 4, + 4 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 4, + 15 + ], + [ + 5, + 0 + ], + [ + 5, + 1 + ], + [ + 5, + 2 + ], + [ + 5, + 3 + ], + [ + 5, + 4 + ], + [ + 5, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 5, + 16 + ], + [ + 6, + 0 + ], + [ + 6, + 1 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 8 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 7, + 16 + ], + [ + 8, + 0 + ], + [ + 8, + 1 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 0 + ], + [ + 9, + 1 + ], + [ + 9, + 2 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 9, + 16 + ], + [ + 10, + 0 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 11, + 16 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 12, + 15 + ], + [ + 12, + 16 + ], + [ + 13, + 1 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 13, + 15 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 14, + 14 + ], + [ + 15, + 3 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 4 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "square_bounds": { + "x_min": 0, + "x_max": 16, + "y_min": 0, + "y_max": 16 + }, + "initial_maker": [], + "initial_breaker": [], + "certificate": { + "repository": "openai/math", + "commit": "1581d4cbdd69a0faf34b2089614fe2a814316a6a", + "path": "preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt", + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt", + "certificate_sha256": "3fa12d36a6d4dbb185e3f2808c8dfde13d85ee309afbca030d6ad17ae9fe3d04", + "byte_length": 38367, + "hash_encoding": "SHA-256 of exact original certificate bytes; no newline normalization." + } + }, + "conclusion": { + "predicate": "A finite-board strategy tree guarantees a translated or square-symmetry copy of the exact six-cell Snaky within the stated number of actual fresh Maker claims from empty Maker and Breaker sets; every legal on-board Breaker reply is covered, and victory needs no further reply.", + "maker_claims_at_most": 21, + "envelope_cells": 251, + "square_cells": 289 + }, + "theorems": { + "envelope": "FiniteCongruenceChecks.SnakyFinite.envelope_wins", + "square": "FiniteCongruenceChecks.SnakyFinite.square_wins" + }, + "applicable_lemmas": [ + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.fresh_cell", + "role": "A strict occupied-cell bound supplies a legal board-contained cell." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.finite_compose", + "role": "The finite resource invariant justifies pivot replacement and every legal Breaker continuation." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.board_wins", + "role": "Any finite board containing the exact final envelope and at least 42 cells supports the strategy." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.envelope_wins", + "role": "Empty initial position on the exact 251-cell envelope." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.square_wins", + "role": "Empty initial position on the exact 17 by 17 square." + } + ], + "citations": [ + { + "path": "lean/snaky/SnakySemantics.lean", + "sha256": "eed7dee5c079df33d8488018119dfdb48d8bc1bc6aeb70e6a23f679135e52f2b" + }, + { + "path": "lean/snaky/SnakyFinite.lean", + "sha256": "4481d384a4f7920d98088bd2cc10796d330e5ae9da11aeff718e0d949c27d3ff" + }, + { + "path": "lean/snaky/vendor-manifest.json", + "sha256": "ca09b16a386355c5aa5a46c91fa87b6979cfc809ddc01b55743d6199e6e63c22" + }, + { + "path": "lean/snaky/SnakyBinding.lean", + "sha256": "c2067bfff6b6a25ce5dc3c6f5d42973943d19f1587954d627e3e774e9b261f8b" + } + ], + "upstream_context": { + "family": "187", + "revision": "1581d4cbdd69a0faf34b2089614fe2a814316a6a", + "scope_url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/lean/docs/187.md", + "paper_url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/build/strategy.tex", + "role": "The paper states the finite-board corollaries. The selected upstream Lean theorem covers the infinite grid." + } + }, + "limits": [ + "This formalizes the source paper's existing 21-Maker-claim finite-board corollaries. It does not establish a new bound, optimality, or a smallest board.", + "The formal result is a finite-board strategy-tree guarantee, not an extracted or benchmarked executable policy.", + "The 728-card theorem certificate is distinct from the historical 616-card comparator reconstruction.", + "The independent Python certificate reconstruction is tested computation, not a formally verified implementation.", + "Saved receipt replay checks recorded sources, commands, artifacts and bindings. It is not a new kernel execution or an authenticated attestation.", + "No general translation correctness or improved agent reasoning is established. Model benchmarks and training remain paused." + ], + "hash_encoding": "SHA-256 of UTF-8 file bytes with CRLF normalized to LF; no other byte changes.", + "source_hashes": { + "scripts/snaky_proof.py": "d07a9623b0e18ad2c68d51dc4d08115adbe4f37f5664456aa90ce1799591fdb5", + "scripts/check_snaky.py": "39557ec80096081efac4f5f8f0182383a4d23af855bb652a8108fa4228ee2d42", + "evidence/snaky-finite-v1/certificate.txt": "3fa12d36a6d4dbb185e3f2808c8dfde13d85ee309afbca030d6ad17ae9fe3d04", + "evidence/snaky-finite-v1/claim.json": "20eb112e32c82ab23fb0c8d7db880f4996cd5008a4c767c84fa67822cad3b201", + "lean/snaky/lean-toolchain": "d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b", + "lean/snaky/lakefile.toml": "fcd7faca2253f2e936e294694c5d691b1ff43e8a168a9bf3f283e6570060acad", + "lean/snaky/lake-manifest.json": "5dda7eda39168cec70584a4b94d61681a7838d3daf43d093f31f4c4aaddf8e68", + "lean/snaky/vendor-manifest.json": "ca09b16a386355c5aa5a46c91fa87b6979cfc809ddc01b55743d6199e6e63c22", + "lean/snaky/generate_finite_cards.py": "475e39c9415fedb0afd237cc19a83fe3f267120aeea2ea34ee5f69009212ab2c", + "lean/snaky/UPSTREAM_LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "lean/snaky/UPSTREAM_NOTICE.md": "1d9cac3fb50ac6ab0ec3000c11486056141aa51e6371e08503512843aa4bcab6", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height01Part01.lean": "b721851d44936e696a7ca108bc258a9cff38340751b3d779e2cbbf8d8b5b5036", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part01.lean": "59d96363dfcfba2711d08567a0f536af7f4ec54cc777c823c78d4b5f6b905aa4", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part02.lean": "0d57456db981f46183771645e5176837cf7d22bfddbb1a9ee2651bc0cfe900e4", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part01.lean": "09869ff7e389b199966af69e5e2b1b8c4a617656d6277698a8c96aa4b021a4b9", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part02.lean": "f229e04ff8b7d9176d39b26b24bfaa88b3f26d2710340db46e5b1b1d22144fc6", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part03.lean": "1b9ddf7e48a2d55d51fc18ddc0f93bcb7b4dc048bd648d2d4e5a72d8bbdf17a3", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part01.lean": "f9e2556bf69c4f88311787cf0d663f0a24d2bfdd43762a6774f9133241b82b5b", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part02.lean": "b7371990d1a053b8dad99d5e3d0bdbfb4be5fc147d8ee5c7d886d89d4bc584e0", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part03.lean": "e80807a7f939ffebcdc234e68c234a3ac1c77e0571ee72c6aac569ff9f3e7b7d", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part04.lean": "93a6c395d391c2f2d73c0a6d6274c53904ed6a6b3e1f88a73781388ffdff6e34", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part05.lean": "878e72c12b9e84fef33a3ea7d649574d08e19565c5560441d7d863117b89e8c3", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part01.lean": "e8bbd9bc6e87400a19e7a80e23eb2a0d3424199590ca3803befc6ecd6ee5a25a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part02.lean": "dd932253e77d2f7292d44782e4b6e37a8ff93c2df170a1340f27834c37894cc3", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part03.lean": "53b601dc52ccff754ccf70084ef44d606d93b41beaf2f7dd61cca127fa799933", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part04.lean": "dd7bf148b9ad98c1430be052ef1f6e9e437ee111a32166443790f15175506777", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part05.lean": "aea13ebf283c4d058d25ada4ed15cec3c3b0ce062b05769aecbac509d309dda5", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part06.lean": "649732e2efb25248b34b40715c91d769d5074fc03c89ba0a43065aa09ebf93f7", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part07.lean": "ba0397ab80d2c5744520d4ea44eb6f857aabe35c7d1bfd787bbdd22f06269397", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part01.lean": "25631c997e43e5d2b93a65de3fa7b445be17232674796aba2572e7fea6f15852", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part02.lean": "c9676996ed11ffa3e24f78308318b2cd9100f36edca21633434ba629198ec813", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part03.lean": "9a6db2aec95eced43911499fbc2841ab1f831885bc087882be027b41b303a046", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part04.lean": "edb074c085baafc8a5dd469ff28d1650d0f51b99a0e46455f30a36a7996dbd7c", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part05.lean": "fb883f0172b0d7195cbc41290c6c2de9879221913ee699494f7179ed9fa5d162", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part06.lean": "d16fbbc1233561d5fa5295174fce0c97805b32c8351374413c7038982392ea33", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part01.lean": "25cd3b6dfb5d18f99a0a9a3a50a5b54f0bf2bf600c942b1fc17cefb7fef79b12", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part02.lean": "11eb252c6d440ed9f51bb56e78af089e155bbe71c9a560a69fc12c331695b1bd", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part03.lean": "706d293c21868a010c5b8eda2cd1cfdbfdf9378e60e8053c190e15f29b8d034f", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part04.lean": "b6ada6198549c57e2c1780de45025ea71667386a45e1a7e551b437ed5fda6a47", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part05.lean": "8f0684cca8d7bc6258c368e7ad5d14f55972a411f64f26e7ccc6f3258a673acc", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part06.lean": "243c2861da61125a2ae538143bd1016c70d888c90030174a43ba55f95f62e919", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part01.lean": "82c6d8311c44ad8d40aea9f0237156dad735197c0ae7986fd5c9169cd76eaf3b", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part02.lean": "78a39d42a9ce6b5ba0450598209571689a8ffd3ddecdf788c9080d2964b08694", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part03.lean": "a502d65803e3611d7df6e7933edb50a86a0f5d74ebfb134203864996c9a6efca", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part04.lean": "d383e19ead30aa84f8dfc1d91cba6bc899aea830b1bd8e75a71d535d8ac72753", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part05.lean": "aac655834b86fccaf58a123116ef69a4503d0254e74bf3a5313e87169b7e03d7", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part01.lean": "eb041abc50134f6a894027720e1f5a72d210885e27e798fa25ecbd40cfcc7b8e", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part02.lean": "d70ef317bc9b10e88176c5299878b37fea8ff32ef13d2705dc5f2e11fe6cd744", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part03.lean": "51e58151811ea564c431a3354866283620e588e911873f91232e57dff26f5d2d", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part04.lean": "c67800b85780fbc0a017ac90bb69aa43474735fbcd36eae20230cb56bacdd792", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part05.lean": "a96acbd788ebbc4414d0e61a7d06e3a65d860c83f1db354511eda3543d4e9076", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part06.lean": "e483d02b0f566c62b17bd12614bce69f9589b9de4d93000c9305bc645c84dc82", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part07.lean": "c64b6fc7441de2c2d3b92daf23c7fdba4448d42589bc46f79ebfb7dae00209a8", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part08.lean": "0d711b1ba2d8f0caf5e6188100216e78d3fb76ebfd63d7e8935d70a4f779681e", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part01.lean": "d8a501150730c5868dc1e87fa4e8f691df984e817b9b87fb454e9b86d12ebaf6", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part02.lean": "47128473825a65bb8a7c6edf869345edb33197e1b08b64452f7413b0b258ca5a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part03.lean": "90591ceddfdfb8a7109f4ec3ba1feac0c777d4aa8f98ef448a2081be2907c335", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part04.lean": "995aeb639e7a2ea3fc12b19382d26465d447e8fbfd12bfa275931f3dd05b3416", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part05.lean": "adbd7834740f2e09d435c743cb00ad078165321a388e86d7f0e4a07593e22846", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part06.lean": "941557ad54a116a5c5353f3abb2d347e995a301ed6d3fb9dd482ddae01c73a7d", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part07.lean": "16bb244088a706cb45bba2c479a60c1ee525d46ab52069c5e27018251c199c6a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part01.lean": "2afe7b6b6d805fec07aef8b1560f7c7c10f5ee1ea2e60131cd2991c132a14425", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part02.lean": "6052574dc2afcc7933532c978ae9f50104b000d3f9e7d23bde74c7a984aafd33", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part03.lean": "c955d181f3d7e17739df4ce36a8e306f067e7ecd47dad1e301a603fbaeccbd24", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part04.lean": "3e15ffd5811c739975a3cccd95bd44abe635f97b9baaed944841b751365afd22", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part05.lean": "75f02f38d91fec7e334a0aa89450a0c27b728be98221d7559964ae0eb0e811e0", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part06.lean": "744342de6ed465e062d443e918dcbf298636856e35958cc7afa32f827dde6da1", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part01.lean": "98ada75cffa280d9bfe02e5510507cdb7a425d326652119fd676e2a612b7de98", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part02.lean": "92978a0d11d3c74f49f2fed81eb75f7296610af3a4c4cd890f0b695009d9bb63", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part03.lean": "9caf9a13e979d827a4c0d74deca5f32c54f4b85c2e7d87ffde7015f02e82e0fb", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part04.lean": "45ab2b20c2db4517ef9db6d8c10849f623b78b4e0e90ed33532f2c456c47646a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part05.lean": "844faee78ca99c9bf2644389ae17459584ed4bd76b1183b44407ea336a001e00", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part01.lean": "c7d05c2ae8c69a2b0d985c2e18edeab63af7e03276ecf47ed80768f730f43cec", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part02.lean": "98283cc58c87f7dbd87cb88ff0ba4b897e7683cafee56c1341610fc81f9a4c55", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part03.lean": "4e604e82c10e2d76f1b2c9a39d96f2f7472c0a8d3fc5f3c109668ba193d1bfa5", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part04.lean": "c6eb8cd09091be55e2bd853d8d0a02c6f3b01e56cf187831d866fe7c72481d16", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part05.lean": "f13ea4353c6cda2dbf684a2734e92f5064822170665155699c5113771be3f3a3", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part06.lean": "b4eb63c7fefeb0a5da6d8a047be13a9bb988a0abc0fa0b2e8e090e7952c2b3a4", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part07.lean": "608570161b4a67b15a575d09664f5032ae854a881950cf6a98e9cf7c972138ca", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part01.lean": "cdcae9363b98149cce6a8a6d95b255bbb928b19226ad53a0efbe0283de9a2f68", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part02.lean": "536089a57e85902db6c1d5b125a4346fc8669ae9aba55099faba30ed1bbbc78a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part03.lean": "78867488bf9599a41719f74e42c34d5bd21047308382079ba3b59b408d5120a3", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part04.lean": "ce1b0fa24cc8ed5050692cc200401c05f27c80ec295e2337cf687055efe7a751", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part01.lean": "95030470ead192c47b9115eed23c003978646393f5ca4f6257a0a1dde0ba7195", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part02.lean": "8d849760c2d74d70cf77c7ccbceca941ebe3fdf867f86afd13911f8e5b194ca2", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part03.lean": "d859675955b216884012b25c82b2c86f0ee159ed7d8fd51320fac584339946ac", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part04.lean": "03498c2351fbd34ae0d95e0e971856f79593df844fc0190a7a0c921cd951da52", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part01.lean": "486549710154751edc1a3b719d1780e0b7bf0aa2955b7d3961e7f4a251ed7248", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part02.lean": "03dfedd9067aaf0644c6d76d75b470141dfd6eb48495eed2c9d3b7bc0a49aed7", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part03.lean": "a9b209921b6691c59d893c8d58eaab64f359707778b8785da65959491164610c", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part01.lean": "060e3a5d9d3b5123433eb50d186c38679892e6663a7c1405ae21c77bc001e862", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part02.lean": "4bd93d460827cf7c577fa113136abd40a53f5a8da1c6cd31f945ddd38d7c24ea", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part01.lean": "154698a2eafd7ab3118236a2f7c772c1b2057846780457f55f074703c267765b", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part02.lean": "fc1ea2edfb94e051c937f84b1add1adc18fd106fcc5e2bf8a60ba5b26328acc9", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height19Part01.lean": "59c407a3ab501823540cf7732c8a9589ecb1a87a73af2776abdfa06c6da30bbb", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height20Part01.lean": "579f5ac435486638f55cba08fe32d2762291d7d3eecd2f54056f491e396fb6c1", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height21Part01.lean": "4f89721d3d39ac9e4e253edc1cbe367f5a4b7db7a15d6241e28951899fa32845", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Certificate/Operations.lean": "e69c168bfdf68f10052ceb9963a4013ddf536bd15ac79f5522fe932e82364a03", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Certificate/Summary.lean": "93ec0b599d3ed2628af92fe631dcf1c185fa0a44c3a532cf3c9179edfe1c9f87", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Main.lean": "a62fa55a65fd74a1bb9a06509a668feba17a0ce589586e72ffee0c6d83134e28", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Model.lean": "e2b6365603299d20d407519c365561f330d03af3e579c0042f19cdc2657df8b0", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Game.lean": "1d20aa7e7c30c525e6daf2a0145668bbd50b42386e2f4523a96fa982b295730a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Geometry.lean": "0d07595a7c774d1a7c6954f2241d32635457f84500ab32016f55a48e563655db", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Policy.lean": "c5feb030221603a62c91caaff754700b20da2c519a5bc05cf797f2dcd79598e5", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Replies.lean": "b7571f5cce7fa672f93e00a74b2cd5d5a1f8d694f4ba791a9d421e27bf3c56b2", + "lean/snaky/FiniteCards/Height01Part01.lean": "8ce6f26470a0ef7a90e273f15612ce7b028711ee895b0b28a660bd7333725438", + "lean/snaky/FiniteCards/Height02Part01.lean": "c1903729797b3d1fbaa149af328ec069d8eaff2cf148fea54e3251f9bbb562ea", + "lean/snaky/FiniteCards/Height02Part02.lean": "a0bae259e9753ba1da55d5326fac3c16e92b2209fbccbb46cb22841157581677", + "lean/snaky/FiniteCards/Height03Part01.lean": "cb55ef2c57a305d7ed4bcc8bfc18b0c74d4d8dcfeaa6ac746253d4c430fbab77", + "lean/snaky/FiniteCards/Height03Part02.lean": "c34a9ea623d76f93a17d8c2a13be5a6ee56f8cb46a25fad1ecfa31307b73364d", + "lean/snaky/FiniteCards/Height03Part03.lean": "f1eecfb54d82c2e1e33fcc25cbe9655f94a7e2fee035abfa8c914a0155a7b080", + "lean/snaky/FiniteCards/Height04Part01.lean": "bdaba8a61047af24723f05d7b042d9ae0d1ddd02e581b1fc267788e2ad7adc39", + "lean/snaky/FiniteCards/Height04Part02.lean": "51c83535ab4a18e778b77a4e9503eb2e2dcaf02ffce27b278e48c9cce767a9b0", + "lean/snaky/FiniteCards/Height04Part03.lean": "1d5034d925bc8a468a2b6b402801531874eea33ad78f35fb2ff92e5348c056a7", + "lean/snaky/FiniteCards/Height04Part04.lean": "542c4a04bffbeed6f501e063a6fd3ab61cdcb51283dc631668ac11993c3cfee1", + "lean/snaky/FiniteCards/Height04Part05.lean": "a6ca72ee5cb4c215f423139a700c8c200478e549b98d45f50e9c7a4ba912b8b7", + "lean/snaky/FiniteCards/Height05Part01.lean": "e0cb7028d42b55ad85a33ef13e58825eff2eea3312d31402f8ff7efd215601fe", + "lean/snaky/FiniteCards/Height05Part02.lean": "1178cbfea2ba0c83d47503e7b0eaa9871d715dae439da6d72d573fb3ec7adaac", + "lean/snaky/FiniteCards/Height05Part03.lean": "8d4e40b5a555fd47b666785b1cda6ab2a531b81b77ef87220eb4f0e3a506b90e", + "lean/snaky/FiniteCards/Height05Part04.lean": "f8a78bf54097fe92f5c4746fb0c83eeac7e080aa4533bb711e4460054872af57", + "lean/snaky/FiniteCards/Height05Part05.lean": "09e1efacebd597af8e92687a2879e17ce9f7c15c9e22d720ddb22619942e2989", + "lean/snaky/FiniteCards/Height05Part06.lean": "f67ad9130e8bdfc6cf104e9bed5cdd9fbc0f04a447842bee9debe7260d6a1681", + "lean/snaky/FiniteCards/Height05Part07.lean": "334daa658b65797fa70ed4f953722d831e8bee733869365e5539483e58dab944", + "lean/snaky/FiniteCards/Height06Part01.lean": "17576b955c548607046b479c46dfbae448c720a4507f3982c4980ca1afc38ffc", + "lean/snaky/FiniteCards/Height06Part02.lean": "b552030d555043e774856df2a94590c2cc95355fb607f3a668a316619520cbb5", + "lean/snaky/FiniteCards/Height06Part03.lean": "15a3e7f34ec61796b4e0c4b0c410544c2174e7869f42f3bd26639859056f45c5", + "lean/snaky/FiniteCards/Height06Part04.lean": "3a3cf04595892670a66d3e80ecb55fda0e532a6ebb70e2f4debffe327a7b01f7", + "lean/snaky/FiniteCards/Height06Part05.lean": "2eb0286ed43004820eb39c919ee065bcc4a588ff638c26aa4d64ede93ddb2d31", + "lean/snaky/FiniteCards/Height06Part06.lean": "6ccdbf6bd6a5d3508e17dbed960948556f31952c2496efc500c2999a4d7642de", + "lean/snaky/FiniteCards/Height07Part01.lean": "625d9c23b37c7f45d5f777059168361eafb564c42264b599b7cd3f36e4c7873a", + "lean/snaky/FiniteCards/Height07Part02.lean": "c711590b67f3bb39c7105dcccc78287c425c80d6191f8d10d09bb60e5e1a6a7e", + "lean/snaky/FiniteCards/Height07Part03.lean": "ec76f4a3a64fc6526be1df60dde7b3179a382756832333a8e8481d1f030a1b7a", + "lean/snaky/FiniteCards/Height07Part04.lean": "5aa1cee89196d89de0ac203aac3d98b3abe89ecfa56af6a795b8c18cfaa76e2a", + "lean/snaky/FiniteCards/Height07Part05.lean": "38947f99f3f589ecbacff7aa69bf53081a7535a55bb760d2ae60c3618b9c4712", + "lean/snaky/FiniteCards/Height07Part06.lean": "3f09b8d521b4cbafb81792163e571a538e6a6fb799ea2016a513a18fb7475723", + "lean/snaky/FiniteCards/Height08Part01.lean": "6892b7c97579655a7f8fca6e15e05e49abbe5126e27dbeeae620dcbb7c537c06", + "lean/snaky/FiniteCards/Height08Part02.lean": "ec75af9d0db5633275670ebcd909448a75b1cab5484b2841c42be44780367983", + "lean/snaky/FiniteCards/Height08Part03.lean": "fbb45f63c5e559fcd95712e2ddfbc1431eb3820bca2ccdd6e3d1b07466554c95", + "lean/snaky/FiniteCards/Height08Part04.lean": "50eebd526c4eabf660692bfb0dbcf39ec6c31a17ba7df9856ddb3524d4dd0f59", + "lean/snaky/FiniteCards/Height08Part05.lean": "b1848df70edceaaed8cd77289dbfcb9a643c141589b53fd341bfe99fa4994523", + "lean/snaky/FiniteCards/Height09Part01.lean": "4fadfde21993ed34175f51a17a8da454ca73a30ef5a92924e89d00142557f85b", + "lean/snaky/FiniteCards/Height09Part02.lean": "a694c0e41c7ee9d2b3b5a98e2db2afffdba395b57fdd5d84a87f0b6c5b377f1c", + "lean/snaky/FiniteCards/Height09Part03.lean": "3a000c50c81817c75ae753f63fd361abf8194789300999cef122e23ea69575c4", + "lean/snaky/FiniteCards/Height09Part04.lean": "b9720a4e14803cfbefcebdb8bf20cb6c4c2727d33d302bd9bc8329dc3ee9628b", + "lean/snaky/FiniteCards/Height09Part05.lean": "2ca75f0160bf4c7152aa0556c3c1881d25e6c52572e035bf7680ed6782a05593", + "lean/snaky/FiniteCards/Height09Part06.lean": "fad38a2cd0a68718c1f6084777724a730edeb736cf128115b39d929a26ef6344", + "lean/snaky/FiniteCards/Height09Part07.lean": "127c65ece69270fc38b0ba41704f40c3987ae6af1ec905ba59d6a52db64fcdeb", + "lean/snaky/FiniteCards/Height09Part08.lean": "03ba34ebf464b50646241ad20dc4fce747f735a7efcc715f90f31e43ba2ca7cd", + "lean/snaky/FiniteCards/Height10Part01.lean": "40e2de479acf3090647b8a07e0fc21d911a7b31649b4d1be1bb027ded311c452", + "lean/snaky/FiniteCards/Height10Part02.lean": "f9439f5946dcce6f4d3ca9d07759239cc78c2f9c60284bc7aec0df1f538a6c35", + "lean/snaky/FiniteCards/Height10Part03.lean": "baef28b1f9ff5c7dd6caf7116ca5da3293531a3377add4cb25b7090d727b1497", + "lean/snaky/FiniteCards/Height10Part04.lean": "47db043cb560943c62f076bbb5605223603113c79d7b12a5965bf417300e9d24", + "lean/snaky/FiniteCards/Height10Part05.lean": "0c60b4d4db00e4f59ea41007d98882627fa29fd361c84082b797527fd67b5c33", + "lean/snaky/FiniteCards/Height10Part06.lean": "85070a217949766901913a2851f2ba2f9ff9b61f3b01517e7818b8d2310afb40", + "lean/snaky/FiniteCards/Height10Part07.lean": "bc365b0393508083a04dbf01a8ac160e3c14c726fa0c1c93697a1d055be6aa39", + "lean/snaky/FiniteCards/Height11Part01.lean": "3425a345d9a9229e7410d593f2ebc0ca18795c4ca60bec743225bede9424ddb9", + "lean/snaky/FiniteCards/Height11Part02.lean": "0158daf583bc010542481565077fd485fd5047231fcbfe6fca3875e13841f1d1", + "lean/snaky/FiniteCards/Height11Part03.lean": "21ba2fa51aa15dec4752c3eb0eef99352fe43deb50172d9ad99d205516ae6890", + "lean/snaky/FiniteCards/Height11Part04.lean": "471e8995a02c5ec8ce1c66d1a39fb2d19dfef5796f279986bf730854230f53f4", + "lean/snaky/FiniteCards/Height11Part05.lean": "ecdd28cb39c48c1072deead4af2b4163b0bc0c05a385623a84d91778ffdf91b8", + "lean/snaky/FiniteCards/Height11Part06.lean": "c4dc54e1ac1eb16bbd07a6d485cf0b53c422a7c2f73c1c744a82178a45171fa3", + "lean/snaky/FiniteCards/Height12Part01.lean": "63f57780773fe4cf7354c2344ca02584b910251b777bcb1772a6ae8bbf79dff3", + "lean/snaky/FiniteCards/Height12Part02.lean": "a88ca3b2be232ccef987d07bb553db35e1c27fef006837391b5592cd05182361", + "lean/snaky/FiniteCards/Height12Part03.lean": "fb468e0e694f748cd4cb78b368d3ef417569a421889605f0daa29de700c1d6d6", + "lean/snaky/FiniteCards/Height12Part04.lean": "017ee2edc6a78628ac6209d868e4f78b4c947e4a47d240aede20e1082d4c2b59", + "lean/snaky/FiniteCards/Height12Part05.lean": "09ed1f540e2fbc1920fdabb71aedd628ef4a598834d66ed85270315f77ecd389", + "lean/snaky/FiniteCards/Height13Part01.lean": "287dbc1c1a78fde0928e61c0941c712d7f4ae2b7b45c01f1cf29e8b219384272", + "lean/snaky/FiniteCards/Height13Part02.lean": "ebdeec27330451c3a703529df37b510051185465fd0faf67be41782ffcdb6cb9", + "lean/snaky/FiniteCards/Height13Part03.lean": "1eae92ec890f11692c8e9ce4d0023baa52325791e610e99e2c0147c8b5c17b83", + "lean/snaky/FiniteCards/Height13Part04.lean": "735a6a5eb3808843c8ad6d83bf08e505e5d288049e37ac62f82e5728e21111ee", + "lean/snaky/FiniteCards/Height13Part05.lean": "092ce445abcc756b463e52e2fa357f37f975af3bd83138ce1ae3fdccdb966a53", + "lean/snaky/FiniteCards/Height13Part06.lean": "07d245a73ca81f362d6ce9cc88e6b9abdd47cb3224959088898b587bde9aba6d", + "lean/snaky/FiniteCards/Height13Part07.lean": "8322790eaea202f2b9017a7b23a6c26572157506b714e1bd43cffcffcc4bc171", + "lean/snaky/FiniteCards/Height14Part01.lean": "31bedc3edcd7f853fb99e951eca5257715a8338943aa4ed4419b40fe77c00967", + "lean/snaky/FiniteCards/Height14Part02.lean": "ba89a77b16358751cf9471c17fa3acfb2cb006fab5df75ed50a7d5e43ca17381", + "lean/snaky/FiniteCards/Height14Part03.lean": "0757d385cb3dd8416e9f16c0f17c55466d48155c8657405770256d451762c77b", + "lean/snaky/FiniteCards/Height14Part04.lean": "e17a8f7aa7b8d57f2be9d556cb894aeff05ef28b647a7bd52f5356d7ca7a8290", + "lean/snaky/FiniteCards/Height15Part01.lean": "29e6a73a81629ab9b121d22c4c5664835f2a5bc6eaae8426a4ba6d4cd944aa45", + "lean/snaky/FiniteCards/Height15Part02.lean": "9a5d3faaa804999caec3be6043cc4cb98396651ad742d6e4571bbf190667e0dc", + "lean/snaky/FiniteCards/Height15Part03.lean": "980212d37614d7c5ec333a94acd3dea988576baf5c92d7c6b183f647bda13c81", + "lean/snaky/FiniteCards/Height15Part04.lean": "a930353524d4c5c426526cb96c6900b21f765e7ab9001414675dddac91c722f1", + "lean/snaky/FiniteCards/Height16Part01.lean": "fabda38ff2d37b1a768e8607048d0a7b8343d416b3bfce96a2df3f82d6666911", + "lean/snaky/FiniteCards/Height16Part02.lean": "6746923d486a2220b87e1c7e8e6aa5243091d617bfdc9aab7f686715fe5054a6", + "lean/snaky/FiniteCards/Height16Part03.lean": "5842f9ed2a8cbb547ace0b8f18866a673e18cdbb2b55994718e519a541683fa1", + "lean/snaky/FiniteCards/Height17Part01.lean": "9656252931887c6cd9fd6256be35d9be673baeb46e544f88ca23f739b7af2a75", + "lean/snaky/FiniteCards/Height17Part02.lean": "aacbb495500616854cd8e7f7b1240261cfe13c19201a033fe8d56b1540c19c94", + "lean/snaky/FiniteCards/Height18Part01.lean": "9fd3e2424aa4fc06b73005f40bbcb6129e133de7ffc548669ab14f552c27bea3", + "lean/snaky/FiniteCards/Height18Part02.lean": "45141c8501b3011db96fc1ee9a5e3d3abadf161eab2bf24e30aa64594c34f114", + "lean/snaky/FiniteCards/Height19Part01.lean": "a0fce1dbbac2e34b740bec1ed593009770553d34a1b3311e0e80d54a87962ca9", + "lean/snaky/FiniteCards/Height20Part01.lean": "9bef588333dbffb781fab452f2b6fbe487532f13eb0d7a85e9af8f2577cad832", + "lean/snaky/FiniteCards/Height21Part01.lean": "5126d8214f7193a4421fa2a9968583721c5a929f7f206e04bbcb3454563b4f6e", + "lean/snaky/SnakySemantics.lean": "eed7dee5c079df33d8488018119dfdb48d8bc1bc6aeb70e6a23f679135e52f2b", + "lean/snaky/SnakyFinite.lean": "4481d384a4f7920d98088bd2cc10796d330e5ae9da11aeff718e0d949c27d3ff", + "lean/snaky/SnakyBinding.lean": "c2067bfff6b6a25ce5dc3c6f5d42973943d19f1587954d627e3e774e9b261f8b" + }, + "environment_overrides": { + "LEAN_NUM_THREADS": "1", + "MATHLIB_NO_CACHE_ON_UPDATE": "1" + }, + "computational_evidence": { + "path": "evidence/snaky-finite-v1/computational.json", + "sha256": "24a023e3e6c65810ec0afdf896f3daf51e78bb582995e0bc7f8f9c0de98837ec" + }, + "stages": [ + { + "name": "version", + "command": [ + "lake", + "env", + "lean", + "--version" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 0, + "timeout_seconds": 2400, + "duration_seconds": 3.125, + "started_utc": "2026-10-19T19:34:58.974500+00:00", + "finished_utc": "2026-10-19T19:35:02.099254+00:00" + }, + { + "name": "dependencies", + "command": [ + "lake", + "exe", + "cache", + "get" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 0, + "timeout_seconds": 2400, + "duration_seconds": 6.986, + "started_utc": "2026-10-19T19:35:02.100773+00:00", + "finished_utc": "2026-10-19T19:35:09.087061+00:00" + }, + { + "name": "build", + "command": [ + "lake", + "build", + "SnakyBinding" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 0, + "timeout_seconds": 3600, + "duration_seconds": 11.8, + "started_utc": "2026-10-19T19:35:09.088338+00:00", + "finished_utc": "2026-10-19T19:35:20.888352+00:00" + }, + { + "name": "axioms", + "command": [ + "lake", + "env", + "lean", + "{out}/Audit.lean" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 0, + "timeout_seconds": 2400, + "duration_seconds": 20.428, + "started_utc": "2026-10-19T19:35:20.889354+00:00", + "finished_utc": "2026-10-19T19:35:41.317192+00:00" + }, + { + "name": "kernel", + "command": [ + "lake", + "env", + "leanchecker", + "-v", + "OAI.GameTheory.SnakyTwentyOne.Model", + "OAI.GameTheory.SnakyTwentyOne.Semantics.Game", + "OAI.GameTheory.SnakyTwentyOne.Semantics.Geometry", + "OAI.GameTheory.SnakyTwentyOne.Certificate.Operations", + "OAI.GameTheory.SnakyTwentyOne.Cards", + "FiniteCards", + "SnakySemantics", + "SnakyFinite", + "SnakyBinding" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 0, + "timeout_seconds": 7200, + "duration_seconds": 1303.713, + "started_utc": "2026-10-19T19:35:41.318503+00:00", + "finished_utc": "2026-10-19T19:57:25.032311+00:00" + }, + { + "name": "changed-target", + "command": [ + "lake", + "env", + "lean", + "{out}/changed-target.lean" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 1, + "timeout_seconds": 2400, + "duration_seconds": 16.03, + "started_utc": "2026-10-19T19:57:25.047233+00:00", + "finished_utc": "2026-10-19T19:57:41.076779+00:00" + }, + { + "name": "changed-envelope", + "command": [ + "lake", + "env", + "lean", + "{out}/changed-envelope.lean" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 1, + "timeout_seconds": 2400, + "duration_seconds": 14.918, + "started_utc": "2026-10-19T19:57:41.079002+00:00", + "finished_utc": "2026-10-19T19:57:55.997383+00:00" + }, + { + "name": "changed-square", + "command": [ + "lake", + "env", + "lean", + "{out}/changed-square.lean" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 1, + "timeout_seconds": 2400, + "duration_seconds": 14.567, + "started_utc": "2026-10-19T19:57:55.998431+00:00", + "finished_utc": "2026-10-19T19:58:10.564953+00:00" + }, + { + "name": "wrong-move-bound", + "command": [ + "lake", + "env", + "lean", + "{out}/wrong-move-bound.lean" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 1, + "timeout_seconds": 2400, + "duration_seconds": 15.369, + "started_utc": "2026-10-19T19:58:10.567699+00:00", + "finished_utc": "2026-10-19T19:58:25.936584+00:00" + }, + { + "name": "wrong-card", + "command": [ + "lake", + "env", + "lean", + "{out}/wrong-card.lean" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 1, + "timeout_seconds": 2400, + "duration_seconds": 15.222, + "started_utc": "2026-10-19T19:58:25.937678+00:00", + "finished_utc": "2026-10-19T19:58:41.159577+00:00" + }, + { + "name": "nonempty-input", + "command": [ + "lake", + "env", + "lean", + "{out}/nonempty-input.lean" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 1, + "timeout_seconds": 2400, + "duration_seconds": 14.721, + "started_utc": "2026-10-19T19:58:41.160713+00:00", + "finished_utc": "2026-10-19T19:58:55.881701+00:00" + }, + { + "name": "unrelated-theorem", + "command": [ + "lake", + "env", + "lean", + "{out}/unrelated-theorem.lean" + ], + "cwd": "lean/snaky", + "status": "passed", + "failure_kind": null, + "exit_code": 1, + "timeout_seconds": 2400, + "duration_seconds": 14.369, + "started_utc": "2026-10-19T19:58:55.885505+00:00", + "finished_utc": "2026-10-19T19:59:10.254608+00:00" + } + ], + "artifacts": { + "Audit.lean": "557232d1735948205cdc299f6f04c68feca5ac51a6e0bd908ecb51c23f297270", + "axioms.log": "ee6611b79ea4ba944f7f84f5249e51c79aa0a29f37a442348e8a8f4317218876", + "build.log": "163fb6d214cac38bf07a43567ef6aa96d3c83f5090b03c3e601985d6ed90e6ca", + "changed-envelope.lean": "09dcb538cd327b2d643b34a01310b7f030635555e87100d6a2030aae40919cf6", + "changed-envelope.log": "aaf05646c138a5e2cfadc40801796927650a9d7aeddb4185135d3abcfd673bf3", + "changed-square.lean": "a164f229a96ccdd4e0fd28bc85d9e526d6eb1fe1f737671bc3fd715d9bb8741e", + "changed-square.log": "64e9f91ae9662f64a9c9093d74ca6b0dcb32af116509d162949125d9fc46736e", + "changed-target.lean": "e0c4f53b637461df801de33dcc35304723ba539b07cefd934bb6f84a99c6c81c", + "changed-target.log": "a41142412eadccc3e5ddeacb008268483b49026802aa48e0e76daf7055a772f1", + "dependencies.log": "29e284dc7d8024aa6a333a92d0b23035028d78ada47b37f7dd77d8e1a0293483", + "kernel.log": "2c00bad2ec2ad2e698cbe1be637427639026d9a2a527c0dc38279815b9655b9c", + "nonempty-input.lean": "dd97852ef1248ba6125bd2c744a58f1657b4c83f6576ec2bfb242f6cf6084926", + "nonempty-input.log": "7978c6b197071e8c2fd06104f50c6aa5e4b3b3e6ffb59ad3cb248932d5f3f416", + "unrelated-theorem.lean": "7f0df330be1fb6245ddd4cc2be2bb188b437df35f4992c3b707222cb3b747d21", + "unrelated-theorem.log": "f908a70b389cfbec20b6adc7521e33df18358f8bb39df36c68f048afe19ebdf4", + "version.log": "355a9a028f81641782d75d6e6b58dec70f29d2f61238a9e271690259d9bf5680", + "wrong-card.lean": "ff5de90e8fd5a0bbe6e910a97aeb1aa5bdef4286f127d00e89bbe97980bdf001", + "wrong-card.log": "097d7942670f90bd9418dfca4609bb9ab0ece298278e8f1f42849c1abb09b1bd", + "wrong-move-bound.lean": "700a2b952ea22cb9ec9450b77a5369646837fca6b9a6dbcd2ca5fb8771e1a664", + "wrong-move-bound.log": "11d8192ccb4a4ad3038bd69f74b69b143b2a5fa4c5130b7542c86e2ad7ca8df1" + }, + "started_utc": "2026-10-19T19:34:58.943599+00:00", + "axioms": { + "FiniteCongruenceChecks.SnakyFinite.FiniteWins.false_impossible": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.FiniteWins.zero_iff": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.fresh_cell": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.finite_immediate": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.finite_compose": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.envelope_card": [ + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.square_card": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.envelope_subset_square": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.square_membership": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.board_wins": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.envelope_wins": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.square_wins": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.target_exact": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.envelope_exact": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.square_exact": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.inputs_exact": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.counts_exact": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.checked_envelope": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.checked_square": [ + "Classical.choice", + "Quot.sound", + "propext" + ] + }, + "finished_utc": "2026-10-19T19:59:10.277482+00:00" +} diff --git a/evidence/snaky-finite-v1/proof/unrelated-theorem.lean b/evidence/snaky-finite-v1/proof/unrelated-theorem.lean new file mode 100644 index 0000000..42ad6eb --- /dev/null +++ b/evidence/snaky-finite-v1/proof/unrelated-theorem.lean @@ -0,0 +1,25 @@ +-- Generated by scripts/snaky_proof.py generate; checked without rewriting. +import SnakyFinite +namespace FiniteCongruenceChecks.SnakyFinite.Binding +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 +private def target : Finset Cell := ([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell).toFinset +private def envelope : Finset Cell := ([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11), (0, 12), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (9, 16), (10, 0), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (10, 16), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (11, 15), (11, 16), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (12, 16), (13, 1), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (13, 15), (14, 1), (14, 2), (14, 3), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 11), (14, 12), (14, 13), (14, 14), (15, 3), (15, 4), (15, 5), (15, 6), (15, 7), (15, 8), (15, 9), (15, 10), (15, 11), (15, 12), (15, 13), (15, 14), (16, 4), (16, 5), (16, 6), (16, 7), (16, 8), (16, 9), (16, 10), (16, 11)] : List Cell).toFinset +private def square : Finset Cell := (Finset.Icc (0 : ℤ) 16).product (Finset.Icc (0 : ℤ) 16) +private def initialM : Finset Cell := ([] : List Cell).toFinset +private def initialB : Finset Cell := ([] : List Cell).toFinset +private def targetWin (M : Finset Cell) : Prop := ∃ (r : Fin 8) (t : Cell), target.image (placement r t) ⊆ M +theorem target_exact : snaky = target := by decide +kernel +theorem envelope_exact : envelope_727 = envelope := by decide +kernel +theorem square_exact : square17 = square := by decide +kernel +theorem inputs_exact : initialM = ∅ ∧ initialB = ∅ ∧ (727 : Nat) = 727 := by decide +kernel +theorem counts_exact : envelope.card = 251 ∧ square.card = 289 := by decide +kernel +private theorem win_exact : HasSnaky = targetWin := by + funext M + simp only [HasSnaky, targetWin, target_exact] +theorem checked_envelope : FiniteWins envelope targetWin 21 initialM initialB := by + rw [← envelope_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.square_wins +theorem checked_square : FiniteWins square targetWin 21 initialM initialB := by + rw [← square_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.square_wins +end FiniteCongruenceChecks.SnakyFinite.Binding diff --git a/evidence/snaky-finite-v1/proof/unrelated-theorem.log b/evidence/snaky-finite-v1/proof/unrelated-theorem.log new file mode 100644 index 0000000..e40cd7b --- /dev/null +++ b/evidence/snaky-finite-v1/proof/unrelated-theorem.log @@ -0,0 +1,6 @@ +/tmp/snaky-recovery-c3af350005f413554aea03db8cbf2c4c2d09e31b/runs/snaky-proof/unrelated-theorem.lean:21:2: error: Type mismatch + square_wins +has type + FiniteWins square17 HasSnaky 21 ∅ ∅ +but is expected to have type + FiniteWins envelope_727 HasSnaky 21 ∅ ∅ diff --git a/evidence/snaky-finite-v1/proof/version.log b/evidence/snaky-finite-v1/proof/version.log new file mode 100644 index 0000000..3bdff92 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/version.log @@ -0,0 +1 @@ +Lean (version 4.34.1, x86_64-unknown-linux-gnu, commit 5045d0056413266e57c625dcd7c365b10e377c52, Release) diff --git a/evidence/snaky-finite-v1/proof/wrong-card.lean b/evidence/snaky-finite-v1/proof/wrong-card.lean new file mode 100644 index 0000000..6570337 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/wrong-card.lean @@ -0,0 +1,25 @@ +-- Generated by scripts/snaky_proof.py generate; checked without rewriting. +import SnakyFinite +namespace FiniteCongruenceChecks.SnakyFinite.Binding +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 +private def target : Finset Cell := ([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell).toFinset +private def envelope : Finset Cell := ([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11), (0, 12), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (9, 16), (10, 0), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (10, 16), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (11, 15), (11, 16), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (12, 16), (13, 1), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (13, 15), (14, 1), (14, 2), (14, 3), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 11), (14, 12), (14, 13), (14, 14), (15, 3), (15, 4), (15, 5), (15, 6), (15, 7), (15, 8), (15, 9), (15, 10), (15, 11), (15, 12), (15, 13), (15, 14), (16, 4), (16, 5), (16, 6), (16, 7), (16, 8), (16, 9), (16, 10), (16, 11)] : List Cell).toFinset +private def square : Finset Cell := (Finset.Icc (0 : ℤ) 16).product (Finset.Icc (0 : ℤ) 16) +private def initialM : Finset Cell := ([] : List Cell).toFinset +private def initialB : Finset Cell := ([] : List Cell).toFinset +private def targetWin (M : Finset Cell) : Prop := ∃ (r : Fin 8) (t : Cell), target.image (placement r t) ⊆ M +theorem target_exact : snaky = target := by decide +kernel +theorem envelope_exact : envelope_727 = envelope := by decide +kernel +theorem square_exact : square17 = square := by decide +kernel +theorem inputs_exact : initialM = ∅ ∧ initialB = ∅ ∧ (726 : Nat) = 727 := by decide +kernel +theorem counts_exact : envelope.card = 251 ∧ square.card = 289 := by decide +kernel +private theorem win_exact : HasSnaky = targetWin := by + funext M + simp only [HasSnaky, targetWin, target_exact] +theorem checked_envelope : FiniteWins envelope targetWin 21 initialM initialB := by + rw [← envelope_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.envelope_wins +theorem checked_square : FiniteWins square targetWin 21 initialM initialB := by + rw [← square_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.square_wins +end FiniteCongruenceChecks.SnakyFinite.Binding diff --git a/evidence/snaky-finite-v1/proof/wrong-card.log b/evidence/snaky-finite-v1/proof/wrong-card.log new file mode 100644 index 0000000..14391ad --- /dev/null +++ b/evidence/snaky-finite-v1/proof/wrong-card.log @@ -0,0 +1,3 @@ +/tmp/snaky-recovery-c3af350005f413554aea03db8cbf2c4c2d09e31b/runs/snaky-proof/wrong-card.lean:14:77: error: Tactic `decide` proved that the proposition + initialM = ∅ ∧ initialB = ∅ ∧ 726 = 727 +is false diff --git a/evidence/snaky-finite-v1/proof/wrong-move-bound.lean b/evidence/snaky-finite-v1/proof/wrong-move-bound.lean new file mode 100644 index 0000000..3c25b7f --- /dev/null +++ b/evidence/snaky-finite-v1/proof/wrong-move-bound.lean @@ -0,0 +1,25 @@ +-- Generated by scripts/snaky_proof.py generate; checked without rewriting. +import SnakyFinite +namespace FiniteCongruenceChecks.SnakyFinite.Binding +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 +private def target : Finset Cell := ([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell).toFinset +private def envelope : Finset Cell := ([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11), (0, 12), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (9, 16), (10, 0), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (10, 16), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (11, 15), (11, 16), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (12, 16), (13, 1), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (13, 15), (14, 1), (14, 2), (14, 3), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 11), (14, 12), (14, 13), (14, 14), (15, 3), (15, 4), (15, 5), (15, 6), (15, 7), (15, 8), (15, 9), (15, 10), (15, 11), (15, 12), (15, 13), (15, 14), (16, 4), (16, 5), (16, 6), (16, 7), (16, 8), (16, 9), (16, 10), (16, 11)] : List Cell).toFinset +private def square : Finset Cell := (Finset.Icc (0 : ℤ) 16).product (Finset.Icc (0 : ℤ) 16) +private def initialM : Finset Cell := ([] : List Cell).toFinset +private def initialB : Finset Cell := ([] : List Cell).toFinset +private def targetWin (M : Finset Cell) : Prop := ∃ (r : Fin 8) (t : Cell), target.image (placement r t) ⊆ M +theorem target_exact : snaky = target := by decide +kernel +theorem envelope_exact : envelope_727 = envelope := by decide +kernel +theorem square_exact : square17 = square := by decide +kernel +theorem inputs_exact : initialM = ∅ ∧ initialB = ∅ ∧ (727 : Nat) = 727 := by decide +kernel +theorem counts_exact : envelope.card = 251 ∧ square.card = 289 := by decide +kernel +private theorem win_exact : HasSnaky = targetWin := by + funext M + simp only [HasSnaky, targetWin, target_exact] +theorem checked_envelope : FiniteWins envelope targetWin 20 initialM initialB := by + rw [← envelope_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.envelope_wins +theorem checked_square : FiniteWins square targetWin 20 initialM initialB := by + rw [← square_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.square_wins +end FiniteCongruenceChecks.SnakyFinite.Binding diff --git a/evidence/snaky-finite-v1/proof/wrong-move-bound.log b/evidence/snaky-finite-v1/proof/wrong-move-bound.log new file mode 100644 index 0000000..251d3a5 --- /dev/null +++ b/evidence/snaky-finite-v1/proof/wrong-move-bound.log @@ -0,0 +1,12 @@ +/tmp/snaky-recovery-c3af350005f413554aea03db8cbf2c4c2d09e31b/runs/snaky-proof/wrong-move-bound.lean:21:2: error: Type mismatch + envelope_wins +has type + FiniteWins envelope_727 HasSnaky 21 ∅ ∅ +but is expected to have type + FiniteWins envelope_727 HasSnaky 20 ∅ ∅ +/tmp/snaky-recovery-c3af350005f413554aea03db8cbf2c4c2d09e31b/runs/snaky-proof/wrong-move-bound.lean:24:2: error: Type mismatch + square_wins +has type + FiniteWins square17 HasSnaky 21 ∅ ∅ +but is expected to have type + FiniteWins square17 HasSnaky 20 ∅ ∅ diff --git a/evidence/snaky-play-v1/example.json b/evidence/snaky-play-v1/example.json new file mode 100644 index 0000000..867e67d --- /dev/null +++ b/evidence/snaky-play-v1/example.json @@ -0,0 +1,5575 @@ +{ + "schema_version": 1, + "id": "example:family-187:snaky:eight-claim-branch:v1", + "title": "One Snaky play: eight Maker claims", + "kind": "illustrative_checked_execution", + "sources": { + "certificate": { + "path": "evidence/snaky-finite-v1/certificate.txt", + "sha256": "3fa12d36a6d4dbb185e3f2808c8dfde13d85ee309afbca030d6ad17ae9fe3d04", + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt", + "commit": "1581d4cbdd69a0faf34b2089614fe2a814316a6a" + }, + "oracle": { + "path": "scripts/check_snaky.py", + "sha256": "39557ec80096081efac4f5f8f0182383a4d23af855bb652a8108fa4228ee2d42" + }, + "generator": { + "path": "scripts/build_snaky_play.py", + "sha256": "77b0701590f0bd022240db0ca93bf46acc931024475454de143fc99c5bbafeac" + }, + "validator": { + "path": "scripts/check_snaky_play.py", + "sha256": "1d9cd05e8865fbf1965f8948e6369f2b9011ae48e9658e1404313161ac08e1ae" + }, + "root_claim_id": "context:family-187:snaky:finite-board-21:v1" + }, + "board": { + "name": "251-cell envelope of card 727", + "cells": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 0, + 12 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 1, + 12 + ], + [ + 1, + 13 + ], + [ + 2, + 1 + ], + [ + 2, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 2, + 14 + ], + [ + 2, + 15 + ], + [ + 3, + 1 + ], + [ + 3, + 2 + ], + [ + 3, + 3 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 3, + 14 + ], + [ + 3, + 15 + ], + [ + 4, + 0 + ], + [ + 4, + 1 + ], + [ + 4, + 2 + ], + [ + 4, + 3 + ], + [ + 4, + 4 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 4, + 15 + ], + [ + 5, + 0 + ], + [ + 5, + 1 + ], + [ + 5, + 2 + ], + [ + 5, + 3 + ], + [ + 5, + 4 + ], + [ + 5, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 5, + 16 + ], + [ + 6, + 0 + ], + [ + 6, + 1 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 8 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 7, + 16 + ], + [ + 8, + 0 + ], + [ + 8, + 1 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 0 + ], + [ + 9, + 1 + ], + [ + 9, + 2 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 9, + 16 + ], + [ + 10, + 0 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 11, + 16 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 12, + 15 + ], + [ + 12, + 16 + ], + [ + 13, + 1 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 13, + 15 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 14, + 14 + ], + [ + 15, + 3 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 4 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "bounds": { + "x_min": 0, + "x_max": 16, + "y_min": 0, + "y_max": 16 + }, + "cell_count": 251 + }, + "choices": { + "maker": "Prescribed pivot, or first free envelope cell if already owned; stop at first Snaky copy.", + "breaker": "Two displayed paper replies, then first free envelope cell in lexicographic (x,y) order.", + "breaker_prefix": [ + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": "First printed child whose placed envelope avoids the legal reply." + }, + "steps": [ + { + "move": 1, + "active": { + "card": 727, + "inline_path": [], + "height": 21, + "required": [], + "envelope": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 0, + 12 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 1, + 12 + ], + [ + 1, + 13 + ], + [ + 2, + 1 + ], + [ + 2, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 2, + 14 + ], + [ + 2, + 15 + ], + [ + 3, + 1 + ], + [ + 3, + 2 + ], + [ + 3, + 3 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 3, + 14 + ], + [ + 3, + 15 + ], + [ + 4, + 0 + ], + [ + 4, + 1 + ], + [ + 4, + 2 + ], + [ + 4, + 3 + ], + [ + 4, + 4 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 4, + 15 + ], + [ + 5, + 0 + ], + [ + 5, + 1 + ], + [ + 5, + 2 + ], + [ + 5, + 3 + ], + [ + 5, + 4 + ], + [ + 5, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 5, + 16 + ], + [ + 6, + 0 + ], + [ + 6, + 1 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 8 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 7, + 16 + ], + [ + 8, + 0 + ], + [ + 8, + 1 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 0 + ], + [ + 9, + 1 + ], + [ + 9, + 2 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 9, + 16 + ], + [ + 10, + 0 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 11, + 16 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 12, + 15 + ], + [ + 12, + 16 + ], + [ + 13, + 1 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 13, + 15 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 14, + 14 + ], + [ + 15, + 3 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 4 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "placement": { + "matrix": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "translation": [ + 0, + 0 + ] + }, + "certificate_ref": { + "line": 722, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L722", + "node": "card 727" + } + }, + "maker_before": [], + "breaker_before": [], + "global_budget_before": 21, + "global_budget_after": 20, + "maker": { + "cell": [ + 8, + 8 + ], + "kind": "pivot", + "prescribed_cell": [ + 8, + 8 + ] + }, + "maker_after": [ + [ + 8, + 8 + ] + ], + "breaker": { + "cell": [ + 7, + 8 + ] + }, + "breaker_after": [ + [ + 7, + 8 + ] + ], + "continuation": { + "child_index": 4, + "kind": "reference", + "source_reference": "708:100", + "card": 708, + "inline_path": [], + "height": 20, + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 0, + 0 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 2, + "active": { + "card": 708, + "inline_path": [], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "envelope": [ + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 1, + 12 + ], + [ + 2, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 3, + 2 + ], + [ + 3, + 3 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 4, + 0 + ], + [ + 4, + 1 + ], + [ + 4, + 2 + ], + [ + 4, + 3 + ], + [ + 4, + 4 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 5, + 0 + ], + [ + 5, + 1 + ], + [ + 5, + 2 + ], + [ + 5, + 3 + ], + [ + 5, + 4 + ], + [ + 5, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 6, + 0 + ], + [ + 6, + 1 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 8, + 0 + ], + [ + 8, + 1 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 0 + ], + [ + 9, + 1 + ], + [ + 9, + 2 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 0, + 0 + ] + }, + "certificate_ref": { + "line": 703, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L703", + "node": "card 708" + } + }, + "maker_before": [ + [ + 8, + 8 + ] + ], + "breaker_before": [ + [ + 7, + 8 + ] + ], + "global_budget_before": 20, + "global_budget_after": 19, + "maker": { + "cell": [ + 8, + 7 + ], + "kind": "pivot", + "prescribed_cell": [ + 8, + 7 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ] + ], + "breaker": { + "cell": [ + 8, + 6 + ] + }, + "breaker_after": [ + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 6, + "kind": "reference", + "source_reference": "684:011", + "card": 684, + "inline_path": [], + "height": 18, + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 1, + 1 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 3, + "active": { + "card": 684, + "inline_path": [], + "height": 18, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ] + ], + "envelope": [ + [ + 1, + 10 + ], + [ + 1, + 12 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 1, + 1 + ] + }, + "certificate_ref": { + "line": 679, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L679", + "node": "card 684" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ] + ], + "breaker_before": [ + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 19, + "global_budget_after": 18, + "maker": { + "cell": [ + 11, + 8 + ], + "kind": "pivot", + "prescribed_cell": [ + 11, + 8 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 11, + 8 + ] + ], + "breaker": { + "cell": [ + 0, + 4 + ] + }, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 0, + "kind": "inline", + "source_reference": null, + "card": 684, + "inline_path": [ + 0 + ], + "height": 14, + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 1, + 1 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 4, + "active": { + "card": 684, + "inline_path": [ + 0 + ], + "height": 14, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 11, + 8 + ] + ], + "envelope": [ + [ + 1, + 10 + ], + [ + 1, + 12 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 12, + 6 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ] + ], + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 1, + 1 + ] + }, + "certificate_ref": { + "line": 679, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L679", + "node": "card 684 / child 0" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 11, + 8 + ] + ], + "breaker_before": [ + [ + 0, + 4 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 18, + "global_budget_after": 17, + "maker": { + "cell": [ + 8, + 9 + ], + "kind": "pivot", + "prescribed_cell": [ + 8, + 9 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 11, + 8 + ] + ], + "breaker": { + "cell": [ + 0, + 5 + ] + }, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 0, + "kind": "reference", + "source_reference": "118:45A", + "card": 118, + "inline_path": [], + "height": 7, + "placement": { + "matrix": [ + [ + 0, + -1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 11, + 6 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 5, + "active": { + "card": 118, + "inline_path": [], + "height": 7, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ] + ], + "envelope": [ + [ + 4, + 9 + ], + [ + 4, + 11 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 11, + 9 + ] + ], + "placement": { + "matrix": [ + [ + 0, + -1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 11, + 6 + ] + }, + "certificate_ref": { + "line": 113, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L113", + "node": "card 118" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 11, + 8 + ] + ], + "breaker_before": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 17, + "global_budget_after": 16, + "maker": { + "cell": [ + 8, + 10 + ], + "kind": "pivot", + "prescribed_cell": [ + 8, + 10 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 11, + 8 + ] + ], + "breaker": { + "cell": [ + 0, + 6 + ] + }, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 0, + "kind": "reference", + "source_reference": "7:303", + "card": 7, + "inline_path": [], + "height": 3, + "placement": { + "matrix": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "translation": [ + 8, + 6 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 6, + "active": { + "card": 7, + "inline_path": [], + "height": 3, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ] + ], + "envelope": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ] + ], + "placement": { + "matrix": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "translation": [ + 8, + 6 + ] + }, + "certificate_ref": { + "line": 2, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L2", + "node": "card 7" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 11, + 8 + ] + ], + "breaker_before": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 16, + "global_budget_after": 15, + "maker": { + "cell": [ + 8, + 11 + ], + "kind": "pivot", + "prescribed_cell": [ + 8, + 11 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 11, + 8 + ] + ], + "breaker": { + "cell": [ + 0, + 7 + ] + }, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 0, + "kind": "reference", + "source_reference": "6:001", + "card": 6, + "inline_path": [], + "height": 2, + "placement": { + "matrix": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "translation": [ + 8, + 7 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 7, + "active": { + "card": 6, + "inline_path": [], + "height": 2, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ] + ], + "envelope": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ] + ], + "placement": { + "matrix": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "translation": [ + 8, + 7 + ] + }, + "certificate_ref": { + "line": 1, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L1", + "node": "card 6" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 11, + 8 + ] + ], + "breaker_before": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 15, + "global_budget_after": 14, + "maker": { + "cell": [ + 9, + 11 + ], + "kind": "pivot", + "prescribed_cell": [ + 9, + 11 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 11 + ], + [ + 11, + 8 + ] + ], + "breaker": { + "cell": [ + 0, + 8 + ] + }, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 0, + "kind": "reference", + "source_reference": "4:100", + "card": 4, + "inline_path": [], + "height": 1, + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 8, + 7 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 8, + "active": { + "card": 4, + "inline_path": [], + "height": 1, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 9, + 11 + ] + ], + "envelope": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ] + ], + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 8, + 7 + ] + }, + "certificate_ref": { + "line": 36, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/lean/OAI/GameTheory/SnakyTwentyOne/Cards/Height01Part01.lean#L36", + "node": "card 4" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 11 + ], + [ + 11, + 8 + ] + ], + "breaker_before": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 14, + "global_budget_after": 13, + "maker": { + "cell": [ + 9, + 10 + ], + "kind": "base_completion", + "prescribed_cell": [ + 9, + 10 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 11, + 8 + ] + ], + "breaker": null, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": null, + "won": true, + "witness": { + "symmetry": 1, + "translation": [ + 8, + 7 + ], + "cells": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ] + ] + } + } + ], + "result": { + "maker_claims": 8, + "breaker_claims": 7, + "won": true, + "target": { + "symmetry": 1, + "translation": [ + 8, + 7 + ], + "cells": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ] + ] + }, + "remaining_global_budget": 13 + }, + "limits": [ + "One illustrative checked execution with chosen legal Breaker replies.", + "Eight Maker claims in this example do not establish an eight-move guarantee.", + "The Python move adapter is not an extracted formally verified policy.", + "This record binds certificate and implementation inputs, not a successful Lean proof receipt.", + "The 21-move universal theorem and its proof receipt are separate evidence." + ] +} diff --git a/lean/snaky/FiniteCards/Height01Part01.lean b/lean/snaky/FiniteCards/Height01Part01.lean new file mode 100644 index 0000000..28a68e2 --- /dev/null +++ b/lean/snaky/FiniteCards/Height01Part01.lean @@ -0,0 +1,46 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_row_works_0 : FiniteTemplate HasSnaky 1 required_0 envelope_0 := by + have hA : required_0 = snaky.erase (0, 0) := by decide +kernel + have hT : envelope_0 = snaky := by decide +kernel + rw [hA, hT] + exact finite_immediate HasSnaky snaky (0, 0) (by decide +kernel) identity_target + +theorem finite_row_works_1 : FiniteTemplate HasSnaky 1 required_1 envelope_1 := by + have hA : required_1 = snaky.erase (1, 0) := by decide +kernel + have hT : envelope_1 = snaky := by decide +kernel + rw [hA, hT] + exact finite_immediate HasSnaky snaky (1, 0) (by decide +kernel) identity_target + +theorem finite_row_works_2 : FiniteTemplate HasSnaky 1 required_2 envelope_2 := by + have hA : required_2 = snaky.erase (2, 0) := by decide +kernel + have hT : envelope_2 = snaky := by decide +kernel + rw [hA, hT] + exact finite_immediate HasSnaky snaky (2, 0) (by decide +kernel) identity_target + +theorem finite_row_works_3 : FiniteTemplate HasSnaky 1 required_3 envelope_3 := by + have hA : required_3 = snaky.erase (3, 0) := by decide +kernel + have hT : envelope_3 = snaky := by decide +kernel + rw [hA, hT] + exact finite_immediate HasSnaky snaky (3, 0) (by decide +kernel) identity_target + +theorem finite_row_works_4 : FiniteTemplate HasSnaky 1 required_4 envelope_4 := by + have hA : required_4 = snaky.erase (3, 1) := by decide +kernel + have hT : envelope_4 = snaky := by decide +kernel + rw [hA, hT] + exact finite_immediate HasSnaky snaky (3, 1) (by decide +kernel) identity_target + +theorem finite_row_works_5 : FiniteTemplate HasSnaky 1 required_5 envelope_5 := by + have hA : required_5 = snaky.erase (4, 1) := by decide +kernel + have hT : envelope_5 = snaky := by decide +kernel + rw [hA, hT] + exact finite_immediate HasSnaky snaky (4, 1) (by decide +kernel) identity_target + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height02Part01.lean b/lean/snaky/FiniteCards/Height02Part01.lean new file mode 100644 index 0000000..ca4f41c --- /dev/null +++ b/lean/snaky/FiniteCards/Height02Part01.lean @@ -0,0 +1,299 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import FiniteCards.Height01Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_6 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_6 j) (childrenD_6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_6 : FiniteTemplate HasSnaky 2 required_6 envelope_6 := by + refine finite_compose HasSnaky 1 childrenC_6 childrenD_6 finite_children_work_6 (1, 4) + required_6 envelope_6 pivot_mem_6 child_required_sub_6 child_envelope_sub_6 ?_ + intro b hb + exact common_sub_6 (mem_commonEnvelope childrenD_6 b hb) + +theorem finite_children_work_11 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_11 j) (childrenD_11 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_11 : FiniteTemplate HasSnaky 2 required_11 envelope_11 := by + refine finite_compose HasSnaky 1 childrenC_11 childrenD_11 finite_children_work_11 (1, 1) + required_11 envelope_11 pivot_mem_11 child_required_sub_11 child_envelope_sub_11 ?_ + intro b hb + exact common_sub_11 (mem_commonEnvelope childrenD_11 b hb) + +theorem finite_children_work_15 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_15 j) (childrenD_15 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_15 : FiniteTemplate HasSnaky 2 required_15 envelope_15 := by + refine finite_compose HasSnaky 1 childrenC_15 childrenD_15 finite_children_work_15 (1, 4) + required_15 envelope_15 pivot_mem_15 child_required_sub_15 child_envelope_sub_15 ?_ + intro b hb + exact common_sub_15 (mem_commonEnvelope childrenD_15 b hb) + +theorem finite_children_work_22 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_22 j) (childrenD_22 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_22 : FiniteTemplate HasSnaky 2 required_22 envelope_22 := by + refine finite_compose HasSnaky 1 childrenC_22 childrenD_22 finite_children_work_22 (0, 3) + required_22 envelope_22 pivot_mem_22 child_required_sub_22 child_envelope_sub_22 ?_ + intro b hb + exact common_sub_22 (mem_commonEnvelope childrenD_22 b hb) + +theorem finite_children_work_23 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_23 j) (childrenD_23 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_23 : FiniteTemplate HasSnaky 2 required_23 envelope_23 := by + refine finite_compose HasSnaky 1 childrenC_23 childrenD_23 finite_children_work_23 (0, 4) + required_23 envelope_23 pivot_mem_23 child_required_sub_23 child_envelope_sub_23 ?_ + intro b hb + exact common_sub_23 (mem_commonEnvelope childrenD_23 b hb) + +theorem finite_children_work_25 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_25 j) (childrenD_25 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 3 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_25 : FiniteTemplate HasSnaky 2 required_25 envelope_25 := by + refine finite_compose HasSnaky 1 childrenC_25 childrenD_25 finite_children_work_25 (3, 0) + required_25 envelope_25 pivot_mem_25 child_required_sub_25 child_envelope_sub_25 ?_ + intro b hb + exact common_sub_25 (mem_commonEnvelope childrenD_25 b hb) + +theorem finite_children_work_28 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_28 j) (childrenD_28 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_28 : FiniteTemplate HasSnaky 2 required_28 envelope_28 := by + refine finite_compose HasSnaky 1 childrenC_28 childrenD_28 finite_children_work_28 (1, 2) + required_28 envelope_28 pivot_mem_28 child_required_sub_28 child_envelope_sub_28 ?_ + intro b hb + exact common_sub_28 (mem_commonEnvelope childrenD_28 b hb) + +theorem finite_children_work_30 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_30 j) (childrenD_30 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 1 (0, 0)).mono (by decide +kernel) + +theorem finite_row_works_30 : FiniteTemplate HasSnaky 2 required_30 envelope_30 := by + refine finite_compose HasSnaky 1 childrenC_30 childrenD_30 finite_children_work_30 (0, 2) + required_30 envelope_30 pivot_mem_30 child_required_sub_30 child_envelope_sub_30 ?_ + intro b hb + exact common_sub_30 (mem_commonEnvelope childrenD_30 b hb) + +theorem finite_children_work_32 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_32 j) (childrenD_32 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_32 : FiniteTemplate HasSnaky 2 required_32 envelope_32 := by + refine finite_compose HasSnaky 1 childrenC_32 childrenD_32 finite_children_work_32 (3, 0) + required_32 envelope_32 pivot_mem_32 child_required_sub_32 child_envelope_sub_32 ?_ + intro b hb + exact common_sub_32 (mem_commonEnvelope childrenD_32 b hb) + +theorem finite_children_work_34 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_34 j) (childrenD_34 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_34 : FiniteTemplate HasSnaky 2 required_34 envelope_34 := by + refine finite_compose HasSnaky 1 childrenC_34 childrenD_34 finite_children_work_34 (0, 3) + required_34 envelope_34 pivot_mem_34 child_required_sub_34 child_envelope_sub_34 ?_ + intro b hb + exact common_sub_34 (mem_commonEnvelope childrenD_34 b hb) + +theorem finite_children_work_35 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_35 j) (childrenD_35 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 7 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_35 : FiniteTemplate HasSnaky 2 required_35 envelope_35 := by + refine finite_compose HasSnaky 1 childrenC_35 childrenD_35 finite_children_work_35 (3, 2) + required_35 envelope_35 pivot_mem_35 child_required_sub_35 child_envelope_sub_35 ?_ + intro b hb + exact common_sub_35 (mem_commonEnvelope childrenD_35 b hb) + +theorem finite_children_work_36 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_36 j) (childrenD_36 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_2 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_36 : FiniteTemplate HasSnaky 2 required_36 envelope_36 := by + refine finite_compose HasSnaky 1 childrenC_36 childrenD_36 finite_children_work_36 (1, 4) + required_36 envelope_36 pivot_mem_36 child_required_sub_36 child_envelope_sub_36 ?_ + intro b hb + exact common_sub_36 (mem_commonEnvelope childrenD_36 b hb) + +theorem finite_children_work_38 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_38 j) (childrenD_38 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_38 : FiniteTemplate HasSnaky 2 required_38 envelope_38 := by + refine finite_compose HasSnaky 1 childrenC_38 childrenD_38 finite_children_work_38 (3, 2) + required_38 envelope_38 pivot_mem_38 child_required_sub_38 child_envelope_sub_38 ?_ + intro b hb + exact common_sub_38 (mem_commonEnvelope childrenD_38 b hb) + +theorem finite_children_work_40 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_40 j) (childrenD_40 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_40 : FiniteTemplate HasSnaky 2 required_40 envelope_40 := by + refine finite_compose HasSnaky 1 childrenC_40 childrenD_40 finite_children_work_40 (1, 3) + required_40 envelope_40 pivot_mem_40 child_required_sub_40 child_envelope_sub_40 ?_ + intro b hb + exact common_sub_40 (mem_commonEnvelope childrenD_40 b hb) + +theorem finite_children_work_43 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_43 j) (childrenD_43 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_43 : FiniteTemplate HasSnaky 2 required_43 envelope_43 := by + refine finite_compose HasSnaky 1 childrenC_43 childrenD_43 finite_children_work_43 (1, 4) + required_43 envelope_43 pivot_mem_43 child_required_sub_43 child_envelope_sub_43 ?_ + intro b hb + exact common_sub_43 (mem_commonEnvelope childrenD_43 b hb) + +theorem finite_children_work_51 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_51 j) (childrenD_51 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 1 (0, 0)).mono (by decide +kernel) + +theorem finite_row_works_51 : FiniteTemplate HasSnaky 2 required_51 envelope_51 := by + refine finite_compose HasSnaky 1 childrenC_51 childrenD_51 finite_children_work_51 (1, 4) + required_51 envelope_51 pivot_mem_51 child_required_sub_51 child_envelope_sub_51 ?_ + intro b hb + exact common_sub_51 (mem_commonEnvelope childrenD_51 b hb) + +theorem finite_children_work_66 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_66 j) (childrenD_66 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_66 : FiniteTemplate HasSnaky 2 required_66 envelope_66 := by + refine finite_compose HasSnaky 1 childrenC_66 childrenD_66 finite_children_work_66 (1, 4) + required_66 envelope_66 pivot_mem_66 child_required_sub_66 child_envelope_sub_66 ?_ + intro b hb + exact common_sub_66 (mem_commonEnvelope childrenD_66 b hb) + +theorem finite_children_work_68 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_68 j) (childrenD_68 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_1 1 (0, 0)).mono (by decide +kernel) + +theorem finite_row_works_68 : FiniteTemplate HasSnaky 2 required_68 envelope_68 := by + refine finite_compose HasSnaky 1 childrenC_68 childrenD_68 finite_children_work_68 (0, 2) + required_68 envelope_68 pivot_mem_68 child_required_sub_68 child_envelope_sub_68 ?_ + intro b hb + exact common_sub_68 (mem_commonEnvelope childrenD_68 b hb) + +theorem finite_children_work_70 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_70 j) (childrenD_70 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 1 (0, 0)).mono (by decide +kernel) + +theorem finite_row_works_70 : FiniteTemplate HasSnaky 2 required_70 envelope_70 := by + refine finite_compose HasSnaky 1 childrenC_70 childrenD_70 finite_children_work_70 (1, 3) + required_70 envelope_70 pivot_mem_70 child_required_sub_70 child_envelope_sub_70 ?_ + intro b hb + exact common_sub_70 (mem_commonEnvelope childrenD_70 b hb) + +theorem finite_children_work_76 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_76 j) (childrenD_76 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_76 : FiniteTemplate HasSnaky 2 required_76 envelope_76 := by + refine finite_compose HasSnaky 1 childrenC_76 childrenD_76 finite_children_work_76 (1, 4) + required_76 envelope_76 pivot_mem_76 child_required_sub_76 child_envelope_sub_76 ?_ + intro b hb + exact common_sub_76 (mem_commonEnvelope childrenD_76 b hb) + +theorem finite_children_work_77 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_77 j) (childrenD_77 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_77 : FiniteTemplate HasSnaky 2 required_77 envelope_77 := by + refine finite_compose HasSnaky 1 childrenC_77 childrenD_77 finite_children_work_77 (2, 1) + required_77 envelope_77 pivot_mem_77 child_required_sub_77 child_envelope_sub_77 ?_ + intro b hb + exact common_sub_77 (mem_commonEnvelope childrenD_77 b hb) + +theorem finite_children_work_80 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_80 j) (childrenD_80 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_80 : FiniteTemplate HasSnaky 2 required_80 envelope_80 := by + refine finite_compose HasSnaky 1 childrenC_80 childrenD_80 finite_children_work_80 (1, 3) + required_80 envelope_80 pivot_mem_80 child_required_sub_80 child_envelope_sub_80 ?_ + intro b hb + exact common_sub_80 (mem_commonEnvelope childrenD_80 b hb) + +theorem finite_children_work_83 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_83 j) (childrenD_83 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_83 : FiniteTemplate HasSnaky 2 required_83 envelope_83 := by + refine finite_compose HasSnaky 1 childrenC_83 childrenD_83 finite_children_work_83 (1, 4) + required_83 envelope_83 pivot_mem_83 child_required_sub_83 child_envelope_sub_83 ?_ + intro b hb + exact common_sub_83 (mem_commonEnvelope childrenD_83 b hb) + +theorem finite_children_work_94 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_94 j) (childrenD_94 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 1 (0, 0)).mono (by decide +kernel) + +theorem finite_row_works_94 : FiniteTemplate HasSnaky 2 required_94 envelope_94 := by + refine finite_compose HasSnaky 1 childrenC_94 childrenD_94 finite_children_work_94 (0, 3) + required_94 envelope_94 pivot_mem_94 child_required_sub_94 child_envelope_sub_94 ?_ + intro b hb + exact common_sub_94 (mem_commonEnvelope childrenD_94 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height02Part02.lean b/lean/snaky/FiniteCards/Height02Part02.lean new file mode 100644 index 0000000..b059b5e --- /dev/null +++ b/lean/snaky/FiniteCards/Height02Part02.lean @@ -0,0 +1,227 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import FiniteCards.Height01Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_96 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_96 j) (childrenD_96 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 5 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_96 : FiniteTemplate HasSnaky 2 required_96 envelope_96 := by + refine finite_compose HasSnaky 1 childrenC_96 childrenD_96 finite_children_work_96 (3, 0) + required_96 envelope_96 pivot_mem_96 child_required_sub_96 child_envelope_sub_96 ?_ + intro b hb + exact common_sub_96 (mem_commonEnvelope childrenD_96 b hb) + +theorem finite_children_work_102 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_102 j) (childrenD_102 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_102 : FiniteTemplate HasSnaky 2 required_102 envelope_102 := by + refine finite_compose HasSnaky 1 childrenC_102 childrenD_102 finite_children_work_102 (1, 3) + required_102 envelope_102 pivot_mem_102 child_required_sub_102 child_envelope_sub_102 ?_ + intro b hb + exact common_sub_102 (mem_commonEnvelope childrenD_102 b hb) + +theorem finite_children_work_121 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_121 j) (childrenD_121 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 3 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_121 : FiniteTemplate HasSnaky 2 required_121 envelope_121 := by + refine finite_compose HasSnaky 1 childrenC_121 childrenD_121 finite_children_work_121 (3, 0) + required_121 envelope_121 pivot_mem_121 child_required_sub_121 child_envelope_sub_121 ?_ + intro b hb + exact common_sub_121 (mem_commonEnvelope childrenD_121 b hb) + +theorem finite_children_work_123 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_123 j) (childrenD_123 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_4 6 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_123 : FiniteTemplate HasSnaky 2 required_123 envelope_123 := by + refine finite_compose HasSnaky 1 childrenC_123 childrenD_123 finite_children_work_123 (4, 1) + required_123 envelope_123 pivot_mem_123 child_required_sub_123 child_envelope_sub_123 ?_ + intro b hb + exact common_sub_123 (mem_commonEnvelope childrenD_123 b hb) + +theorem finite_children_work_129 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_129 j) (childrenD_129 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_129 : FiniteTemplate HasSnaky 2 required_129 envelope_129 := by + refine finite_compose HasSnaky 1 childrenC_129 childrenD_129 finite_children_work_129 (1, 2) + required_129 envelope_129 pivot_mem_129 child_required_sub_129 child_envelope_sub_129 ?_ + intro b hb + exact common_sub_129 (mem_commonEnvelope childrenD_129 b hb) + +theorem finite_children_work_138 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_138 j) (childrenD_138 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_138 : FiniteTemplate HasSnaky 2 required_138 envelope_138 := by + refine finite_compose HasSnaky 1 childrenC_138 childrenD_138 finite_children_work_138 (1, 4) + required_138 envelope_138 pivot_mem_138 child_required_sub_138 child_envelope_sub_138 ?_ + intro b hb + exact common_sub_138 (mem_commonEnvelope childrenD_138 b hb) + +theorem finite_children_work_146 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_146 j) (childrenD_146 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_146 : FiniteTemplate HasSnaky 2 required_146 envelope_146 := by + refine finite_compose HasSnaky 1 childrenC_146 childrenD_146 finite_children_work_146 (2, 1) + required_146 envelope_146 pivot_mem_146 child_required_sub_146 child_envelope_sub_146 ?_ + intro b hb + exact common_sub_146 (mem_commonEnvelope childrenD_146 b hb) + +theorem finite_children_work_153 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_153 j) (childrenD_153 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 2 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_153 : FiniteTemplate HasSnaky 2 required_153 envelope_153 := by + refine finite_compose HasSnaky 1 childrenC_153 childrenD_153 finite_children_work_153 (1, 4) + required_153 envelope_153 pivot_mem_153 child_required_sub_153 child_envelope_sub_153 ?_ + intro b hb + exact common_sub_153 (mem_commonEnvelope childrenD_153 b hb) + +theorem finite_children_work_154 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_154 j) (childrenD_154 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_154 : FiniteTemplate HasSnaky 2 required_154 envelope_154 := by + refine finite_compose HasSnaky 1 childrenC_154 childrenD_154 finite_children_work_154 (1, 3) + required_154 envelope_154 pivot_mem_154 child_required_sub_154 child_envelope_sub_154 ?_ + intro b hb + exact common_sub_154 (mem_commonEnvelope childrenD_154 b hb) + +theorem finite_children_work_156 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_156 j) (childrenD_156 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 3 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_156 : FiniteTemplate HasSnaky 2 required_156 envelope_156 := by + refine finite_compose HasSnaky 1 childrenC_156 childrenD_156 finite_children_work_156 (3, 1) + required_156 envelope_156 pivot_mem_156 child_required_sub_156 child_envelope_sub_156 ?_ + intro b hb + exact common_sub_156 (mem_commonEnvelope childrenD_156 b hb) + +theorem finite_children_work_169 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_169 j) (childrenD_169 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_1 7 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_169 : FiniteTemplate HasSnaky 2 required_169 envelope_169 := by + refine finite_compose HasSnaky 1 childrenC_169 childrenD_169 finite_children_work_169 (1, 4) + required_169 envelope_169 pivot_mem_169 child_required_sub_169 child_envelope_sub_169 ?_ + intro b hb + exact common_sub_169 (mem_commonEnvelope childrenD_169 b hb) + +theorem finite_children_work_170 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_170 j) (childrenD_170 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_170 : FiniteTemplate HasSnaky 2 required_170 envelope_170 := by + refine finite_compose HasSnaky 1 childrenC_170 childrenD_170 finite_children_work_170 (1, 2) + required_170 envelope_170 pivot_mem_170 child_required_sub_170 child_envelope_sub_170 ?_ + intro b hb + exact common_sub_170 (mem_commonEnvelope childrenD_170 b hb) + +theorem finite_children_work_200 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_200 j) (childrenD_200 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_200 : FiniteTemplate HasSnaky 2 required_200 envelope_200 := by + refine finite_compose HasSnaky 1 childrenC_200 childrenD_200 finite_children_work_200 (1, 3) + required_200 envelope_200 pivot_mem_200 child_required_sub_200 child_envelope_sub_200 ?_ + intro b hb + exact common_sub_200 (mem_commonEnvelope childrenD_200 b hb) + +theorem finite_children_work_210 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_210 j) (childrenD_210 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_4 6 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_210 : FiniteTemplate HasSnaky 2 required_210 envelope_210 := by + refine finite_compose HasSnaky 1 childrenC_210 childrenD_210 finite_children_work_210 (0, 0) + required_210 envelope_210 pivot_mem_210 child_required_sub_210 child_envelope_sub_210 ?_ + intro b hb + exact common_sub_210 (mem_commonEnvelope childrenD_210 b hb) + +theorem finite_children_work_220 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_220 j) (childrenD_220 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (2, 4)).mono (by decide +kernel) + +theorem finite_row_works_220 : FiniteTemplate HasSnaky 2 required_220 envelope_220 := by + refine finite_compose HasSnaky 1 childrenC_220 childrenD_220 finite_children_work_220 (3, 1) + required_220 envelope_220 pivot_mem_220 child_required_sub_220 child_envelope_sub_220 ?_ + intro b hb + exact common_sub_220 (mem_commonEnvelope childrenD_220 b hb) + +theorem finite_children_work_224 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_224 j) (childrenD_224 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 7 (3, 4)).mono (by decide +kernel) + +theorem finite_row_works_224 : FiniteTemplate HasSnaky 2 required_224 envelope_224 := by + refine finite_compose HasSnaky 1 childrenC_224 childrenD_224 finite_children_work_224 (3, 1) + required_224 envelope_224 pivot_mem_224 child_required_sub_224 child_envelope_sub_224 ?_ + intro b hb + exact common_sub_224 (mem_commonEnvelope childrenD_224 b hb) + +theorem finite_children_work_244 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_244 j) (childrenD_244 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_244 : FiniteTemplate HasSnaky 2 required_244 envelope_244 := by + refine finite_compose HasSnaky 1 childrenC_244 childrenD_244 finite_children_work_244 (1, 4) + required_244 envelope_244 pivot_mem_244 child_required_sub_244 child_envelope_sub_244 ?_ + intro b hb + exact common_sub_244 (mem_commonEnvelope childrenD_244 b hb) + +theorem finite_children_work_281 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_281 j) (childrenD_281 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 2 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 1 (0, 0)).mono (by decide +kernel) + +theorem finite_row_works_281 : FiniteTemplate HasSnaky 2 required_281 envelope_281 := by + refine finite_compose HasSnaky 1 childrenC_281 childrenD_281 finite_children_work_281 (1, 3) + required_281 envelope_281 pivot_mem_281 child_required_sub_281 child_envelope_sub_281 ?_ + intro b hb + exact common_sub_281 (mem_commonEnvelope childrenD_281 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height03Part01.lean b/lean/snaky/FiniteCards/Height03Part01.lean new file mode 100644 index 0000000..e077d0d --- /dev/null +++ b/lean/snaky/FiniteCards/Height03Part01.lean @@ -0,0 +1,302 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_7 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_7 j) (childrenD_7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_7 : FiniteTemplate HasSnaky 3 required_7 envelope_7 := by + refine finite_compose HasSnaky 2 childrenC_7 childrenD_7 finite_children_work_7 (0, 5) + required_7 envelope_7 pivot_mem_7 child_required_sub_7 child_envelope_sub_7 ?_ + intro b hb + exact common_sub_7 (mem_commonEnvelope childrenD_7 b hb) + +theorem finite_children_work_8 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_8 j) (childrenD_8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 3 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_8 : FiniteTemplate HasSnaky 3 required_8 envelope_8 := by + refine finite_compose HasSnaky 2 childrenC_8 childrenD_8 finite_children_work_8 (4, 1) + required_8 envelope_8 pivot_mem_8 child_required_sub_8 child_envelope_sub_8 ?_ + intro b hb + exact common_sub_8 (mem_commonEnvelope childrenD_8 b hb) + +theorem finite_children_work_9 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_9 j) (childrenD_9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 6 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_9 : FiniteTemplate HasSnaky 3 required_9 envelope_9 := by + refine finite_compose HasSnaky 2 childrenC_9 childrenD_9 finite_children_work_9 (1, 5) + required_9 envelope_9 pivot_mem_9 child_required_sub_9 child_envelope_sub_9 ?_ + intro b hb + exact common_sub_9 (mem_commonEnvelope childrenD_9 b hb) + +theorem finite_children_work_16 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_16 j) (childrenD_16 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 3 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_6.mono (by decide +kernel) + +theorem finite_row_works_16 : FiniteTemplate HasSnaky 3 required_16 envelope_16 := by + refine finite_compose HasSnaky 2 childrenC_16 childrenD_16 finite_children_work_16 (0, 4) + required_16 envelope_16 pivot_mem_16 child_required_sub_16 child_envelope_sub_16 ?_ + intro b hb + exact common_sub_16 (mem_commonEnvelope childrenD_16 b hb) + +theorem finite_children_work_20 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_20 j) (childrenD_20 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_20 : FiniteTemplate HasSnaky 3 required_20 envelope_20 := by + refine finite_compose HasSnaky 2 childrenC_20 childrenD_20 finite_children_work_20 (1, 4) + required_20 envelope_20 pivot_mem_20 child_required_sub_20 child_envelope_sub_20 ?_ + intro b hb + exact common_sub_20 (mem_commonEnvelope childrenD_20 b hb) + +theorem finite_children_work_21 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_21 j) (childrenD_21 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_6.mono (by decide +kernel) + +theorem finite_row_works_21 : FiniteTemplate HasSnaky 3 required_21 envelope_21 := by + refine finite_compose HasSnaky 2 childrenC_21 childrenD_21 finite_children_work_21 (0, 4) + required_21 envelope_21 pivot_mem_21 child_required_sub_21 child_envelope_sub_21 ?_ + intro b hb + exact common_sub_21 (mem_commonEnvelope childrenD_21 b hb) + +theorem finite_children_work_24 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_24 j) (childrenD_24 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 6 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_24 : FiniteTemplate HasSnaky 3 required_24 envelope_24 := by + refine finite_compose HasSnaky 2 childrenC_24 childrenD_24 finite_children_work_24 (4, 1) + required_24 envelope_24 pivot_mem_24 child_required_sub_24 child_envelope_sub_24 ?_ + intro b hb + exact common_sub_24 (mem_commonEnvelope childrenD_24 b hb) + +theorem finite_children_work_29 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_29 j) (childrenD_29 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_6.mono (by decide +kernel) + +theorem finite_row_works_29 : FiniteTemplate HasSnaky 3 required_29 envelope_29 := by + refine finite_compose HasSnaky 2 childrenC_29 childrenD_29 finite_children_work_29 (0, 4) + required_29 envelope_29 pivot_mem_29 child_required_sub_29 child_envelope_sub_29 ?_ + intro b hb + exact common_sub_29 (mem_commonEnvelope childrenD_29 b hb) + +theorem finite_children_work_37 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_37 j) (childrenD_37 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_37 : FiniteTemplate HasSnaky 3 required_37 envelope_37 := by + refine finite_compose HasSnaky 2 childrenC_37 childrenD_37 finite_children_work_37 (1, 4) + required_37 envelope_37 pivot_mem_37 child_required_sub_37 child_envelope_sub_37 ?_ + intro b hb + exact common_sub_37 (mem_commonEnvelope childrenD_37 b hb) + +theorem finite_children_work_44 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_44 j) (childrenD_44 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_43 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_44 : FiniteTemplate HasSnaky 3 required_44 envelope_44 := by + refine finite_compose HasSnaky 2 childrenC_44 childrenD_44 finite_children_work_44 (1, 4) + required_44 envelope_44 pivot_mem_44 child_required_sub_44 child_envelope_sub_44 ?_ + intro b hb + exact common_sub_44 (mem_commonEnvelope childrenD_44 b hb) + +theorem finite_children_work_45 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_45 j) (childrenD_45 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_23 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_45 : FiniteTemplate HasSnaky 3 required_45 envelope_45 := by + refine finite_compose HasSnaky 2 childrenC_45 childrenD_45 finite_children_work_45 (3, 3) + required_45 envelope_45 pivot_mem_45 child_required_sub_45 child_envelope_sub_45 ?_ + intro b hb + exact common_sub_45 (mem_commonEnvelope childrenD_45 b hb) + +theorem finite_children_work_52 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_52 j) (childrenD_52 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_51 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_52 : FiniteTemplate HasSnaky 3 required_52 envelope_52 := by + refine finite_compose HasSnaky 2 childrenC_52 childrenD_52 finite_children_work_52 (1, 4) + required_52 envelope_52 pivot_mem_52 child_required_sub_52 child_envelope_sub_52 ?_ + intro b hb + exact common_sub_52 (mem_commonEnvelope childrenD_52 b hb) + +theorem finite_children_work_53 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_53 j) (childrenD_53 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_51 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_53 : FiniteTemplate HasSnaky 3 required_53 envelope_53 := by + refine finite_compose HasSnaky 2 childrenC_53 childrenD_53 finite_children_work_53 (0, 1) + required_53 envelope_53 pivot_mem_53 child_required_sub_53 child_envelope_sub_53 ?_ + intro b hb + exact common_sub_53 (mem_commonEnvelope childrenD_53 b hb) + +theorem finite_children_work_54 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_54 j) (childrenD_54 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_51 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_54 : FiniteTemplate HasSnaky 3 required_54 envelope_54 := by + refine finite_compose HasSnaky 2 childrenC_54 childrenD_54 finite_children_work_54 (0, 2) + required_54 envelope_54 pivot_mem_54 child_required_sub_54 child_envelope_sub_54 ?_ + intro b hb + exact common_sub_54 (mem_commonEnvelope childrenD_54 b hb) + +theorem finite_children_work_61 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_61 j) (childrenD_61 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_51 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_61 : FiniteTemplate HasSnaky 3 required_61 envelope_61 := by + refine finite_compose HasSnaky 2 childrenC_61 childrenD_61 finite_children_work_61 (1, 3) + required_61 envelope_61 pivot_mem_61 child_required_sub_61 child_envelope_sub_61 ?_ + intro b hb + exact common_sub_61 (mem_commonEnvelope childrenD_61 b hb) + +theorem finite_children_work_62 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_62 j) (childrenD_62 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 4 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 6 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_62 : FiniteTemplate HasSnaky 3 required_62 envelope_62 := by + refine finite_compose HasSnaky 2 childrenC_62 childrenD_62 finite_children_work_62 (1, 5) + required_62 envelope_62 pivot_mem_62 child_required_sub_62 child_envelope_sub_62 ?_ + intro b hb + exact common_sub_62 (mem_commonEnvelope childrenD_62 b hb) + +theorem finite_children_work_64 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_64 j) (childrenD_64 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_43 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_64 : FiniteTemplate HasSnaky 3 required_64 envelope_64 := by + refine finite_compose HasSnaky 2 childrenC_64 childrenD_64 finite_children_work_64 (0, 2) + required_64 envelope_64 pivot_mem_64 child_required_sub_64 child_envelope_sub_64 ?_ + intro b hb + exact common_sub_64 (mem_commonEnvelope childrenD_64 b hb) + +theorem finite_children_work_69 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_69 j) (childrenD_69 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_15 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_69 : FiniteTemplate HasSnaky 3 required_69 envelope_69 := by + refine finite_compose HasSnaky 2 childrenC_69 childrenD_69 finite_children_work_69 (3, 1) + required_69 envelope_69 pivot_mem_69 child_required_sub_69 child_envelope_sub_69 ?_ + intro b hb + exact common_sub_69 (mem_commonEnvelope childrenD_69 b hb) + +theorem finite_children_work_74 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_74 j) (childrenD_74 j) := by + intro j + fin_cases j + · exact finite_row_works_30.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_30 2 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_36.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_36 2 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_74 : FiniteTemplate HasSnaky 3 required_74 envelope_74 := by + refine finite_compose HasSnaky 2 childrenC_74 childrenD_74 finite_children_work_74 (1, 3) + required_74 envelope_74 pivot_mem_74 child_required_sub_74 child_envelope_sub_74 ?_ + intro b hb + exact common_sub_74 (mem_commonEnvelope childrenD_74 b hb) + +theorem finite_children_work_78 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_78 j) (childrenD_78 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_77 5 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_78 : FiniteTemplate HasSnaky 3 required_78 envelope_78 := by + refine finite_compose HasSnaky 2 childrenC_78 childrenD_78 finite_children_work_78 (3, 0) + required_78 envelope_78 pivot_mem_78 child_required_sub_78 child_envelope_sub_78 ?_ + intro b hb + exact common_sub_78 (mem_commonEnvelope childrenD_78 b hb) + +theorem finite_children_work_87 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_87 j) (childrenD_87 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_35 7 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_87 : FiniteTemplate HasSnaky 3 required_87 envelope_87 := by + refine finite_compose HasSnaky 2 childrenC_87 childrenD_87 finite_children_work_87 (4, 2) + required_87 envelope_87 pivot_mem_87 child_required_sub_87 child_envelope_sub_87 ?_ + intro b hb + exact common_sub_87 (mem_commonEnvelope childrenD_87 b hb) + +theorem finite_children_work_101 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_101 j) (childrenD_101 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_51 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_101 : FiniteTemplate HasSnaky 3 required_101 envelope_101 := by + refine finite_compose HasSnaky 2 childrenC_101 childrenD_101 finite_children_work_101 (0, 3) + required_101 envelope_101 pivot_mem_101 child_required_sub_101 child_envelope_sub_101 ?_ + intro b hb + exact common_sub_101 (mem_commonEnvelope childrenD_101 b hb) + +theorem finite_children_work_103 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_103 j) (childrenD_103 j) := by + intro j + fin_cases j + · exact finite_row_works_6.mono (by decide +kernel) + · exact finite_row_works_11.mono (by decide +kernel) + +theorem finite_row_works_103 : FiniteTemplate HasSnaky 3 required_103 envelope_103 := by + refine finite_compose HasSnaky 2 childrenC_103 childrenD_103 finite_children_work_103 (0, 4) + required_103 envelope_103 pivot_mem_103 child_required_sub_103 child_envelope_sub_103 ?_ + intro b hb + exact common_sub_103 (mem_commonEnvelope childrenD_103 b hb) + +theorem finite_children_work_105 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_105 j) (childrenD_105 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_11.mono (by decide +kernel) + +theorem finite_row_works_105 : FiniteTemplate HasSnaky 3 required_105 envelope_105 := by + refine finite_compose HasSnaky 2 childrenC_105 childrenD_105 finite_children_work_105 (0, 3) + required_105 envelope_105 pivot_mem_105 child_required_sub_105 child_envelope_sub_105 ?_ + intro b hb + exact common_sub_105 (mem_commonEnvelope childrenD_105 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height03Part02.lean b/lean/snaky/FiniteCards/Height03Part02.lean new file mode 100644 index 0000000..61db0b9 --- /dev/null +++ b/lean/snaky/FiniteCards/Height03Part02.lean @@ -0,0 +1,301 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_108 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_108 j) (childrenD_108 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_102 3 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_108 : FiniteTemplate HasSnaky 3 required_108 envelope_108 := by + refine finite_compose HasSnaky 2 childrenC_108 childrenD_108 finite_children_work_108 (1, 1) + required_108 envelope_108 pivot_mem_108 child_required_sub_108 child_envelope_sub_108 ?_ + intro b hb + exact common_sub_108 (mem_commonEnvelope childrenD_108 b hb) + +theorem finite_children_work_113 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_113 j) (childrenD_113 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_23 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_113 : FiniteTemplate HasSnaky 3 required_113 envelope_113 := by + refine finite_compose HasSnaky 2 childrenC_113 childrenD_113 finite_children_work_113 (1, 3) + required_113 envelope_113 pivot_mem_113 child_required_sub_113 child_envelope_sub_113 ?_ + intro b hb + exact common_sub_113 (mem_commonEnvelope childrenD_113 b hb) + +theorem finite_children_work_124 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_124 j) (childrenD_124 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_123 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_124 : FiniteTemplate HasSnaky 3 required_124 envelope_124 := by + refine finite_compose HasSnaky 2 childrenC_124 childrenD_124 finite_children_work_124 (2, 1) + required_124 envelope_124 pivot_mem_124 child_required_sub_124 child_envelope_sub_124 ?_ + intro b hb + exact common_sub_124 (mem_commonEnvelope childrenD_124 b hb) + +theorem finite_children_work_126 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_126 j) (childrenD_126 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_123 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_126 : FiniteTemplate HasSnaky 3 required_126 envelope_126 := by + refine finite_compose HasSnaky 2 childrenC_126 childrenD_126 finite_children_work_126 (1, 2) + required_126 envelope_126 pivot_mem_126 child_required_sub_126 child_envelope_sub_126 ?_ + intro b hb + exact common_sub_126 (mem_commonEnvelope childrenD_126 b hb) + +theorem finite_children_work_130 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_130 j) (childrenD_130 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact finite_row_works_129.mono (by decide +kernel) + +theorem finite_row_works_130 : FiniteTemplate HasSnaky 3 required_130 envelope_130 := by + refine finite_compose HasSnaky 2 childrenC_130 childrenD_130 finite_children_work_130 (1, 4) + required_130 envelope_130 pivot_mem_130 child_required_sub_130 child_envelope_sub_130 ?_ + intro b hb + exact common_sub_130 (mem_commonEnvelope childrenD_130 b hb) + +theorem finite_children_work_131 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_131 j) (childrenD_131 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_15.mono (by decide +kernel) + +theorem finite_row_works_131 : FiniteTemplate HasSnaky 3 required_131 envelope_131 := by + refine finite_compose HasSnaky 2 childrenC_131 childrenD_131 finite_children_work_131 (1, 3) + required_131 envelope_131 pivot_mem_131 child_required_sub_131 child_envelope_sub_131 ?_ + intro b hb + exact common_sub_131 (mem_commonEnvelope childrenD_131 b hb) + +theorem finite_children_work_139 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_139 j) (childrenD_139 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_138 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_139 : FiniteTemplate HasSnaky 3 required_139 envelope_139 := by + refine finite_compose HasSnaky 2 childrenC_139 childrenD_139 finite_children_work_139 (1, 3) + required_139 envelope_139 pivot_mem_139 child_required_sub_139 child_envelope_sub_139 ?_ + intro b hb + exact common_sub_139 (mem_commonEnvelope childrenD_139 b hb) + +theorem finite_children_work_140 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_140 j) (childrenD_140 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_43 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_140 : FiniteTemplate HasSnaky 3 required_140 envelope_140 := by + refine finite_compose HasSnaky 2 childrenC_140 childrenD_140 finite_children_work_140 (1, 3) + required_140 envelope_140 pivot_mem_140 child_required_sub_140 child_envelope_sub_140 ?_ + intro b hb + exact common_sub_140 (mem_commonEnvelope childrenD_140 b hb) + +theorem finite_children_work_143 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_143 j) (childrenD_143 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 3 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_143 : FiniteTemplate HasSnaky 3 required_143 envelope_143 := by + refine finite_compose HasSnaky 2 childrenC_143 childrenD_143 finite_children_work_143 (4, 1) + required_143 envelope_143 pivot_mem_143 child_required_sub_143 child_envelope_sub_143 ?_ + intro b hb + exact common_sub_143 (mem_commonEnvelope childrenD_143 b hb) + +theorem finite_children_work_157 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_157 j) (childrenD_157 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_156 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_157 : FiniteTemplate HasSnaky 3 required_157 envelope_157 := by + refine finite_compose HasSnaky 2 childrenC_157 childrenD_157 finite_children_work_157 (4, 0) + required_157 envelope_157 pivot_mem_157 child_required_sub_157 child_envelope_sub_157 ?_ + intro b hb + exact common_sub_157 (mem_commonEnvelope childrenD_157 b hb) + +theorem finite_children_work_158 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_158 j) (childrenD_158 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_158 : FiniteTemplate HasSnaky 3 required_158 envelope_158 := by + refine finite_compose HasSnaky 2 childrenC_158 childrenD_158 finite_children_work_158 (0, 4) + required_158 envelope_158 pivot_mem_158 child_required_sub_158 child_envelope_sub_158 ?_ + intro b hb + exact common_sub_158 (mem_commonEnvelope childrenD_158 b hb) + +theorem finite_children_work_159 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_159 j) (childrenD_159 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_23 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_66 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_159 : FiniteTemplate HasSnaky 3 required_159 envelope_159 := by + refine finite_compose HasSnaky 2 childrenC_159 childrenD_159 finite_children_work_159 (3, 1) + required_159 envelope_159 pivot_mem_159 child_required_sub_159 child_envelope_sub_159 ?_ + intro b hb + exact common_sub_159 (mem_commonEnvelope childrenD_159 b hb) + +theorem finite_children_work_160 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_160 j) (childrenD_160 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 4 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_160 : FiniteTemplate HasSnaky 3 required_160 envelope_160 := by + refine finite_compose HasSnaky 2 childrenC_160 childrenD_160 finite_children_work_160 (1, 2) + required_160 envelope_160 pivot_mem_160 child_required_sub_160 child_envelope_sub_160 ?_ + intro b hb + exact common_sub_160 (mem_commonEnvelope childrenD_160 b hb) + +theorem finite_children_work_163 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_163 j) (childrenD_163 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact finite_row_works_129.mono (by decide +kernel) + +theorem finite_row_works_163 : FiniteTemplate HasSnaky 3 required_163 envelope_163 := by + refine finite_compose HasSnaky 2 childrenC_163 childrenD_163 finite_children_work_163 (0, 2) + required_163 envelope_163 pivot_mem_163 child_required_sub_163 child_envelope_sub_163 ?_ + intro b hb + exact common_sub_163 (mem_commonEnvelope childrenD_163 b hb) + +theorem finite_children_work_177 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_177 j) (childrenD_177 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_23.mono (by decide +kernel) + +theorem finite_row_works_177 : FiniteTemplate HasSnaky 3 required_177 envelope_177 := by + refine finite_compose HasSnaky 2 childrenC_177 childrenD_177 finite_children_work_177 (1, 1) + required_177 envelope_177 pivot_mem_177 child_required_sub_177 child_envelope_sub_177 ?_ + intro b hb + exact common_sub_177 (mem_commonEnvelope childrenD_177 b hb) + +theorem finite_children_work_198 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_198 j) (childrenD_198 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 4 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_198 : FiniteTemplate HasSnaky 3 required_198 envelope_198 := by + refine finite_compose HasSnaky 2 childrenC_198 childrenD_198 finite_children_work_198 (1, 5) + required_198 envelope_198 pivot_mem_198 child_required_sub_198 child_envelope_sub_198 ?_ + intro b hb + exact common_sub_198 (mem_commonEnvelope childrenD_198 b hb) + +theorem finite_children_work_201 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_201 j) (childrenD_201 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_146 5 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_201 : FiniteTemplate HasSnaky 3 required_201 envelope_201 := by + refine finite_compose HasSnaky 2 childrenC_201 childrenD_201 finite_children_work_201 (3, 0) + required_201 envelope_201 pivot_mem_201 child_required_sub_201 child_envelope_sub_201 ?_ + intro b hb + exact common_sub_201 (mem_commonEnvelope childrenD_201 b hb) + +theorem finite_children_work_205 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_205 j) (childrenD_205 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 4 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_23 2 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_205 : FiniteTemplate HasSnaky 3 required_205 envelope_205 := by + refine finite_compose HasSnaky 2 childrenC_205 childrenD_205 finite_children_work_205 (1, 5) + required_205 envelope_205 pivot_mem_205 child_required_sub_205 child_envelope_sub_205 ?_ + intro b hb + exact common_sub_205 (mem_commonEnvelope childrenD_205 b hb) + +theorem finite_children_work_207 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_207 j) (childrenD_207 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_77 5 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_207 : FiniteTemplate HasSnaky 3 required_207 envelope_207 := by + refine finite_compose HasSnaky 2 childrenC_207 childrenD_207 finite_children_work_207 (3, 1) + required_207 envelope_207 pivot_mem_207 child_required_sub_207 child_envelope_sub_207 ?_ + intro b hb + exact common_sub_207 (mem_commonEnvelope childrenD_207 b hb) + +theorem finite_children_work_209 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_209 j) (childrenD_209 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_138 6 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_209 : FiniteTemplate HasSnaky 3 required_209 envelope_209 := by + refine finite_compose HasSnaky 2 childrenC_209 childrenD_209 finite_children_work_209 (1, 4) + required_209 envelope_209 pivot_mem_209 child_required_sub_209 child_envelope_sub_209 ?_ + intro b hb + exact common_sub_209 (mem_commonEnvelope childrenD_209 b hb) + +theorem finite_children_work_212 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_212 j) (childrenD_212 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_76 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_212 : FiniteTemplate HasSnaky 3 required_212 envelope_212 := by + refine finite_compose HasSnaky 2 childrenC_212 childrenD_212 finite_children_work_212 (1, 4) + required_212 envelope_212 pivot_mem_212 child_required_sub_212 child_envelope_sub_212 ?_ + intro b hb + exact common_sub_212 (mem_commonEnvelope childrenD_212 b hb) + +theorem finite_children_work_215 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_215 j) (childrenD_215 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_215 : FiniteTemplate HasSnaky 3 required_215 envelope_215 := by + refine finite_compose HasSnaky 2 childrenC_215 childrenD_215 finite_children_work_215 (3, 1) + required_215 envelope_215 pivot_mem_215 child_required_sub_215 child_envelope_sub_215 ?_ + intro b hb + exact common_sub_215 (mem_commonEnvelope childrenD_215 b hb) + +theorem finite_children_work_218 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_218 j) (childrenD_218 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_83 4 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_218 : FiniteTemplate HasSnaky 3 required_218 envelope_218 := by + refine finite_compose HasSnaky 2 childrenC_218 childrenD_218 finite_children_work_218 (1, 2) + required_218 envelope_218 pivot_mem_218 child_required_sub_218 child_envelope_sub_218 ?_ + intro b hb + exact common_sub_218 (mem_commonEnvelope childrenD_218 b hb) + +theorem finite_children_work_219 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_219 j) (childrenD_219 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 6 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_219 : FiniteTemplate HasSnaky 3 required_219 envelope_219 := by + refine finite_compose HasSnaky 2 childrenC_219 childrenD_219 finite_children_work_219 (1, 1) + required_219 envelope_219 pivot_mem_219 child_required_sub_219 child_envelope_sub_219 ?_ + intro b hb + exact common_sub_219 (mem_commonEnvelope childrenD_219 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height03Part03.lean b/lean/snaky/FiniteCards/Height03Part03.lean new file mode 100644 index 0000000..02bd062 --- /dev/null +++ b/lean/snaky/FiniteCards/Height03Part03.lean @@ -0,0 +1,277 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_221 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_221 j) (childrenD_221 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_220 4 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_221 : FiniteTemplate HasSnaky 3 required_221 envelope_221 := by + refine finite_compose HasSnaky 2 childrenC_221 childrenD_221 finite_children_work_221 (1, 3) + required_221 envelope_221 pivot_mem_221 child_required_sub_221 child_envelope_sub_221 ?_ + intro b hb + exact common_sub_221 (mem_commonEnvelope childrenD_221 b hb) + +theorem finite_children_work_222 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_222 j) (childrenD_222 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (2, 1)).mono (by decide +kernel) + · exact finite_row_works_220.mono (by decide +kernel) + +theorem finite_row_works_222 : FiniteTemplate HasSnaky 3 required_222 envelope_222 := by + refine finite_compose HasSnaky 2 childrenC_222 childrenD_222 finite_children_work_222 (2, 1) + required_222 envelope_222 pivot_mem_222 child_required_sub_222 child_envelope_sub_222 ?_ + intro b hb + exact common_sub_222 (mem_commonEnvelope childrenD_222 b hb) + +theorem finite_children_work_223 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_223 j) (childrenD_223 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 0 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_223 : FiniteTemplate HasSnaky 3 required_223 envelope_223 := by + refine finite_compose HasSnaky 2 childrenC_223 childrenD_223 finite_children_work_223 (3, 0) + required_223 envelope_223 pivot_mem_223 child_required_sub_223 child_envelope_sub_223 ?_ + intro b hb + exact common_sub_223 (mem_commonEnvelope childrenD_223 b hb) + +theorem finite_children_work_226 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_226 j) (childrenD_226 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_32 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_226 : FiniteTemplate HasSnaky 3 required_226 envelope_226 := by + refine finite_compose HasSnaky 2 childrenC_226 childrenD_226 finite_children_work_226 (4, 1) + required_226 envelope_226 pivot_mem_226 child_required_sub_226 child_envelope_sub_226 ?_ + intro b hb + exact common_sub_226 (mem_commonEnvelope childrenD_226 b hb) + +theorem finite_children_work_236 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_236 j) (childrenD_236 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_32 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_236 : FiniteTemplate HasSnaky 3 required_236 envelope_236 := by + refine finite_compose HasSnaky 2 childrenC_236 childrenD_236 finite_children_work_236 (1, 5) + required_236 envelope_236 pivot_mem_236 child_required_sub_236 child_envelope_sub_236 ?_ + intro b hb + exact common_sub_236 (mem_commonEnvelope childrenD_236 b hb) + +theorem finite_children_work_239 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_239 j) (childrenD_239 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 6 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_25 7 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_239 : FiniteTemplate HasSnaky 3 required_239 envelope_239 := by + refine finite_compose HasSnaky 2 childrenC_239 childrenD_239 finite_children_work_239 (3, 1) + required_239 envelope_239 pivot_mem_239 child_required_sub_239 child_envelope_sub_239 ?_ + intro b hb + exact common_sub_239 (mem_commonEnvelope childrenD_239 b hb) + +theorem finite_children_work_245 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_245 j) (childrenD_245 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_32 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_245 : FiniteTemplate HasSnaky 3 required_245 envelope_245 := by + refine finite_compose HasSnaky 2 childrenC_245 childrenD_245 finite_children_work_245 (1, 4) + required_245 envelope_245 pivot_mem_245 child_required_sub_245 child_envelope_sub_245 ?_ + intro b hb + exact common_sub_245 (mem_commonEnvelope childrenD_245 b hb) + +theorem finite_children_work_246 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_246 j) (childrenD_246 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_25 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_246 : FiniteTemplate HasSnaky 3 required_246 envelope_246 := by + refine finite_compose HasSnaky 2 childrenC_246 childrenD_246 finite_children_work_246 (1, 4) + required_246 envelope_246 pivot_mem_246 child_required_sub_246 child_envelope_sub_246 ?_ + intro b hb + exact common_sub_246 (mem_commonEnvelope childrenD_246 b hb) + +theorem finite_children_work_247 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_247 j) (childrenD_247 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_35 7 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_247 : FiniteTemplate HasSnaky 3 required_247 envelope_247 := by + refine finite_compose HasSnaky 2 childrenC_247 childrenD_247 finite_children_work_247 (3, 4) + required_247 envelope_247 pivot_mem_247 child_required_sub_247 child_envelope_sub_247 ?_ + intro b hb + exact common_sub_247 (mem_commonEnvelope childrenD_247 b hb) + +theorem finite_children_work_251 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_251 j) (childrenD_251 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_224 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_251 : FiniteTemplate HasSnaky 3 required_251 envelope_251 := by + refine finite_compose HasSnaky 2 childrenC_251 childrenD_251 finite_children_work_251 (4, 2) + required_251 envelope_251 pivot_mem_251 child_required_sub_251 child_envelope_sub_251 ?_ + intro b hb + exact common_sub_251 (mem_commonEnvelope childrenD_251 b hb) + +theorem finite_children_work_261 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_261 j) (childrenD_261 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact finite_row_works_129.mono (by decide +kernel) + +theorem finite_row_works_261 : FiniteTemplate HasSnaky 3 required_261 envelope_261 := by + refine finite_compose HasSnaky 2 childrenC_261 childrenD_261 finite_children_work_261 (1, 3) + required_261 envelope_261 pivot_mem_261 child_required_sub_261 child_envelope_sub_261 ?_ + intro b hb + exact common_sub_261 (mem_commonEnvelope childrenD_261 b hb) + +theorem finite_children_work_262 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_262 j) (childrenD_262 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_66 3 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_262 : FiniteTemplate HasSnaky 3 required_262 envelope_262 := by + refine finite_compose HasSnaky 2 childrenC_262 childrenD_262 finite_children_work_262 (1, 1) + required_262 envelope_262 pivot_mem_262 child_required_sub_262 child_envelope_sub_262 ?_ + intro b hb + exact common_sub_262 (mem_commonEnvelope childrenD_262 b hb) + +theorem finite_children_work_280 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_280 j) (childrenD_280 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_280 : FiniteTemplate HasSnaky 3 required_280 envelope_280 := by + refine finite_compose HasSnaky 2 childrenC_280 childrenD_280 finite_children_work_280 (1, 2) + required_280 envelope_280 pivot_mem_280 child_required_sub_280 child_envelope_sub_280 ?_ + intro b hb + exact common_sub_280 (mem_commonEnvelope childrenD_280 b hb) + +theorem finite_children_work_310 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_310 j) (childrenD_310 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_76 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_310 : FiniteTemplate HasSnaky 3 required_310 envelope_310 := by + refine finite_compose HasSnaky 2 childrenC_310 childrenD_310 finite_children_work_310 (1, 3) + required_310 envelope_310 pivot_mem_310 child_required_sub_310 child_envelope_sub_310 ?_ + intro b hb + exact common_sub_310 (mem_commonEnvelope childrenD_310 b hb) + +theorem finite_children_work_333_i0 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_333_i0 j) (childrenD_333_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 1 (0, 0)).mono (by decide +kernel) + +theorem finite_row_works_333_i0 : FiniteTemplate HasSnaky 2 required_333_i0 envelope_333_i0 := by + refine finite_compose HasSnaky 1 childrenC_333_i0 childrenD_333_i0 finite_children_work_333_i0 (0, 2) + required_333_i0 envelope_333_i0 pivot_mem_333_i0 child_required_sub_333_i0 child_envelope_sub_333_i0 ?_ + intro b hb + exact common_sub_333_i0 (mem_commonEnvelope childrenD_333_i0 b hb) + +theorem finite_children_work_333 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_333 j) (childrenD_333 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 7 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_333_i0.mono (by decide +kernel) + +theorem finite_row_works_333 : FiniteTemplate HasSnaky 3 required_333 envelope_333 := by + refine finite_compose HasSnaky 2 childrenC_333 childrenD_333 finite_children_work_333 (1, 4) + required_333 envelope_333 pivot_mem_333 child_required_sub_333 child_envelope_sub_333 ?_ + intro b hb + exact common_sub_333 (mem_commonEnvelope childrenD_333 b hb) + +theorem finite_children_work_350_i0 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_350_i0 j) (childrenD_350_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 3 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 4 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_350_i0 : FiniteTemplate HasSnaky 2 required_350_i0 envelope_350_i0 := by + refine finite_compose HasSnaky 1 childrenC_350_i0 childrenD_350_i0 finite_children_work_350_i0 (4, 1) + required_350_i0 envelope_350_i0 pivot_mem_350_i0 child_required_sub_350_i0 child_envelope_sub_350_i0 ?_ + intro b hb + exact common_sub_350_i0 (mem_commonEnvelope childrenD_350_i0 b hb) + +theorem finite_children_work_350 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_350 j) (childrenD_350 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_350_i0.mono (by decide +kernel) + +theorem finite_row_works_350 : FiniteTemplate HasSnaky 3 required_350 envelope_350 := by + refine finite_compose HasSnaky 2 childrenC_350 childrenD_350 finite_children_work_350 (4, 0) + required_350 envelope_350 pivot_mem_350 child_required_sub_350 child_envelope_sub_350 ?_ + intro b hb + exact common_sub_350 (mem_commonEnvelope childrenD_350 b hb) + +theorem finite_children_work_374_i0 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_374_i0 j) (childrenD_374_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 7 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_374_i0 : FiniteTemplate HasSnaky 2 required_374_i0 envelope_374_i0 := by + refine finite_compose HasSnaky 1 childrenC_374_i0 childrenD_374_i0 finite_children_work_374_i0 (4, 1) + required_374_i0 envelope_374_i0 pivot_mem_374_i0 child_required_sub_374_i0 child_envelope_sub_374_i0 ?_ + intro b hb + exact common_sub_374_i0 (mem_commonEnvelope childrenD_374_i0 b hb) + +theorem finite_children_work_374 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_374 j) (childrenD_374 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_374_i0.mono (by decide +kernel) + +theorem finite_row_works_374 : FiniteTemplate HasSnaky 3 required_374 envelope_374 := by + refine finite_compose HasSnaky 2 childrenC_374 childrenD_374 finite_children_work_374 (4, 2) + required_374 envelope_374 pivot_mem_374 child_required_sub_374 child_envelope_sub_374 ?_ + intro b hb + exact common_sub_374 (mem_commonEnvelope childrenD_374 b hb) + +theorem finite_children_work_402_i0 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_402_i0 j) (childrenD_402_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 5 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_402_i0 : FiniteTemplate HasSnaky 2 required_402_i0 envelope_402_i0 := by + refine finite_compose HasSnaky 1 childrenC_402_i0 childrenD_402_i0 finite_children_work_402_i0 (2, 4) + required_402_i0 envelope_402_i0 pivot_mem_402_i0 child_required_sub_402_i0 child_envelope_sub_402_i0 ?_ + intro b hb + exact common_sub_402_i0 (mem_commonEnvelope childrenD_402_i0 b hb) + +theorem finite_children_work_402 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_402 j) (childrenD_402 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_38 3 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_402_i0.mono (by decide +kernel) + +theorem finite_row_works_402 : FiniteTemplate HasSnaky 3 required_402 envelope_402 := by + refine finite_compose HasSnaky 2 childrenC_402 childrenD_402 finite_children_work_402 (3, 1) + required_402 envelope_402 pivot_mem_402 child_required_sub_402 child_envelope_sub_402 ?_ + intro b hb + exact common_sub_402 (mem_commonEnvelope childrenD_402 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height04Part01.lean b/lean/snaky/FiniteCards/Height04Part01.lean new file mode 100644 index 0000000..af50710 --- /dev/null +++ b/lean/snaky/FiniteCards/Height04Part01.lean @@ -0,0 +1,306 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_10 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_10 j) (childrenD_10 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_10 : FiniteTemplate HasSnaky 4 required_10 envelope_10 := by + refine finite_compose HasSnaky 3 childrenC_10 childrenD_10 finite_children_work_10 (1, 4) + required_10 envelope_10 pivot_mem_10 child_required_sub_10 child_envelope_sub_10 ?_ + intro b hb + exact common_sub_10 (mem_commonEnvelope childrenD_10 b hb) + +theorem finite_children_work_12 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_12 j) (childrenD_12 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 6 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_12 : FiniteTemplate HasSnaky 4 required_12 envelope_12 := by + refine finite_compose HasSnaky 3 childrenC_12 childrenD_12 finite_children_work_12 (1, 5) + required_12 envelope_12 pivot_mem_12 child_required_sub_12 child_envelope_sub_12 ?_ + intro b hb + exact common_sub_12 (mem_commonEnvelope childrenD_12 b hb) + +theorem finite_children_work_13 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_13 j) (childrenD_13 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 6 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_13 : FiniteTemplate HasSnaky 4 required_13 envelope_13 := by + refine finite_compose HasSnaky 3 childrenC_13 childrenD_13 finite_children_work_13 (1, 5) + required_13 envelope_13 pivot_mem_13 child_required_sub_13 child_envelope_sub_13 ?_ + intro b hb + exact common_sub_13 (mem_commonEnvelope childrenD_13 b hb) + +theorem finite_children_work_14 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_14 j) (childrenD_14 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_14 : FiniteTemplate HasSnaky 4 required_14 envelope_14 := by + refine finite_compose HasSnaky 3 childrenC_14 childrenD_14 finite_children_work_14 (1, 5) + required_14 envelope_14 pivot_mem_14 child_required_sub_14 child_envelope_sub_14 ?_ + intro b hb + exact common_sub_14 (mem_commonEnvelope childrenD_14 b hb) + +theorem finite_children_work_17 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_17 j) (childrenD_17 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_16 2 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_17 : FiniteTemplate HasSnaky 4 required_17 envelope_17 := by + refine finite_compose HasSnaky 3 childrenC_17 childrenD_17 finite_children_work_17 (1, 4) + required_17 envelope_17 pivot_mem_17 child_required_sub_17 child_envelope_sub_17 ?_ + intro b hb + exact common_sub_17 (mem_commonEnvelope childrenD_17 b hb) + +theorem finite_children_work_18 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_18 j) (childrenD_18 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_18 : FiniteTemplate HasSnaky 4 required_18 envelope_18 := by + refine finite_compose HasSnaky 3 childrenC_18 childrenD_18 finite_children_work_18 (1, 4) + required_18 envelope_18 pivot_mem_18 child_required_sub_18 child_envelope_sub_18 ?_ + intro b hb + exact common_sub_18 (mem_commonEnvelope childrenD_18 b hb) + +theorem finite_children_work_26 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_26 j) (childrenD_26 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_7 3 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_26 : FiniteTemplate HasSnaky 4 required_26 envelope_26 := by + refine finite_compose HasSnaky 3 childrenC_26 childrenD_26 finite_children_work_26 (4, 1) + required_26 envelope_26 pivot_mem_26 child_required_sub_26 child_envelope_sub_26 ?_ + intro b hb + exact common_sub_26 (mem_commonEnvelope childrenD_26 b hb) + +theorem finite_children_work_27 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_27 j) (childrenD_27 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_16 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_27 : FiniteTemplate HasSnaky 4 required_27 envelope_27 := by + refine finite_compose HasSnaky 3 childrenC_27 childrenD_27 finite_children_work_27 (0, 4) + required_27 envelope_27 pivot_mem_27 child_required_sub_27 child_envelope_sub_27 ?_ + intro b hb + exact common_sub_27 (mem_commonEnvelope childrenD_27 b hb) + +theorem finite_children_work_31 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_31 j) (childrenD_31 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_31 : FiniteTemplate HasSnaky 4 required_31 envelope_31 := by + refine finite_compose HasSnaky 3 childrenC_31 childrenD_31 finite_children_work_31 (1, 5) + required_31 envelope_31 pivot_mem_31 child_required_sub_31 child_envelope_sub_31 ?_ + intro b hb + exact common_sub_31 (mem_commonEnvelope childrenD_31 b hb) + +theorem finite_children_work_33 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_33 j) (childrenD_33 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_33 : FiniteTemplate HasSnaky 4 required_33 envelope_33 := by + refine finite_compose HasSnaky 3 childrenC_33 childrenD_33 finite_children_work_33 (1, 5) + required_33 envelope_33 pivot_mem_33 child_required_sub_33 child_envelope_sub_33 ?_ + intro b hb + exact common_sub_33 (mem_commonEnvelope childrenD_33 b hb) + +theorem finite_children_work_39 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_39 j) (childrenD_39 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_39 : FiniteTemplate HasSnaky 4 required_39 envelope_39 := by + refine finite_compose HasSnaky 3 childrenC_39 childrenD_39 finite_children_work_39 (1, 3) + required_39 envelope_39 pivot_mem_39 child_required_sub_39 child_envelope_sub_39 ?_ + intro b hb + exact common_sub_39 (mem_commonEnvelope childrenD_39 b hb) + +theorem finite_children_work_41 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_41 j) (childrenD_41 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 2 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_41 : FiniteTemplate HasSnaky 4 required_41 envelope_41 := by + refine finite_compose HasSnaky 3 childrenC_41 childrenD_41 finite_children_work_41 (1, 4) + required_41 envelope_41 pivot_mem_41 child_required_sub_41 child_envelope_sub_41 ?_ + intro b hb + exact common_sub_41 (mem_commonEnvelope childrenD_41 b hb) + +theorem finite_children_work_42 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_42 j) (childrenD_42 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_42 : FiniteTemplate HasSnaky 4 required_42 envelope_42 := by + refine finite_compose HasSnaky 3 childrenC_42 childrenD_42 finite_children_work_42 (1, 3) + required_42 envelope_42 pivot_mem_42 child_required_sub_42 child_envelope_sub_42 ?_ + intro b hb + exact common_sub_42 (mem_commonEnvelope childrenD_42 b hb) + +theorem finite_children_work_46 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_46 j) (childrenD_46 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_45.mono (by decide +kernel) + +theorem finite_row_works_46 : FiniteTemplate HasSnaky 4 required_46 envelope_46 := by + refine finite_compose HasSnaky 3 childrenC_46 childrenD_46 finite_children_work_46 (3, 1) + required_46 envelope_46 pivot_mem_46 child_required_sub_46 child_envelope_sub_46 ?_ + intro b hb + exact common_sub_46 (mem_commonEnvelope childrenD_46 b hb) + +theorem finite_children_work_48 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_48 j) (childrenD_48 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_48 : FiniteTemplate HasSnaky 4 required_48 envelope_48 := by + refine finite_compose HasSnaky 3 childrenC_48 childrenD_48 finite_children_work_48 (1, 4) + required_48 envelope_48 pivot_mem_48 child_required_sub_48 child_envelope_sub_48 ?_ + intro b hb + exact common_sub_48 (mem_commonEnvelope childrenD_48 b hb) + +theorem finite_children_work_49 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_49 j) (childrenD_49 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (0, 0)).mono (by decide +kernel) + +theorem finite_row_works_49 : FiniteTemplate HasSnaky 4 required_49 envelope_49 := by + refine finite_compose HasSnaky 3 childrenC_49 childrenD_49 finite_children_work_49 (4, 1) + required_49 envelope_49 pivot_mem_49 child_required_sub_49 child_envelope_sub_49 ?_ + intro b hb + exact common_sub_49 (mem_commonEnvelope childrenD_49 b hb) + +theorem finite_children_work_50 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_50 j) (childrenD_50 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_50 : FiniteTemplate HasSnaky 4 required_50 envelope_50 := by + refine finite_compose HasSnaky 3 childrenC_50 childrenD_50 finite_children_work_50 (1, 2) + required_50 envelope_50 pivot_mem_50 child_required_sub_50 child_envelope_sub_50 ?_ + intro b hb + exact common_sub_50 (mem_commonEnvelope childrenD_50 b hb) + +theorem finite_children_work_55 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_55 j) (childrenD_55 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_55 : FiniteTemplate HasSnaky 4 required_55 envelope_55 := by + refine finite_compose HasSnaky 3 childrenC_55 childrenD_55 finite_children_work_55 (3, 4) + required_55 envelope_55 pivot_mem_55 child_required_sub_55 child_envelope_sub_55 ?_ + intro b hb + exact common_sub_55 (mem_commonEnvelope childrenD_55 b hb) + +theorem finite_children_work_56 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_56 j) (childrenD_56 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 6 (3, 6)).mono (by decide +kernel) + +theorem finite_row_works_56 : FiniteTemplate HasSnaky 4 required_56 envelope_56 := by + refine finite_compose HasSnaky 3 childrenC_56 childrenD_56 finite_children_work_56 (3, 4) + required_56 envelope_56 pivot_mem_56 child_required_sub_56 child_envelope_sub_56 ?_ + intro b hb + exact common_sub_56 (mem_commonEnvelope childrenD_56 b hb) + +theorem finite_children_work_57 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_57 j) (childrenD_57 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 6 (3, 6)).mono (by decide +kernel) + +theorem finite_row_works_57 : FiniteTemplate HasSnaky 4 required_57 envelope_57 := by + refine finite_compose HasSnaky 3 childrenC_57 childrenD_57 finite_children_work_57 (3, 4) + required_57 envelope_57 pivot_mem_57 child_required_sub_57 child_envelope_sub_57 ?_ + intro b hb + exact common_sub_57 (mem_commonEnvelope childrenD_57 b hb) + +theorem finite_children_work_58 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_58 j) (childrenD_58 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_58 : FiniteTemplate HasSnaky 4 required_58 envelope_58 := by + refine finite_compose HasSnaky 3 childrenC_58 childrenD_58 finite_children_work_58 (4, 3) + required_58 envelope_58 pivot_mem_58 child_required_sub_58 child_envelope_sub_58 ?_ + intro b hb + exact common_sub_58 (mem_commonEnvelope childrenD_58 b hb) + +theorem finite_children_work_60 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_60 j) (childrenD_60 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_60 : FiniteTemplate HasSnaky 4 required_60 envelope_60 := by + refine finite_compose HasSnaky 3 childrenC_60 childrenD_60 finite_children_work_60 (0, 3) + required_60 envelope_60 pivot_mem_60 child_required_sub_60 child_envelope_sub_60 ?_ + intro b hb + exact common_sub_60 (mem_commonEnvelope childrenD_60 b hb) + +theorem finite_children_work_63 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_63 j) (childrenD_63 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_16 2 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_62 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_63 : FiniteTemplate HasSnaky 4 required_63 envelope_63 := by + refine finite_compose HasSnaky 3 childrenC_63 childrenD_63 finite_children_work_63 (1, 4) + required_63 envelope_63 pivot_mem_63 child_required_sub_63 child_envelope_sub_63 ?_ + intro b hb + exact common_sub_63 (mem_commonEnvelope childrenD_63 b hb) + +theorem finite_children_work_65 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_65 j) (childrenD_65 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_20 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_20 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_65 : FiniteTemplate HasSnaky 4 required_65 envelope_65 := by + refine finite_compose HasSnaky 3 childrenC_65 childrenD_65 finite_children_work_65 (1, 5) + required_65 envelope_65 pivot_mem_65 child_required_sub_65 child_envelope_sub_65 ?_ + intro b hb + exact common_sub_65 (mem_commonEnvelope childrenD_65 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height04Part02.lean b/lean/snaky/FiniteCards/Height04Part02.lean new file mode 100644 index 0000000..17f2244 --- /dev/null +++ b/lean/snaky/FiniteCards/Height04Part02.lean @@ -0,0 +1,305 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_67 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_67 j) (childrenD_67 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_32 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_67 : FiniteTemplate HasSnaky 4 required_67 envelope_67 := by + refine finite_compose HasSnaky 3 childrenC_67 childrenD_67 finite_children_work_67 (1, 1) + required_67 envelope_67 pivot_mem_67 child_required_sub_67 child_envelope_sub_67 ?_ + intro b hb + exact common_sub_67 (mem_commonEnvelope childrenD_67 b hb) + +theorem finite_children_work_73 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_73 j) (childrenD_73 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_73 : FiniteTemplate HasSnaky 4 required_73 envelope_73 := by + refine finite_compose HasSnaky 3 childrenC_73 childrenD_73 finite_children_work_73 (2, 3) + required_73 envelope_73 pivot_mem_73 child_required_sub_73 child_envelope_sub_73 ?_ + intro b hb + exact common_sub_73 (mem_commonEnvelope childrenD_73 b hb) + +theorem finite_children_work_75 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_75 j) (childrenD_75 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_20 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_23 6 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_75 : FiniteTemplate HasSnaky 4 required_75 envelope_75 := by + refine finite_compose HasSnaky 3 childrenC_75 childrenD_75 finite_children_work_75 (0, 4) + required_75 envelope_75 pivot_mem_75 child_required_sub_75 child_envelope_sub_75 ?_ + intro b hb + exact common_sub_75 (mem_commonEnvelope childrenD_75 b hb) + +theorem finite_children_work_79 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_79 j) (childrenD_79 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 7 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_79 : FiniteTemplate HasSnaky 4 required_79 envelope_79 := by + refine finite_compose HasSnaky 3 childrenC_79 childrenD_79 finite_children_work_79 (3, 4) + required_79 envelope_79 pivot_mem_79 child_required_sub_79 child_envelope_sub_79 ?_ + intro b hb + exact common_sub_79 (mem_commonEnvelope childrenD_79 b hb) + +theorem finite_children_work_82 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_82 j) (childrenD_82 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_64 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_82 : FiniteTemplate HasSnaky 4 required_82 envelope_82 := by + refine finite_compose HasSnaky 3 childrenC_82 childrenD_82 finite_children_work_82 (4, 3) + required_82 envelope_82 pivot_mem_82 child_required_sub_82 child_envelope_sub_82 ?_ + intro b hb + exact common_sub_82 (mem_commonEnvelope childrenD_82 b hb) + +theorem finite_children_work_86 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_86 j) (childrenD_86 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 7 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_86 : FiniteTemplate HasSnaky 4 required_86 envelope_86 := by + refine finite_compose HasSnaky 3 childrenC_86 childrenD_86 finite_children_work_86 (1, 2) + required_86 envelope_86 pivot_mem_86 child_required_sub_86 child_envelope_sub_86 ?_ + intro b hb + exact common_sub_86 (mem_commonEnvelope childrenD_86 b hb) + +theorem finite_children_work_88 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_88 j) (childrenD_88 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_88 : FiniteTemplate HasSnaky 4 required_88 envelope_88 := by + refine finite_compose HasSnaky 3 childrenC_88 childrenD_88 finite_children_work_88 (3, 4) + required_88 envelope_88 pivot_mem_88 child_required_sub_88 child_envelope_sub_88 ?_ + intro b hb + exact common_sub_88 (mem_commonEnvelope childrenD_88 b hb) + +theorem finite_children_work_89 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_89 j) (childrenD_89 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_7 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_89 : FiniteTemplate HasSnaky 4 required_89 envelope_89 := by + refine finite_compose HasSnaky 3 childrenC_89 childrenD_89 finite_children_work_89 (1, 4) + required_89 envelope_89 pivot_mem_89 child_required_sub_89 child_envelope_sub_89 ?_ + intro b hb + exact common_sub_89 (mem_commonEnvelope childrenD_89 b hb) + +theorem finite_children_work_90 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_90 j) (childrenD_90 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_37 1 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_90 : FiniteTemplate HasSnaky 4 required_90 envelope_90 := by + refine finite_compose HasSnaky 3 childrenC_90 childrenD_90 finite_children_work_90 (4, 1) + required_90 envelope_90 pivot_mem_90 child_required_sub_90 child_envelope_sub_90 ?_ + intro b hb + exact common_sub_90 (mem_commonEnvelope childrenD_90 b hb) + +theorem finite_children_work_91 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_91 j) (childrenD_91 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_16 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_91 : FiniteTemplate HasSnaky 4 required_91 envelope_91 := by + refine finite_compose HasSnaky 3 childrenC_91 childrenD_91 finite_children_work_91 (1, 4) + required_91 envelope_91 pivot_mem_91 child_required_sub_91 child_envelope_sub_91 ?_ + intro b hb + exact common_sub_91 (mem_commonEnvelope childrenD_91 b hb) + +theorem finite_children_work_92 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_92 j) (childrenD_92 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_69.mono (by decide +kernel) + +theorem finite_row_works_92 : FiniteTemplate HasSnaky 4 required_92 envelope_92 := by + refine finite_compose HasSnaky 3 childrenC_92 childrenD_92 finite_children_work_92 (3, 3) + required_92 envelope_92 pivot_mem_92 child_required_sub_92 child_envelope_sub_92 ?_ + intro b hb + exact common_sub_92 (mem_commonEnvelope childrenD_92 b hb) + +theorem finite_children_work_93 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_93 j) (childrenD_93 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_21 3 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_93 : FiniteTemplate HasSnaky 4 required_93 envelope_93 := by + refine finite_compose HasSnaky 3 childrenC_93 childrenD_93 finite_children_work_93 (4, 1) + required_93 envelope_93 pivot_mem_93 child_required_sub_93 child_envelope_sub_93 ?_ + intro b hb + exact common_sub_93 (mem_commonEnvelope childrenD_93 b hb) + +theorem finite_children_work_97 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_97 j) (childrenD_97 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_97 : FiniteTemplate HasSnaky 4 required_97 envelope_97 := by + refine finite_compose HasSnaky 3 childrenC_97 childrenD_97 finite_children_work_97 (1, 2) + required_97 envelope_97 pivot_mem_97 child_required_sub_97 child_envelope_sub_97 ?_ + intro b hb + exact common_sub_97 (mem_commonEnvelope childrenD_97 b hb) + +theorem finite_children_work_98 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_98 j) (childrenD_98 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_16 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_98 : FiniteTemplate HasSnaky 4 required_98 envelope_98 := by + refine finite_compose HasSnaky 3 childrenC_98 childrenD_98 finite_children_work_98 (0, 2) + required_98 envelope_98 pivot_mem_98 child_required_sub_98 child_envelope_sub_98 ?_ + intro b hb + exact common_sub_98 (mem_commonEnvelope childrenD_98 b hb) + +theorem finite_children_work_99 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_99 j) (childrenD_99 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_99 : FiniteTemplate HasSnaky 4 required_99 envelope_99 := by + refine finite_compose HasSnaky 3 childrenC_99 childrenD_99 finite_children_work_99 (3, 2) + required_99 envelope_99 pivot_mem_99 child_required_sub_99 child_envelope_sub_99 ?_ + intro b hb + exact common_sub_99 (mem_commonEnvelope childrenD_99 b hb) + +theorem finite_children_work_106 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_106 j) (childrenD_106 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_7 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_106 : FiniteTemplate HasSnaky 4 required_106 envelope_106 := by + refine finite_compose HasSnaky 3 childrenC_106 childrenD_106 finite_children_work_106 (1, 1) + required_106 envelope_106 pivot_mem_106 child_required_sub_106 child_envelope_sub_106 ?_ + intro b hb + exact common_sub_106 (mem_commonEnvelope childrenD_106 b hb) + +theorem finite_children_work_109 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_109 j) (childrenD_109 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_109 : FiniteTemplate HasSnaky 4 required_109 envelope_109 := by + refine finite_compose HasSnaky 3 childrenC_109 childrenD_109 finite_children_work_109 (2, 3) + required_109 envelope_109 pivot_mem_109 child_required_sub_109 child_envelope_sub_109 ?_ + intro b hb + exact common_sub_109 (mem_commonEnvelope childrenD_109 b hb) + +theorem finite_children_work_112 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_112 j) (childrenD_112 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_34 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_112 : FiniteTemplate HasSnaky 4 required_112 envelope_112 := by + refine finite_compose HasSnaky 3 childrenC_112 childrenD_112 finite_children_work_112 (2, 3) + required_112 envelope_112 pivot_mem_112 child_required_sub_112 child_envelope_sub_112 ?_ + intro b hb + exact common_sub_112 (mem_commonEnvelope childrenD_112 b hb) + +theorem finite_children_work_125 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_125 j) (childrenD_125 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_124.mono (by decide +kernel) + +theorem finite_row_works_125 : FiniteTemplate HasSnaky 4 required_125 envelope_125 := by + refine finite_compose HasSnaky 3 childrenC_125 childrenD_125 finite_children_work_125 (1, 2) + required_125 envelope_125 pivot_mem_125 child_required_sub_125 child_envelope_sub_125 ?_ + intro b hb + exact common_sub_125 (mem_commonEnvelope childrenD_125 b hb) + +theorem finite_children_work_127 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_127 j) (childrenD_127 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_124 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_127 : FiniteTemplate HasSnaky 4 required_127 envelope_127 := by + refine finite_compose HasSnaky 3 childrenC_127 childrenD_127 finite_children_work_127 (1, 5) + required_127 envelope_127 pivot_mem_127 child_required_sub_127 child_envelope_sub_127 ?_ + intro b hb + exact common_sub_127 (mem_commonEnvelope childrenD_127 b hb) + +theorem finite_children_work_128 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_128 j) (childrenD_128 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_16 2 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_124 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_128 : FiniteTemplate HasSnaky 4 required_128 envelope_128 := by + refine finite_compose HasSnaky 3 childrenC_128 childrenD_128 finite_children_work_128 (1, 5) + required_128 envelope_128 pivot_mem_128 child_required_sub_128 child_envelope_sub_128 ?_ + intro b hb + exact common_sub_128 (mem_commonEnvelope childrenD_128 b hb) + +theorem finite_children_work_132 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_132 j) (childrenD_132 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_131 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_132 : FiniteTemplate HasSnaky 4 required_132 envelope_132 := by + refine finite_compose HasSnaky 3 childrenC_132 childrenD_132 finite_children_work_132 (1, 3) + required_132 envelope_132 pivot_mem_132 child_required_sub_132 child_envelope_sub_132 ?_ + intro b hb + exact common_sub_132 (mem_commonEnvelope childrenD_132 b hb) + +theorem finite_children_work_141 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_141 j) (childrenD_141 j) := by + intro j + fin_cases j + · exact finite_row_works_53.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_76 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_141 : FiniteTemplate HasSnaky 4 required_141 envelope_141 := by + refine finite_compose HasSnaky 3 childrenC_141 childrenD_141 finite_children_work_141 (1, 4) + required_141 envelope_141 pivot_mem_141 child_required_sub_141 child_envelope_sub_141 ?_ + intro b hb + exact common_sub_141 (mem_commonEnvelope childrenD_141 b hb) + +theorem finite_children_work_148 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_148 j) (childrenD_148 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_21 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_148 : FiniteTemplate HasSnaky 4 required_148 envelope_148 := by + refine finite_compose HasSnaky 3 childrenC_148 childrenD_148 finite_children_work_148 (1, 4) + required_148 envelope_148 pivot_mem_148 child_required_sub_148 child_envelope_sub_148 ?_ + intro b hb + exact common_sub_148 (mem_commonEnvelope childrenD_148 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height04Part03.lean b/lean/snaky/FiniteCards/Height04Part03.lean new file mode 100644 index 0000000..81d6e45 --- /dev/null +++ b/lean/snaky/FiniteCards/Height04Part03.lean @@ -0,0 +1,306 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_149 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_149 j) (childrenD_149 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_124.mono (by decide +kernel) + +theorem finite_row_works_149 : FiniteTemplate HasSnaky 4 required_149 envelope_149 := by + refine finite_compose HasSnaky 3 childrenC_149 childrenD_149 finite_children_work_149 (1, 3) + required_149 envelope_149 pivot_mem_149 child_required_sub_149 child_envelope_sub_149 ?_ + intro b hb + exact common_sub_149 (mem_commonEnvelope childrenD_149 b hb) + +theorem finite_children_work_150 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_150 j) (childrenD_150 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_7 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_150 : FiniteTemplate HasSnaky 4 required_150 envelope_150 := by + refine finite_compose HasSnaky 3 childrenC_150 childrenD_150 finite_children_work_150 (1, 2) + required_150 envelope_150 pivot_mem_150 child_required_sub_150 child_envelope_sub_150 ?_ + intro b hb + exact common_sub_150 (mem_commonEnvelope childrenD_150 b hb) + +theorem finite_children_work_151 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_151 j) (childrenD_151 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_35 7 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_151 : FiniteTemplate HasSnaky 4 required_151 envelope_151 := by + refine finite_compose HasSnaky 3 childrenC_151 childrenD_151 finite_children_work_151 (4, 2) + required_151 envelope_151 pivot_mem_151 child_required_sub_151 child_envelope_sub_151 ?_ + intro b hb + exact common_sub_151 (mem_commonEnvelope childrenD_151 b hb) + +theorem finite_children_work_165 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_165 j) (childrenD_165 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_64 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_165 : FiniteTemplate HasSnaky 4 required_165 envelope_165 := by + refine finite_compose HasSnaky 3 childrenC_165 childrenD_165 finite_children_work_165 (4, 3) + required_165 envelope_165 pivot_mem_165 child_required_sub_165 child_envelope_sub_165 ?_ + intro b hb + exact common_sub_165 (mem_commonEnvelope childrenD_165 b hb) + +theorem finite_children_work_168 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_168 j) (childrenD_168 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_131 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_168 : FiniteTemplate HasSnaky 4 required_168 envelope_168 := by + refine finite_compose HasSnaky 3 childrenC_168 childrenD_168 finite_children_work_168 (2, 2) + required_168 envelope_168 pivot_mem_168 child_required_sub_168 child_envelope_sub_168 ?_ + intro b hb + exact common_sub_168 (mem_commonEnvelope childrenD_168 b hb) + +theorem finite_children_work_178 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_178 j) (childrenD_178 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_177 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_178 : FiniteTemplate HasSnaky 4 required_178 envelope_178 := by + refine finite_compose HasSnaky 3 childrenC_178 childrenD_178 finite_children_work_178 (1, 1) + required_178 envelope_178 pivot_mem_178 child_required_sub_178 child_envelope_sub_178 ?_ + intro b hb + exact common_sub_178 (mem_commonEnvelope childrenD_178 b hb) + +theorem finite_children_work_185 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_185 j) (childrenD_185 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_113.mono (by decide +kernel) + +theorem finite_row_works_185 : FiniteTemplate HasSnaky 4 required_185 envelope_185 := by + refine finite_compose HasSnaky 3 childrenC_185 childrenD_185 finite_children_work_185 (1, 4) + required_185 envelope_185 pivot_mem_185 child_required_sub_185 child_envelope_sub_185 ?_ + intro b hb + exact common_sub_185 (mem_commonEnvelope childrenD_185 b hb) + +theorem finite_children_work_194 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_194 j) (childrenD_194 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_194 : FiniteTemplate HasSnaky 4 required_194 envelope_194 := by + refine finite_compose HasSnaky 3 childrenC_194 childrenD_194 finite_children_work_194 (1, 4) + required_194 envelope_194 pivot_mem_194 child_required_sub_194 child_envelope_sub_194 ?_ + intro b hb + exact common_sub_194 (mem_commonEnvelope childrenD_194 b hb) + +theorem finite_children_work_195 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_195 j) (childrenD_195 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_7 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_195 : FiniteTemplate HasSnaky 4 required_195 envelope_195 := by + refine finite_compose HasSnaky 3 childrenC_195 childrenD_195 finite_children_work_195 (1, 4) + required_195 envelope_195 pivot_mem_195 child_required_sub_195 child_envelope_sub_195 ?_ + intro b hb + exact common_sub_195 (mem_commonEnvelope childrenD_195 b hb) + +theorem finite_children_work_196 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_196 j) (childrenD_196 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_143 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_196 : FiniteTemplate HasSnaky 4 required_196 envelope_196 := by + refine finite_compose HasSnaky 3 childrenC_196 childrenD_196 finite_children_work_196 (3, 0) + required_196 envelope_196 pivot_mem_196 child_required_sub_196 child_envelope_sub_196 ?_ + intro b hb + exact common_sub_196 (mem_commonEnvelope childrenD_196 b hb) + +theorem finite_children_work_199 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_199 j) (childrenD_199 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 5 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_198.mono (by decide +kernel) + +theorem finite_row_works_199 : FiniteTemplate HasSnaky 4 required_199 envelope_199 := by + refine finite_compose HasSnaky 3 childrenC_199 childrenD_199 finite_children_work_199 (1, 1) + required_199 envelope_199 pivot_mem_199 child_required_sub_199 child_envelope_sub_199 ?_ + intro b hb + exact common_sub_199 (mem_commonEnvelope childrenD_199 b hb) + +theorem finite_children_work_206 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_206 j) (childrenD_206 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 5 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_205.mono (by decide +kernel) + +theorem finite_row_works_206 : FiniteTemplate HasSnaky 4 required_206 envelope_206 := by + refine finite_compose HasSnaky 3 childrenC_206 childrenD_206 finite_children_work_206 (1, 1) + required_206 envelope_206 pivot_mem_206 child_required_sub_206 child_envelope_sub_206 ?_ + intro b hb + exact common_sub_206 (mem_commonEnvelope childrenD_206 b hb) + +theorem finite_children_work_208 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_208 j) (childrenD_208 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_207 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_208 : FiniteTemplate HasSnaky 4 required_208 envelope_208 := by + refine finite_compose HasSnaky 3 childrenC_208 childrenD_208 finite_children_work_208 (4, 0) + required_208 envelope_208 pivot_mem_208 child_required_sub_208 child_envelope_sub_208 ?_ + intro b hb + exact common_sub_208 (mem_commonEnvelope childrenD_208 b hb) + +theorem finite_children_work_213 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_213 j) (childrenD_213 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 2 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_212 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_213 : FiniteTemplate HasSnaky 4 required_213 envelope_213 := by + refine finite_compose HasSnaky 3 childrenC_213 childrenD_213 finite_children_work_213 (1, 4) + required_213 envelope_213 pivot_mem_213 child_required_sub_213 child_envelope_sub_213 ?_ + intro b hb + exact common_sub_213 (mem_commonEnvelope childrenD_213 b hb) + +theorem finite_children_work_216 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_216 j) (childrenD_216 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_54 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_216 : FiniteTemplate HasSnaky 4 required_216 envelope_216 := by + refine finite_compose HasSnaky 3 childrenC_216 childrenD_216 finite_children_work_216 (4, 3) + required_216 envelope_216 pivot_mem_216 child_required_sub_216 child_envelope_sub_216 ?_ + intro b hb + exact common_sub_216 (mem_commonEnvelope childrenD_216 b hb) + +theorem finite_children_work_227 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_227 j) (childrenD_227 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 2 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_227 : FiniteTemplate HasSnaky 4 required_227 envelope_227 := by + refine finite_compose HasSnaky 3 childrenC_227 childrenD_227 finite_children_work_227 (1, 4) + required_227 envelope_227 pivot_mem_227 child_required_sub_227 child_envelope_sub_227 ?_ + intro b hb + exact common_sub_227 (mem_commonEnvelope childrenD_227 b hb) + +theorem finite_children_work_229 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_229 j) (childrenD_229 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_215.mono (by decide +kernel) + +theorem finite_row_works_229 : FiniteTemplate HasSnaky 4 required_229 envelope_229 := by + refine finite_compose HasSnaky 3 childrenC_229 childrenD_229 finite_children_work_229 (3, 3) + required_229 envelope_229 pivot_mem_229 child_required_sub_229 child_envelope_sub_229 ?_ + intro b hb + exact common_sub_229 (mem_commonEnvelope childrenD_229 b hb) + +theorem finite_children_work_235 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_235 j) (childrenD_235 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_226 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_235 : FiniteTemplate HasSnaky 4 required_235 envelope_235 := by + refine finite_compose HasSnaky 3 childrenC_235 childrenD_235 finite_children_work_235 (2, 1) + required_235 envelope_235 pivot_mem_235 child_required_sub_235 child_envelope_sub_235 ?_ + intro b hb + exact common_sub_235 (mem_commonEnvelope childrenD_235 b hb) + +theorem finite_children_work_240 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_240 j) (childrenD_240 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_240 : FiniteTemplate HasSnaky 4 required_240 envelope_240 := by + refine finite_compose HasSnaky 3 childrenC_240 childrenD_240 finite_children_work_240 (2, 3) + required_240 envelope_240 pivot_mem_240 child_required_sub_240 child_envelope_sub_240 ?_ + intro b hb + exact common_sub_240 (mem_commonEnvelope childrenD_240 b hb) + +theorem finite_children_work_242 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_242 j) (childrenD_242 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_69 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_242 : FiniteTemplate HasSnaky 4 required_242 envelope_242 := by + refine finite_compose HasSnaky 3 childrenC_242 childrenD_242 finite_children_work_242 (4, 2) + required_242 envelope_242 pivot_mem_242 child_required_sub_242 child_envelope_sub_242 ?_ + intro b hb + exact common_sub_242 (mem_commonEnvelope childrenD_242 b hb) + +theorem finite_children_work_259 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_259 j) (childrenD_259 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_159 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_259 : FiniteTemplate HasSnaky 4 required_259 envelope_259 := by + refine finite_compose HasSnaky 3 childrenC_259 childrenD_259 finite_children_work_259 (2, 4) + required_259 envelope_259 pivot_mem_259 child_required_sub_259 child_envelope_sub_259 ?_ + intro b hb + exact common_sub_259 (mem_commonEnvelope childrenD_259 b hb) + +theorem finite_children_work_263 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_263 j) (childrenD_263 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 5 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_263 : FiniteTemplate HasSnaky 4 required_263 envelope_263 := by + refine finite_compose HasSnaky 3 childrenC_263 childrenD_263 finite_children_work_263 (3, 4) + required_263 envelope_263 pivot_mem_263 child_required_sub_263 child_envelope_sub_263 ?_ + intro b hb + exact common_sub_263 (mem_commonEnvelope childrenD_263 b hb) + +theorem finite_children_work_264 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_264 j) (childrenD_264 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_201 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_264 : FiniteTemplate HasSnaky 4 required_264 envelope_264 := by + refine finite_compose HasSnaky 3 childrenC_264 childrenD_264 finite_children_work_264 (1, 4) + required_264 envelope_264 pivot_mem_264 child_required_sub_264 child_envelope_sub_264 ?_ + intro b hb + exact common_sub_264 (mem_commonEnvelope childrenD_264 b hb) + +theorem finite_children_work_266 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_266 j) (childrenD_266 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_16 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_113 4 (0, 7)).mono (by decide +kernel) + +theorem finite_row_works_266 : FiniteTemplate HasSnaky 4 required_266 envelope_266 := by + refine finite_compose HasSnaky 3 childrenC_266 childrenD_266 finite_children_work_266 (0, 6) + required_266 envelope_266 pivot_mem_266 child_required_sub_266 child_envelope_sub_266 ?_ + intro b hb + exact common_sub_266 (mem_commonEnvelope childrenD_266 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height04Part04.lean b/lean/snaky/FiniteCards/Height04Part04.lean new file mode 100644 index 0000000..6c580db --- /dev/null +++ b/lean/snaky/FiniteCards/Height04Part04.lean @@ -0,0 +1,284 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_268 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_268 j) (childrenD_268 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 6 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_268 : FiniteTemplate HasSnaky 4 required_268 envelope_268 := by + refine finite_compose HasSnaky 3 childrenC_268 childrenD_268 finite_children_work_268 (1, 4) + required_268 envelope_268 pivot_mem_268 child_required_sub_268 child_envelope_sub_268 ?_ + intro b hb + exact common_sub_268 (mem_commonEnvelope childrenD_268 b hb) + +theorem finite_children_work_269 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_269 j) (childrenD_269 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_21 2 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_269 : FiniteTemplate HasSnaky 4 required_269 envelope_269 := by + refine finite_compose HasSnaky 3 childrenC_269 childrenD_269 finite_children_work_269 (1, 5) + required_269 envelope_269 pivot_mem_269 child_required_sub_269 child_envelope_sub_269 ?_ + intro b hb + exact common_sub_269 (mem_commonEnvelope childrenD_269 b hb) + +theorem finite_children_work_271 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_271 j) (childrenD_271 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_271 : FiniteTemplate HasSnaky 4 required_271 envelope_271 := by + refine finite_compose HasSnaky 3 childrenC_271 childrenD_271 finite_children_work_271 (2, 3) + required_271 envelope_271 pivot_mem_271 child_required_sub_271 child_envelope_sub_271 ?_ + intro b hb + exact common_sub_271 (mem_commonEnvelope childrenD_271 b hb) + +theorem finite_children_work_277 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_277 j) (childrenD_277 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_69 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_277 : FiniteTemplate HasSnaky 4 required_277 envelope_277 := by + refine finite_compose HasSnaky 3 childrenC_277 childrenD_277 finite_children_work_277 (1, 3) + required_277 envelope_277 pivot_mem_277 child_required_sub_277 child_envelope_sub_277 ?_ + intro b hb + exact common_sub_277 (mem_commonEnvelope childrenD_277 b hb) + +theorem finite_children_work_288 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_288 j) (childrenD_288 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 3 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_68.mono (by decide +kernel) + +theorem finite_row_works_288 : FiniteTemplate HasSnaky 4 required_288 envelope_288 := by + refine finite_compose HasSnaky 3 childrenC_288 childrenD_288 finite_children_work_288 (1, 5) + required_288 envelope_288 pivot_mem_288 child_required_sub_288 child_envelope_sub_288 ?_ + intro b hb + exact common_sub_288 (mem_commonEnvelope childrenD_288 b hb) + +theorem finite_children_work_289 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_289 j) (childrenD_289 j) := by + intro j + fin_cases j + · exact finite_row_works_22.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_28 4 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_126 6 (2, 5)).mono (by decide +kernel) + +theorem finite_row_works_289 : FiniteTemplate HasSnaky 4 required_289 envelope_289 := by + refine finite_compose HasSnaky 3 childrenC_289 childrenD_289 finite_children_work_289 (1, 2) + required_289 envelope_289 pivot_mem_289 child_required_sub_289 child_envelope_sub_289 ?_ + intro b hb + exact common_sub_289 (mem_commonEnvelope childrenD_289 b hb) + +theorem finite_children_work_291 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_291 j) (childrenD_291 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_25 5 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_291 : FiniteTemplate HasSnaky 4 required_291 envelope_291 := by + refine finite_compose HasSnaky 3 childrenC_291 childrenD_291 finite_children_work_291 (3, 4) + required_291 envelope_291 pivot_mem_291 child_required_sub_291 child_envelope_sub_291 ?_ + intro b hb + exact common_sub_291 (mem_commonEnvelope childrenD_291 b hb) + +theorem finite_children_work_304 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_304 j) (childrenD_304 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 6 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_304 : FiniteTemplate HasSnaky 4 required_304 envelope_304 := by + refine finite_compose HasSnaky 3 childrenC_304 childrenD_304 finite_children_work_304 (1, 4) + required_304 envelope_304 pivot_mem_304 child_required_sub_304 child_envelope_sub_304 ?_ + intro b hb + exact common_sub_304 (mem_commonEnvelope childrenD_304 b hb) + +theorem finite_children_work_305 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_305 j) (childrenD_305 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_124 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_305 : FiniteTemplate HasSnaky 4 required_305 envelope_305 := by + refine finite_compose HasSnaky 3 childrenC_305 childrenD_305 finite_children_work_305 (1, 3) + required_305 envelope_305 pivot_mem_305 child_required_sub_305 child_envelope_sub_305 ?_ + intro b hb + exact common_sub_305 (mem_commonEnvelope childrenD_305 b hb) + +theorem finite_children_work_307 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_307 j) (childrenD_307 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_131 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_307 : FiniteTemplate HasSnaky 4 required_307 envelope_307 := by + refine finite_compose HasSnaky 3 childrenC_307 childrenD_307 finite_children_work_307 (4, 2) + required_307 envelope_307 pivot_mem_307 child_required_sub_307 child_envelope_sub_307 ?_ + intro b hb + exact common_sub_307 (mem_commonEnvelope childrenD_307 b hb) + +theorem finite_children_work_311_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_311_i0 j) (childrenD_311_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_311_i0 : FiniteTemplate HasSnaky 3 required_311_i0 envelope_311_i0 := by + refine finite_compose HasSnaky 2 childrenC_311_i0 childrenD_311_i0 finite_children_work_311_i0 (4, 1) + required_311_i0 envelope_311_i0 pivot_mem_311_i0 child_required_sub_311_i0 child_envelope_sub_311_i0 ?_ + intro b hb + exact common_sub_311_i0 (mem_commonEnvelope childrenD_311_i0 b hb) + +theorem finite_children_work_311 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_311 j) (childrenD_311 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_311_i0.mono (by decide +kernel) + +theorem finite_row_works_311 : FiniteTemplate HasSnaky 4 required_311 envelope_311 := by + refine finite_compose HasSnaky 3 childrenC_311 childrenD_311 finite_children_work_311 (3, 1) + required_311 envelope_311 pivot_mem_311 child_required_sub_311 child_envelope_sub_311 ?_ + intro b hb + exact common_sub_311 (mem_commonEnvelope childrenD_311 b hb) + +theorem finite_children_work_334 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_334 j) (childrenD_334 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_101 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_101 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_333 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_333 6 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_334 : FiniteTemplate HasSnaky 4 required_334 envelope_334 := by + refine finite_compose HasSnaky 3 childrenC_334 childrenD_334 finite_children_work_334 (1, 5) + required_334 envelope_334 pivot_mem_334 child_required_sub_334 child_envelope_sub_334 ?_ + intro b hb + exact common_sub_334 (mem_commonEnvelope childrenD_334 b hb) + +theorem finite_children_work_351 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_351 j) (childrenD_351 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_350.mono (by decide +kernel) + +theorem finite_row_works_351 : FiniteTemplate HasSnaky 4 required_351 envelope_351 := by + refine finite_compose HasSnaky 3 childrenC_351 childrenD_351 finite_children_work_351 (3, 1) + required_351 envelope_351 pivot_mem_351 child_required_sub_351 child_envelope_sub_351 ?_ + intro b hb + exact common_sub_351 (mem_commonEnvelope childrenD_351 b hb) + +theorem finite_children_work_354_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_354_i0 j) (childrenD_354_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_70 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_354_i0 : FiniteTemplate HasSnaky 3 required_354_i0 envelope_354_i0 := by + refine finite_compose HasSnaky 2 childrenC_354_i0 childrenD_354_i0 finite_children_work_354_i0 (3, 2) + required_354_i0 envelope_354_i0 pivot_mem_354_i0 child_required_sub_354_i0 child_envelope_sub_354_i0 ?_ + intro b hb + exact common_sub_354_i0 (mem_commonEnvelope childrenD_354_i0 b hb) + +theorem finite_children_work_354 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_354 j) (childrenD_354 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_354_i0.mono (by decide +kernel) + +theorem finite_row_works_354 : FiniteTemplate HasSnaky 4 required_354 envelope_354 := by + refine finite_compose HasSnaky 3 childrenC_354 childrenD_354 finite_children_work_354 (3, 0) + required_354 envelope_354 pivot_mem_354 child_required_sub_354 child_envelope_sub_354 ?_ + intro b hb + exact common_sub_354 (mem_commonEnvelope childrenD_354 b hb) + +theorem finite_children_work_365_i1 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_365_i1 j) (childrenD_365_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 5 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_0 7 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_365_i1 : FiniteTemplate HasSnaky 2 required_365_i1 envelope_365_i1 := by + refine finite_compose HasSnaky 1 childrenC_365_i1 childrenD_365_i1 finite_children_work_365_i1 (0, 4) + required_365_i1 envelope_365_i1 pivot_mem_365_i1 child_required_sub_365_i1 child_envelope_sub_365_i1 ?_ + intro b hb + exact common_sub_365_i1 (mem_commonEnvelope childrenD_365_i1 b hb) + +theorem finite_children_work_365_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_365_i0 j) (childrenD_365_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_365_i1.mono (by decide +kernel) + +theorem finite_row_works_365_i0 : FiniteTemplate HasSnaky 3 required_365_i0 envelope_365_i0 := by + refine finite_compose HasSnaky 2 childrenC_365_i0 childrenD_365_i0 finite_children_work_365_i0 (0, 3) + required_365_i0 envelope_365_i0 pivot_mem_365_i0 child_required_sub_365_i0 child_envelope_sub_365_i0 ?_ + intro b hb + exact common_sub_365_i0 (mem_commonEnvelope childrenD_365_i0 b hb) + +theorem finite_children_work_365 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_365 j) (childrenD_365 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_365_i0.mono (by decide +kernel) + +theorem finite_row_works_365 : FiniteTemplate HasSnaky 4 required_365 envelope_365 := by + refine finite_compose HasSnaky 3 childrenC_365 childrenD_365 finite_children_work_365 (1, 6) + required_365 envelope_365 pivot_mem_365 child_required_sub_365 child_envelope_sub_365 ?_ + intro b hb + exact common_sub_365 (mem_commonEnvelope childrenD_365 b hb) + +theorem finite_children_work_375 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_375 j) (childrenD_375 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_374.mono (by decide +kernel) + +theorem finite_row_works_375 : FiniteTemplate HasSnaky 4 required_375 envelope_375 := by + refine finite_compose HasSnaky 3 childrenC_375 childrenD_375 finite_children_work_375 (3, 1) + required_375 envelope_375 pivot_mem_375 child_required_sub_375 child_envelope_sub_375 ?_ + intro b hb + exact common_sub_375 (mem_commonEnvelope childrenD_375 b hb) + +theorem finite_children_work_376_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_376_i0 j) (childrenD_376_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 3 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_77 5 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_376_i0 : FiniteTemplate HasSnaky 3 required_376_i0 envelope_376_i0 := by + refine finite_compose HasSnaky 2 childrenC_376_i0 childrenD_376_i0 finite_children_work_376_i0 (2, 4) + required_376_i0 envelope_376_i0 pivot_mem_376_i0 child_required_sub_376_i0 child_envelope_sub_376_i0 ?_ + intro b hb + exact common_sub_376_i0 (mem_commonEnvelope childrenD_376_i0 b hb) + +theorem finite_children_work_376 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_376 j) (childrenD_376 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_376_i0.mono (by decide +kernel) + +theorem finite_row_works_376 : FiniteTemplate HasSnaky 4 required_376 envelope_376 := by + refine finite_compose HasSnaky 3 childrenC_376 childrenD_376 finite_children_work_376 (3, 0) + required_376 envelope_376 pivot_mem_376 child_required_sub_376 child_envelope_sub_376 ?_ + intro b hb + exact common_sub_376 (mem_commonEnvelope childrenD_376 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height04Part05.lean b/lean/snaky/FiniteCards/Height04Part05.lean new file mode 100644 index 0000000..590aeca --- /dev/null +++ b/lean/snaky/FiniteCards/Height04Part05.lean @@ -0,0 +1,147 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_381_i1 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_381_i1 j) (childrenD_381_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 4 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_381_i1 : FiniteTemplate HasSnaky 2 required_381_i1 envelope_381_i1 := by + refine finite_compose HasSnaky 1 childrenC_381_i1 childrenD_381_i1 finite_children_work_381_i1 (4, 1) + required_381_i1 envelope_381_i1 pivot_mem_381_i1 child_required_sub_381_i1 child_envelope_sub_381_i1 ?_ + intro b hb + exact common_sub_381_i1 (mem_commonEnvelope childrenD_381_i1 b hb) + +theorem finite_children_work_381_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_381_i0 j) (childrenD_381_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_381_i1.mono (by decide +kernel) + +theorem finite_row_works_381_i0 : FiniteTemplate HasSnaky 3 required_381_i0 envelope_381_i0 := by + refine finite_compose HasSnaky 2 childrenC_381_i0 childrenD_381_i0 finite_children_work_381_i0 (4, 0) + required_381_i0 envelope_381_i0 pivot_mem_381_i0 child_required_sub_381_i0 child_envelope_sub_381_i0 ?_ + intro b hb + exact common_sub_381_i0 (mem_commonEnvelope childrenD_381_i0 b hb) + +theorem finite_children_work_381 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_381 j) (childrenD_381 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_381_i0.mono (by decide +kernel) + +theorem finite_row_works_381 : FiniteTemplate HasSnaky 4 required_381 envelope_381 := by + refine finite_compose HasSnaky 3 childrenC_381 childrenD_381 finite_children_work_381 (3, 1) + required_381 envelope_381 pivot_mem_381 child_required_sub_381 child_envelope_sub_381 ?_ + intro b hb + exact common_sub_381 (mem_commonEnvelope childrenD_381 b hb) + +theorem finite_children_work_424_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_424_i0 j) (childrenD_424_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 0 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_424_i0 : FiniteTemplate HasSnaky 3 required_424_i0 envelope_424_i0 := by + refine finite_compose HasSnaky 2 childrenC_424_i0 childrenD_424_i0 finite_children_work_424_i0 (4, 2) + required_424_i0 envelope_424_i0 pivot_mem_424_i0 child_required_sub_424_i0 child_envelope_sub_424_i0 ?_ + intro b hb + exact common_sub_424_i0 (mem_commonEnvelope childrenD_424_i0 b hb) + +theorem finite_children_work_424 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_424 j) (childrenD_424 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_25 5 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_424_i0.mono (by decide +kernel) + +theorem finite_row_works_424 : FiniteTemplate HasSnaky 4 required_424 envelope_424 := by + refine finite_compose HasSnaky 3 childrenC_424 childrenD_424 finite_children_work_424 (3, 4) + required_424 envelope_424 pivot_mem_424 child_required_sub_424 child_envelope_sub_424 ?_ + intro b hb + exact common_sub_424 (mem_commonEnvelope childrenD_424 b hb) + +theorem finite_children_work_432_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_432_i0 j) (childrenD_432_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_146 5 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_432_i0 : FiniteTemplate HasSnaky 3 required_432_i0 envelope_432_i0 := by + refine finite_compose HasSnaky 2 childrenC_432_i0 childrenD_432_i0 finite_children_work_432_i0 (4, 1) + required_432_i0 envelope_432_i0 pivot_mem_432_i0 child_required_sub_432_i0 child_envelope_sub_432_i0 ?_ + intro b hb + exact common_sub_432_i0 (mem_commonEnvelope childrenD_432_i0 b hb) + +theorem finite_children_work_432 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_432 j) (childrenD_432 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_432_i0.mono (by decide +kernel) + +theorem finite_row_works_432 : FiniteTemplate HasSnaky 4 required_432 envelope_432 := by + refine finite_compose HasSnaky 3 childrenC_432 childrenD_432 finite_children_work_432 (4, 0) + required_432 envelope_432 pivot_mem_432 child_required_sub_432 child_envelope_sub_432 ?_ + intro b hb + exact common_sub_432 (mem_commonEnvelope childrenD_432 b hb) + +theorem finite_children_work_496_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_496_i0 j) (childrenD_496_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_30 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_496_i0 : FiniteTemplate HasSnaky 3 required_496_i0 envelope_496_i0 := by + refine finite_compose HasSnaky 2 childrenC_496_i0 childrenD_496_i0 finite_children_work_496_i0 (1, 2) + required_496_i0 envelope_496_i0 pivot_mem_496_i0 child_required_sub_496_i0 child_envelope_sub_496_i0 ?_ + intro b hb + exact common_sub_496_i0 (mem_commonEnvelope childrenD_496_i0 b hb) + +theorem finite_children_work_496 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_496 j) (childrenD_496 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_496_i0.mono (by decide +kernel) + +theorem finite_row_works_496 : FiniteTemplate HasSnaky 4 required_496 envelope_496 := by + refine finite_compose HasSnaky 3 childrenC_496 childrenD_496 finite_children_work_496 (1, 1) + required_496 envelope_496 pivot_mem_496 child_required_sub_496 child_envelope_sub_496 ?_ + intro b hb + exact common_sub_496 (mem_commonEnvelope childrenD_496 b hb) + +theorem finite_children_work_500_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_500_i0 j) (childrenD_500_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_146.mono (by decide +kernel) + +theorem finite_row_works_500_i0 : FiniteTemplate HasSnaky 3 required_500_i0 envelope_500_i0 := by + refine finite_compose HasSnaky 2 childrenC_500_i0 childrenD_500_i0 finite_children_work_500_i0 (1, 1) + required_500_i0 envelope_500_i0 pivot_mem_500_i0 child_required_sub_500_i0 child_envelope_sub_500_i0 ?_ + intro b hb + exact common_sub_500_i0 (mem_commonEnvelope childrenD_500_i0 b hb) + +theorem finite_children_work_500 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_500 j) (childrenD_500 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_500_i0.mono (by decide +kernel) + +theorem finite_row_works_500 : FiniteTemplate HasSnaky 4 required_500 envelope_500 := by + refine finite_compose HasSnaky 3 childrenC_500 childrenD_500 finite_children_work_500 (1, 2) + required_500 envelope_500 pivot_mem_500 child_required_sub_500 child_envelope_sub_500 ?_ + intro b hb + exact common_sub_500 (mem_commonEnvelope childrenD_500 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height05Part01.lean b/lean/snaky/FiniteCards/Height05Part01.lean new file mode 100644 index 0000000..5e47b0e --- /dev/null +++ b/lean/snaky/FiniteCards/Height05Part01.lean @@ -0,0 +1,313 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_19 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_19 j) (childrenD_19 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_18 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_19 : FiniteTemplate HasSnaky 5 required_19 envelope_19 := by + refine finite_compose HasSnaky 4 childrenC_19 childrenD_19 finite_children_work_19 (0, 1) + required_19 envelope_19 pivot_mem_19 child_required_sub_19 child_envelope_sub_19 ?_ + intro b hb + exact common_sub_19 (mem_commonEnvelope childrenD_19 b hb) + +theorem finite_children_work_47 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_47 j) (childrenD_47 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_46 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_47 : FiniteTemplate HasSnaky 5 required_47 envelope_47 := by + refine finite_compose HasSnaky 4 childrenC_47 childrenD_47 finite_children_work_47 (4, 2) + required_47 envelope_47 pivot_mem_47 child_required_sub_47 child_envelope_sub_47 ?_ + intro b hb + exact common_sub_47 (mem_commonEnvelope childrenD_47 b hb) + +theorem finite_children_work_59 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_59 j) (childrenD_59 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_28 5 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_31 0 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_58 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_59 : FiniteTemplate HasSnaky 5 required_59 envelope_59 := by + refine finite_compose HasSnaky 4 childrenC_59 childrenD_59 finite_children_work_59 (3, 2) + required_59 envelope_59 pivot_mem_59 child_required_sub_59 child_envelope_sub_59 ?_ + intro b hb + exact common_sub_59 (mem_commonEnvelope childrenD_59 b hb) + +theorem finite_children_work_71 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_71 j) (childrenD_71 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_10 2 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_71 : FiniteTemplate HasSnaky 5 required_71 envelope_71 := by + refine finite_compose HasSnaky 4 childrenC_71 childrenD_71 finite_children_work_71 (2, 1) + required_71 envelope_71 pivot_mem_71 child_required_sub_71 child_envelope_sub_71 ?_ + intro b hb + exact common_sub_71 (mem_commonEnvelope childrenD_71 b hb) + +theorem finite_children_work_72 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_72 j) (childrenD_72 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_20 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_29 3 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_46.mono (by decide +kernel) + +theorem finite_row_works_72 : FiniteTemplate HasSnaky 5 required_72 envelope_72 := by + refine finite_compose HasSnaky 4 childrenC_72 childrenD_72 finite_children_work_72 (3, 2) + required_72 envelope_72 pivot_mem_72 child_required_sub_72 child_envelope_sub_72 ?_ + intro b hb + exact common_sub_72 (mem_commonEnvelope childrenD_72 b hb) + +theorem finite_children_work_81 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_81 j) (childrenD_81 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_42 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_81 : FiniteTemplate HasSnaky 5 required_81 envelope_81 := by + refine finite_compose HasSnaky 4 childrenC_81 childrenD_81 finite_children_work_81 (3, 2) + required_81 envelope_81 pivot_mem_81 child_required_sub_81 child_envelope_sub_81 ?_ + intro b hb + exact common_sub_81 (mem_commonEnvelope childrenD_81 b hb) + +theorem finite_children_work_84 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_84 j) (childrenD_84 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_84 : FiniteTemplate HasSnaky 5 required_84 envelope_84 := by + refine finite_compose HasSnaky 4 childrenC_84 childrenD_84 finite_children_work_84 (1, 5) + required_84 envelope_84 pivot_mem_84 child_required_sub_84 child_envelope_sub_84 ?_ + intro b hb + exact common_sub_84 (mem_commonEnvelope childrenD_84 b hb) + +theorem finite_children_work_100 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_100 j) (childrenD_100 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_10 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_100 : FiniteTemplate HasSnaky 5 required_100 envelope_100 := by + refine finite_compose HasSnaky 4 childrenC_100 childrenD_100 finite_children_work_100 (4, 1) + required_100 envelope_100 pivot_mem_100 child_required_sub_100 child_envelope_sub_100 ?_ + intro b hb + exact common_sub_100 (mem_commonEnvelope childrenD_100 b hb) + +theorem finite_children_work_104 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_104 j) (childrenD_104 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_10 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_104 : FiniteTemplate HasSnaky 5 required_104 envelope_104 := by + refine finite_compose HasSnaky 4 childrenC_104 childrenD_104 finite_children_work_104 (1, 4) + required_104 envelope_104 pivot_mem_104 child_required_sub_104 child_envelope_sub_104 ?_ + intro b hb + exact common_sub_104 (mem_commonEnvelope childrenD_104 b hb) + +theorem finite_children_work_107 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_107 j) (childrenD_107 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_18 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_107 : FiniteTemplate HasSnaky 5 required_107 envelope_107 := by + refine finite_compose HasSnaky 4 childrenC_107 childrenD_107 finite_children_work_107 (1, 2) + required_107 envelope_107 pivot_mem_107 child_required_sub_107 child_envelope_sub_107 ?_ + intro b hb + exact common_sub_107 (mem_commonEnvelope childrenD_107 b hb) + +theorem finite_children_work_111 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_111 j) (childrenD_111 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_17 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_55 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_111 : FiniteTemplate HasSnaky 5 required_111 envelope_111 := by + refine finite_compose HasSnaky 4 childrenC_111 childrenD_111 finite_children_work_111 (4, 3) + required_111 envelope_111 pivot_mem_111 child_required_sub_111 child_envelope_sub_111 ?_ + intro b hb + exact common_sub_111 (mem_commonEnvelope childrenD_111 b hb) + +theorem finite_children_work_114 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_114 j) (childrenD_114 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_114 : FiniteTemplate HasSnaky 5 required_114 envelope_114 := by + refine finite_compose HasSnaky 4 childrenC_114 childrenD_114 finite_children_work_114 (3, 4) + required_114 envelope_114 pivot_mem_114 child_required_sub_114 child_envelope_sub_114 ?_ + intro b hb + exact common_sub_114 (mem_commonEnvelope childrenD_114 b hb) + +theorem finite_children_work_122 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_122 j) (childrenD_122 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_46 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_122 : FiniteTemplate HasSnaky 5 required_122 envelope_122 := by + refine finite_compose HasSnaky 4 childrenC_122 childrenD_122 finite_children_work_122 (2, 4) + required_122 envelope_122 pivot_mem_122 child_required_sub_122 child_envelope_sub_122 ?_ + intro b hb + exact common_sub_122 (mem_commonEnvelope childrenD_122 b hb) + +theorem finite_children_work_133 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_133 j) (childrenD_133 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_132.mono (by decide +kernel) + +theorem finite_row_works_133 : FiniteTemplate HasSnaky 5 required_133 envelope_133 := by + refine finite_compose HasSnaky 4 childrenC_133 childrenD_133 finite_children_work_133 (1, 1) + required_133 envelope_133 pivot_mem_133 child_required_sub_133 child_envelope_sub_133 ?_ + intro b hb + exact common_sub_133 (mem_commonEnvelope childrenD_133 b hb) + +theorem finite_children_work_142 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_142 j) (childrenD_142 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_141 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_142 : FiniteTemplate HasSnaky 5 required_142 envelope_142 := by + refine finite_compose HasSnaky 4 childrenC_142 childrenD_142 finite_children_work_142 (1, 2) + required_142 envelope_142 pivot_mem_142 child_required_sub_142 child_envelope_sub_142 ?_ + intro b hb + exact common_sub_142 (mem_commonEnvelope childrenD_142 b hb) + +theorem finite_children_work_144 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_144 j) (childrenD_144 j) := by + intro j + fin_cases j + · exact finite_row_works_46.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_103 3 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_143 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_144 : FiniteTemplate HasSnaky 5 required_144 envelope_144 := by + refine finite_compose HasSnaky 4 childrenC_144 childrenD_144 finite_children_work_144 (3, 2) + required_144 envelope_144 pivot_mem_144 child_required_sub_144 child_envelope_sub_144 ?_ + intro b hb + exact common_sub_144 (mem_commonEnvelope childrenD_144 b hb) + +theorem finite_children_work_145 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_145 j) (childrenD_145 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_10 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_145 : FiniteTemplate HasSnaky 5 required_145 envelope_145 := by + refine finite_compose HasSnaky 4 childrenC_145 childrenD_145 finite_children_work_145 (3, 2) + required_145 envelope_145 pivot_mem_145 child_required_sub_145 child_envelope_sub_145 ?_ + intro b hb + exact common_sub_145 (mem_commonEnvelope childrenD_145 b hb) + +theorem finite_children_work_147 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_147 j) (childrenD_147 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_39 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_147 : FiniteTemplate HasSnaky 5 required_147 envelope_147 := by + refine finite_compose HasSnaky 4 childrenC_147 childrenD_147 finite_children_work_147 (3, 2) + required_147 envelope_147 pivot_mem_147 child_required_sub_147 child_envelope_sub_147 ?_ + intro b hb + exact common_sub_147 (mem_commonEnvelope childrenD_147 b hb) + +theorem finite_children_work_152 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_152 j) (childrenD_152 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_99 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_152 : FiniteTemplate HasSnaky 5 required_152 envelope_152 := by + refine finite_compose HasSnaky 4 childrenC_152 childrenD_152 finite_children_work_152 (2, 3) + required_152 envelope_152 pivot_mem_152 child_required_sub_152 child_envelope_sub_152 ?_ + intro b hb + exact common_sub_152 (mem_commonEnvelope childrenD_152 b hb) + +theorem finite_children_work_155 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_155 j) (childrenD_155 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 3 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_46 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_155 : FiniteTemplate HasSnaky 5 required_155 envelope_155 := by + refine finite_compose HasSnaky 4 childrenC_155 childrenD_155 finite_children_work_155 (4, 2) + required_155 envelope_155 pivot_mem_155 child_required_sub_155 child_envelope_sub_155 ?_ + intro b hb + exact common_sub_155 (mem_commonEnvelope childrenD_155 b hb) + +theorem finite_children_work_164 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_164 j) (childrenD_164 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_55.mono (by decide +kernel) + +theorem finite_row_works_164 : FiniteTemplate HasSnaky 5 required_164 envelope_164 := by + refine finite_compose HasSnaky 4 childrenC_164 childrenD_164 finite_children_work_164 (3, 3) + required_164 envelope_164 pivot_mem_164 child_required_sub_164 child_envelope_sub_164 ?_ + intro b hb + exact common_sub_164 (mem_commonEnvelope childrenD_164 b hb) + +theorem finite_children_work_175 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_175 j) (childrenD_175 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_32 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_60 4 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_175 : FiniteTemplate HasSnaky 5 required_175 envelope_175 := by + refine finite_compose HasSnaky 4 childrenC_175 childrenD_175 finite_children_work_175 (1, 5) + required_175 envelope_175 pivot_mem_175 child_required_sub_175 child_envelope_sub_175 ?_ + intro b hb + exact common_sub_175 (mem_commonEnvelope childrenD_175 b hb) + +theorem finite_children_work_176 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_176 j) (childrenD_176 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_60 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_176 : FiniteTemplate HasSnaky 5 required_176 envelope_176 := by + refine finite_compose HasSnaky 4 childrenC_176 childrenD_176 finite_children_work_176 (2, 2) + required_176 envelope_176 pivot_mem_176 child_required_sub_176 child_envelope_sub_176 ?_ + intro b hb + exact common_sub_176 (mem_commonEnvelope childrenD_176 b hb) + +theorem finite_children_work_179 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_179 j) (childrenD_179 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_178.mono (by decide +kernel) + +theorem finite_row_works_179 : FiniteTemplate HasSnaky 5 required_179 envelope_179 := by + refine finite_compose HasSnaky 4 childrenC_179 childrenD_179 finite_children_work_179 (1, 3) + required_179 envelope_179 pivot_mem_179 child_required_sub_179 child_envelope_sub_179 ?_ + intro b hb + exact common_sub_179 (mem_commonEnvelope childrenD_179 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height05Part02.lean b/lean/snaky/FiniteCards/Height05Part02.lean new file mode 100644 index 0000000..2aad554 --- /dev/null +++ b/lean/snaky/FiniteCards/Height05Part02.lean @@ -0,0 +1,311 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_183 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_183 j) (childrenD_183 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_178 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_183 : FiniteTemplate HasSnaky 5 required_183 envelope_183 := by + refine finite_compose HasSnaky 4 childrenC_183 childrenD_183 finite_children_work_183 (4, 2) + required_183 envelope_183 pivot_mem_183 child_required_sub_183 child_envelope_sub_183 ?_ + intro b hb + exact common_sub_183 (mem_commonEnvelope childrenD_183 b hb) + +theorem finite_children_work_186 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_186 j) (childrenD_186 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_185 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_186 : FiniteTemplate HasSnaky 5 required_186 envelope_186 := by + refine finite_compose HasSnaky 4 childrenC_186 childrenD_186 finite_children_work_186 (1, 1) + required_186 envelope_186 pivot_mem_186 child_required_sub_186 child_envelope_sub_186 ?_ + intro b hb + exact common_sub_186 (mem_commonEnvelope childrenD_186 b hb) + +theorem finite_children_work_187 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_187 j) (childrenD_187 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_7 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_185 4 (0, 7)).mono (by decide +kernel) + +theorem finite_row_works_187 : FiniteTemplate HasSnaky 5 required_187 envelope_187 := by + refine finite_compose HasSnaky 4 childrenC_187 childrenD_187 finite_children_work_187 (0, 6) + required_187 envelope_187 pivot_mem_187 child_required_sub_187 child_envelope_sub_187 ?_ + intro b hb + exact common_sub_187 (mem_commonEnvelope childrenD_187 b hb) + +theorem finite_children_work_191 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_191 j) (childrenD_191 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_89 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_191 : FiniteTemplate HasSnaky 5 required_191 envelope_191 := by + refine finite_compose HasSnaky 4 childrenC_191 childrenD_191 finite_children_work_191 (0, 1) + required_191 envelope_191 pivot_mem_191 child_required_sub_191 child_envelope_sub_191 ?_ + intro b hb + exact common_sub_191 (mem_commonEnvelope childrenD_191 b hb) + +theorem finite_children_work_197 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_197 j) (childrenD_197 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_196.mono (by decide +kernel) + +theorem finite_row_works_197 : FiniteTemplate HasSnaky 5 required_197 envelope_197 := by + refine finite_compose HasSnaky 4 childrenC_197 childrenD_197 finite_children_work_197 (4, 1) + required_197 envelope_197 pivot_mem_197 child_required_sub_197 child_envelope_sub_197 ?_ + intro b hb + exact common_sub_197 (mem_commonEnvelope childrenD_197 b hb) + +theorem finite_children_work_202 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_202 j) (childrenD_202 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_27 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_202 : FiniteTemplate HasSnaky 5 required_202 envelope_202 := by + refine finite_compose HasSnaky 4 childrenC_202 childrenD_202 finite_children_work_202 (3, 2) + required_202 envelope_202 pivot_mem_202 child_required_sub_202 child_envelope_sub_202 ?_ + intro b hb + exact common_sub_202 (mem_commonEnvelope childrenD_202 b hb) + +theorem finite_children_work_211 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_211 j) (childrenD_211 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 6 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_151 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_211 : FiniteTemplate HasSnaky 5 required_211 envelope_211 := by + refine finite_compose HasSnaky 4 childrenC_211 childrenD_211 finite_children_work_211 (3, 5) + required_211 envelope_211 pivot_mem_211 child_required_sub_211 child_envelope_sub_211 ?_ + intro b hb + exact common_sub_211 (mem_commonEnvelope childrenD_211 b hb) + +theorem finite_children_work_214 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_214 j) (childrenD_214 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_213 4 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_214 : FiniteTemplate HasSnaky 5 required_214 envelope_214 := by + refine finite_compose HasSnaky 4 childrenC_214 childrenD_214 finite_children_work_214 (3, 4) + required_214 envelope_214 pivot_mem_214 child_required_sub_214 child_envelope_sub_214 ?_ + intro b hb + exact common_sub_214 (mem_commonEnvelope childrenD_214 b hb) + +theorem finite_children_work_225 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_225 j) (childrenD_225 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 5 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_225 : FiniteTemplate HasSnaky 5 required_225 envelope_225 := by + refine finite_compose HasSnaky 4 childrenC_225 childrenD_225 finite_children_work_225 (1, 5) + required_225 envelope_225 pivot_mem_225 child_required_sub_225 child_envelope_sub_225 ?_ + intro b hb + exact common_sub_225 (mem_commonEnvelope childrenD_225 b hb) + +theorem finite_children_work_228 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_228 j) (childrenD_228 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_227 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_228 : FiniteTemplate HasSnaky 5 required_228 envelope_228 := by + refine finite_compose HasSnaky 4 childrenC_228 childrenD_228 finite_children_work_228 (3, 2) + required_228 envelope_228 pivot_mem_228 child_required_sub_228 child_envelope_sub_228 ?_ + intro b hb + exact common_sub_228 (mem_commonEnvelope childrenD_228 b hb) + +theorem finite_children_work_230 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_230 j) (childrenD_230 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 3 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_229 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_230 : FiniteTemplate HasSnaky 5 required_230 envelope_230 := by + refine finite_compose HasSnaky 4 childrenC_230 childrenD_230 finite_children_work_230 (4, 2) + required_230 envelope_230 pivot_mem_230 child_required_sub_230 child_envelope_sub_230 ?_ + intro b hb + exact common_sub_230 (mem_commonEnvelope childrenD_230 b hb) + +theorem finite_children_work_231 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_231 j) (childrenD_231 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_55 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_231 : FiniteTemplate HasSnaky 5 required_231 envelope_231 := by + refine finite_compose HasSnaky 4 childrenC_231 childrenD_231 finite_children_work_231 (4, 3) + required_231 envelope_231 pivot_mem_231 child_required_sub_231 child_envelope_sub_231 ?_ + intro b hb + exact common_sub_231 (mem_commonEnvelope childrenD_231 b hb) + +theorem finite_children_work_232 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_232 j) (childrenD_232 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 5 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_232 : FiniteTemplate HasSnaky 5 required_232 envelope_232 := by + refine finite_compose HasSnaky 4 childrenC_232 childrenD_232 finite_children_work_232 (1, 4) + required_232 envelope_232 pivot_mem_232 child_required_sub_232 child_envelope_sub_232 ?_ + intro b hb + exact common_sub_232 (mem_commonEnvelope childrenD_232 b hb) + +theorem finite_children_work_233 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_233 j) (childrenD_233 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_27 3 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_233 : FiniteTemplate HasSnaky 5 required_233 envelope_233 := by + refine finite_compose HasSnaky 4 childrenC_233 childrenD_233 finite_children_work_233 (4, 1) + required_233 envelope_233 pivot_mem_233 child_required_sub_233 child_envelope_sub_233 ?_ + intro b hb + exact common_sub_233 (mem_commonEnvelope childrenD_233 b hb) + +theorem finite_children_work_234 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_234 j) (childrenD_234 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_148 2 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_234 : FiniteTemplate HasSnaky 5 required_234 envelope_234 := by + refine finite_compose HasSnaky 4 childrenC_234 childrenD_234 finite_children_work_234 (2, 1) + required_234 envelope_234 pivot_mem_234 child_required_sub_234 child_envelope_sub_234 ?_ + intro b hb + exact common_sub_234 (mem_commonEnvelope childrenD_234 b hb) + +theorem finite_children_work_237 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_237 j) (childrenD_237 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_10.mono (by decide +kernel) + +theorem finite_row_works_237 : FiniteTemplate HasSnaky 5 required_237 envelope_237 := by + refine finite_compose HasSnaky 4 childrenC_237 childrenD_237 finite_children_work_237 (0, 1) + required_237 envelope_237 pivot_mem_237 child_required_sub_237 child_envelope_sub_237 ?_ + intro b hb + exact common_sub_237 (mem_commonEnvelope childrenD_237 b hb) + +theorem finite_children_work_241 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_241 j) (childrenD_241 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_91 2 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_241 : FiniteTemplate HasSnaky 5 required_241 envelope_241 := by + refine finite_compose HasSnaky 4 childrenC_241 childrenD_241 finite_children_work_241 (2, 1) + required_241 envelope_241 pivot_mem_241 child_required_sub_241 child_envelope_sub_241 ?_ + intro b hb + exact common_sub_241 (mem_commonEnvelope childrenD_241 b hb) + +theorem finite_children_work_243 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_243 j) (childrenD_243 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 2 (2, 1)).mono (by decide +kernel) + · exact finite_row_works_242.mono (by decide +kernel) + +theorem finite_row_works_243 : FiniteTemplate HasSnaky 5 required_243 envelope_243 := by + refine finite_compose HasSnaky 4 childrenC_243 childrenD_243 finite_children_work_243 (2, 2) + required_243 envelope_243 pivot_mem_243 child_required_sub_243 child_envelope_sub_243 ?_ + intro b hb + exact common_sub_243 (mem_commonEnvelope childrenD_243 b hb) + +theorem finite_children_work_249 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_249 j) (childrenD_249 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_17 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_35 7 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_249 : FiniteTemplate HasSnaky 5 required_249 envelope_249 := by + refine finite_compose HasSnaky 4 childrenC_249 childrenD_249 finite_children_work_249 (4, 2) + required_249 envelope_249 pivot_mem_249 child_required_sub_249 child_envelope_sub_249 ?_ + intro b hb + exact common_sub_249 (mem_commonEnvelope childrenD_249 b hb) + +theorem finite_children_work_250 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_250 j) (childrenD_250 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 5 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_195.mono (by decide +kernel) + +theorem finite_row_works_250 : FiniteTemplate HasSnaky 5 required_250 envelope_250 := by + refine finite_compose HasSnaky 4 childrenC_250 childrenD_250 finite_children_work_250 (1, 2) + required_250 envelope_250 pivot_mem_250 child_required_sub_250 child_envelope_sub_250 ?_ + intro b hb + exact common_sub_250 (mem_commonEnvelope childrenD_250 b hb) + +theorem finite_children_work_252 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_252 j) (childrenD_252 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_55 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_56 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_91 1 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_252 : FiniteTemplate HasSnaky 5 required_252 envelope_252 := by + refine finite_compose HasSnaky 4 childrenC_252 childrenD_252 finite_children_work_252 (2, 4) + required_252 envelope_252 pivot_mem_252 child_required_sub_252 child_envelope_sub_252 ?_ + intro b hb + exact common_sub_252 (mem_commonEnvelope childrenD_252 b hb) + +theorem finite_children_work_254 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_254 j) (childrenD_254 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 2 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_75.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_103 6 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_254 : FiniteTemplate HasSnaky 5 required_254 envelope_254 := by + refine finite_compose HasSnaky 4 childrenC_254 childrenD_254 finite_children_work_254 (1, 5) + required_254 envelope_254 pivot_mem_254 child_required_sub_254 child_envelope_sub_254 ?_ + intro b hb + exact common_sub_254 (mem_commonEnvelope childrenD_254 b hb) + +theorem finite_children_work_260 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_260 j) (childrenD_260 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_208 5 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_260 : FiniteTemplate HasSnaky 5 required_260 envelope_260 := by + refine finite_compose HasSnaky 4 childrenC_260 childrenD_260 finite_children_work_260 (3, 0) + required_260 envelope_260 pivot_mem_260 child_required_sub_260 child_envelope_sub_260 ?_ + intro b hb + exact common_sub_260 (mem_commonEnvelope childrenD_260 b hb) + +theorem finite_children_work_265 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_265 j) (childrenD_265 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_93 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_265 : FiniteTemplate HasSnaky 5 required_265 envelope_265 := by + refine finite_compose HasSnaky 4 childrenC_265 childrenD_265 finite_children_work_265 (1, 4) + required_265 envelope_265 pivot_mem_265 child_required_sub_265 child_envelope_sub_265 ?_ + intro b hb + exact common_sub_265 (mem_commonEnvelope childrenD_265 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height05Part03.lean b/lean/snaky/FiniteCards/Height05Part03.lean new file mode 100644 index 0000000..762b0cd --- /dev/null +++ b/lean/snaky/FiniteCards/Height05Part03.lean @@ -0,0 +1,315 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_272 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_272 j) (childrenD_272 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_39 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_272 : FiniteTemplate HasSnaky 5 required_272 envelope_272 := by + refine finite_compose HasSnaky 4 childrenC_272 childrenD_272 finite_children_work_272 (2, 1) + required_272 envelope_272 pivot_mem_272 child_required_sub_272 child_envelope_sub_272 ?_ + intro b hb + exact common_sub_272 (mem_commonEnvelope childrenD_272 b hb) + +theorem finite_children_work_273 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_273 j) (childrenD_273 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_206 0 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_273 : FiniteTemplate HasSnaky 5 required_273 envelope_273 := by + refine finite_compose HasSnaky 4 childrenC_273 childrenD_273 finite_children_work_273 (3, 3) + required_273 envelope_273 pivot_mem_273 child_required_sub_273 child_envelope_sub_273 ?_ + intro b hb + exact common_sub_273 (mem_commonEnvelope childrenD_273 b hb) + +theorem finite_children_work_274 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_274 j) (childrenD_274 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 0 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_83 5 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_274 : FiniteTemplate HasSnaky 5 required_274 envelope_274 := by + refine finite_compose HasSnaky 4 childrenC_274 childrenD_274 finite_children_work_274 (3, 2) + required_274 envelope_274 pivot_mem_274 child_required_sub_274 child_envelope_sub_274 ?_ + intro b hb + exact common_sub_274 (mem_commonEnvelope childrenD_274 b hb) + +theorem finite_children_work_278 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_278 j) (childrenD_278 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_277.mono (by decide +kernel) + +theorem finite_row_works_278 : FiniteTemplate HasSnaky 5 required_278 envelope_278 := by + refine finite_compose HasSnaky 4 childrenC_278 childrenD_278 finite_children_work_278 (4, 2) + required_278 envelope_278 pivot_mem_278 child_required_sub_278 child_envelope_sub_278 ?_ + intro b hb + exact common_sub_278 (mem_commonEnvelope childrenD_278 b hb) + +theorem finite_children_work_279 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_279 j) (childrenD_279 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_141 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_279 : FiniteTemplate HasSnaky 5 required_279 envelope_279 := by + refine finite_compose HasSnaky 4 childrenC_279 childrenD_279 finite_children_work_279 (4, 3) + required_279 envelope_279 pivot_mem_279 child_required_sub_279 child_envelope_sub_279 ?_ + intro b hb + exact common_sub_279 (mem_commonEnvelope childrenD_279 b hb) + +theorem finite_children_work_282 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_282 j) (childrenD_282 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_20 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_29 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_92.mono (by decide +kernel) + +theorem finite_row_works_282 : FiniteTemplate HasSnaky 5 required_282 envelope_282 := by + refine finite_compose HasSnaky 4 childrenC_282 childrenD_282 finite_children_work_282 (3, 2) + required_282 envelope_282 pivot_mem_282 child_required_sub_282 child_envelope_sub_282 ?_ + intro b hb + exact common_sub_282 (mem_commonEnvelope childrenD_282 b hb) + +theorem finite_children_work_293 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_293 j) (childrenD_293 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_17 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_56 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_293 : FiniteTemplate HasSnaky 5 required_293 envelope_293 := by + refine finite_compose HasSnaky 4 childrenC_293 childrenD_293 finite_children_work_293 (4, 3) + required_293 envelope_293 pivot_mem_293 child_required_sub_293 child_envelope_sub_293 ?_ + intro b hb + exact common_sub_293 (mem_commonEnvelope childrenD_293 b hb) + +theorem finite_children_work_294 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_294 j) (childrenD_294 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_48 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_165 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_294 : FiniteTemplate HasSnaky 5 required_294 envelope_294 := by + refine finite_compose HasSnaky 4 childrenC_294 childrenD_294 finite_children_work_294 (3, 3) + required_294 envelope_294 pivot_mem_294 child_required_sub_294 child_envelope_sub_294 ?_ + intro b hb + exact common_sub_294 (mem_commonEnvelope childrenD_294 b hb) + +theorem finite_children_work_296 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_296 j) (childrenD_296 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_132 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_296 : FiniteTemplate HasSnaky 5 required_296 envelope_296 := by + refine finite_compose HasSnaky 4 childrenC_296 childrenD_296 finite_children_work_296 (2, 3) + required_296 envelope_296 pivot_mem_296 child_required_sub_296 child_envelope_sub_296 ?_ + intro b hb + exact common_sub_296 (mem_commonEnvelope childrenD_296 b hb) + +theorem finite_children_work_299 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_299 j) (childrenD_299 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_165 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_264 2 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_299 : FiniteTemplate HasSnaky 5 required_299 envelope_299 := by + refine finite_compose HasSnaky 4 childrenC_299 childrenD_299 finite_children_work_299 (3, 5) + required_299 envelope_299 pivot_mem_299 child_required_sub_299 child_envelope_sub_299 ?_ + intro b hb + exact common_sub_299 (mem_commonEnvelope childrenD_299 b hb) + +theorem finite_children_work_301 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_301 j) (childrenD_301 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_23 3 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_55.mono (by decide +kernel) + +theorem finite_row_works_301 : FiniteTemplate HasSnaky 5 required_301 envelope_301 := by + refine finite_compose HasSnaky 4 childrenC_301 childrenD_301 finite_children_work_301 (3, 3) + required_301 envelope_301 pivot_mem_301 child_required_sub_301 child_envelope_sub_301 ?_ + intro b hb + exact common_sub_301 (mem_commonEnvelope childrenD_301 b hb) + +theorem finite_children_work_306 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_306 j) (childrenD_306 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_207 7 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_306 : FiniteTemplate HasSnaky 5 required_306 envelope_306 := by + refine finite_compose HasSnaky 4 childrenC_306 childrenD_306 finite_children_work_306 (4, 1) + required_306 envelope_306 pivot_mem_306 child_required_sub_306 child_envelope_sub_306 ?_ + intro b hb + exact common_sub_306 (mem_commonEnvelope childrenD_306 b hb) + +theorem finite_children_work_308 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_308 j) (childrenD_308 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_63 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_158 6 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_308 : FiniteTemplate HasSnaky 5 required_308 envelope_308 := by + refine finite_compose HasSnaky 4 childrenC_308 childrenD_308 finite_children_work_308 (1, 5) + required_308 envelope_308 pivot_mem_308 child_required_sub_308 child_envelope_sub_308 ?_ + intro b hb + exact common_sub_308 (mem_commonEnvelope childrenD_308 b hb) + +theorem finite_children_work_312 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_312 j) (childrenD_312 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_311 4 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_312 : FiniteTemplate HasSnaky 5 required_312 envelope_312 := by + refine finite_compose HasSnaky 4 childrenC_312 childrenD_312 finite_children_work_312 (2, 1) + required_312 envelope_312 pivot_mem_312 child_required_sub_312 child_envelope_sub_312 ?_ + intro b hb + exact common_sub_312 (mem_commonEnvelope childrenD_312 b hb) + +theorem finite_children_work_314_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_314_i0 j) (childrenD_314_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_20 1 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_314_i0 : FiniteTemplate HasSnaky 4 required_314_i0 envelope_314_i0 := by + refine finite_compose HasSnaky 3 childrenC_314_i0 childrenD_314_i0 finite_children_work_314_i0 (3, 0) + required_314_i0 envelope_314_i0 pivot_mem_314_i0 child_required_sub_314_i0 child_envelope_sub_314_i0 ?_ + intro b hb + exact common_sub_314_i0 (mem_commonEnvelope childrenD_314_i0 b hb) + +theorem finite_children_work_314 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_314 j) (childrenD_314 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 1 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_314_i0.mono (by decide +kernel) + +theorem finite_row_works_314 : FiniteTemplate HasSnaky 5 required_314 envelope_314 := by + refine finite_compose HasSnaky 4 childrenC_314 childrenD_314 finite_children_work_314 (4, 1) + required_314 envelope_314 pivot_mem_314 child_required_sub_314 child_envelope_sub_314 ?_ + intro b hb + exact common_sub_314 (mem_commonEnvelope childrenD_314 b hb) + +theorem finite_children_work_335 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_335 j) (childrenD_335 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_334 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_335 : FiniteTemplate HasSnaky 5 required_335 envelope_335 := by + refine finite_compose HasSnaky 4 childrenC_335 childrenD_335 finite_children_work_335 (3, 3) + required_335 envelope_335 pivot_mem_335 child_required_sub_335 child_envelope_sub_335 ?_ + intro b hb + exact common_sub_335 (mem_commonEnvelope childrenD_335 b hb) + +theorem finite_children_work_342_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_342_i0 j) (childrenD_342_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 2 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 5 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_342_i0 : FiniteTemplate HasSnaky 4 required_342_i0 envelope_342_i0 := by + refine finite_compose HasSnaky 3 childrenC_342_i0 childrenD_342_i0 finite_children_work_342_i0 (3, 4) + required_342_i0 envelope_342_i0 pivot_mem_342_i0 child_required_sub_342_i0 child_envelope_sub_342_i0 ?_ + intro b hb + exact common_sub_342_i0 (mem_commonEnvelope childrenD_342_i0 b hb) + +theorem finite_children_work_342 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_342 j) (childrenD_342 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_342_i0.mono (by decide +kernel) + +theorem finite_row_works_342 : FiniteTemplate HasSnaky 5 required_342 envelope_342 := by + refine finite_compose HasSnaky 4 childrenC_342 childrenD_342 finite_children_work_342 (3, 1) + required_342 envelope_342 pivot_mem_342 child_required_sub_342 child_envelope_sub_342 ?_ + intro b hb + exact common_sub_342 (mem_commonEnvelope childrenD_342 b hb) + +theorem finite_children_work_347_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_347_i1 j) (childrenD_347_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_94 3 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_347_i1 : FiniteTemplate HasSnaky 3 required_347_i1 envelope_347_i1 := by + refine finite_compose HasSnaky 2 childrenC_347_i1 childrenD_347_i1 finite_children_work_347_i1 (2, 3) + required_347_i1 envelope_347_i1 pivot_mem_347_i1 child_required_sub_347_i1 child_envelope_sub_347_i1 ?_ + intro b hb + exact common_sub_347_i1 (mem_commonEnvelope childrenD_347_i1 b hb) + +theorem finite_children_work_347_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_347_i0 j) (childrenD_347_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_347_i1.mono (by decide +kernel) + +theorem finite_row_works_347_i0 : FiniteTemplate HasSnaky 4 required_347_i0 envelope_347_i0 := by + refine finite_compose HasSnaky 3 childrenC_347_i0 childrenD_347_i0 finite_children_work_347_i0 (0, 3) + required_347_i0 envelope_347_i0 pivot_mem_347_i0 child_required_sub_347_i0 child_envelope_sub_347_i0 ?_ + intro b hb + exact common_sub_347_i0 (mem_commonEnvelope childrenD_347_i0 b hb) + +theorem finite_children_work_347 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_347 j) (childrenD_347 j) := by + intro j + fin_cases j + · exact finite_row_works_20.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_29 2 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_347_i0.mono (by decide +kernel) + +theorem finite_row_works_347 : FiniteTemplate HasSnaky 5 required_347 envelope_347 := by + refine finite_compose HasSnaky 4 childrenC_347 childrenD_347 finite_children_work_347 (1, 3) + required_347 envelope_347 pivot_mem_347 child_required_sub_347 child_envelope_sub_347 ?_ + intro b hb + exact common_sub_347 (mem_commonEnvelope childrenD_347 b hb) + +theorem finite_children_work_352 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_352 j) (childrenD_352 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_351 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_352 : FiniteTemplate HasSnaky 5 required_352 envelope_352 := by + refine finite_compose HasSnaky 4 childrenC_352 childrenD_352 finite_children_work_352 (4, 2) + required_352 envelope_352 pivot_mem_352 child_required_sub_352 child_envelope_sub_352 ?_ + intro b hb + exact common_sub_352 (mem_commonEnvelope childrenD_352 b hb) + +theorem finite_children_work_355 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_355 j) (childrenD_355 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_354 7 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_355 : FiniteTemplate HasSnaky 5 required_355 envelope_355 := by + refine finite_compose HasSnaky 4 childrenC_355 childrenD_355 finite_children_work_355 (3, 4) + required_355 envelope_355 pivot_mem_355 child_required_sub_355 child_envelope_sub_355 ?_ + intro b hb + exact common_sub_355 (mem_commonEnvelope childrenD_355 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height05Part04.lean b/lean/snaky/FiniteCards/Height05Part04.lean new file mode 100644 index 0000000..8f768af --- /dev/null +++ b/lean/snaky/FiniteCards/Height05Part04.lean @@ -0,0 +1,288 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part04 +import FiniteCards.Height04Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_356_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_356_i0 j) (childrenD_356_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 2 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_121 7 (4, 5)).mono (by decide +kernel) + +theorem finite_row_works_356_i0 : FiniteTemplate HasSnaky 4 required_356_i0 envelope_356_i0 := by + refine finite_compose HasSnaky 3 childrenC_356_i0 childrenD_356_i0 finite_children_work_356_i0 (2, 3) + required_356_i0 envelope_356_i0 pivot_mem_356_i0 child_required_sub_356_i0 child_envelope_sub_356_i0 ?_ + intro b hb + exact common_sub_356_i0 (mem_commonEnvelope childrenD_356_i0 b hb) + +theorem finite_children_work_356 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_356 j) (childrenD_356 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_356_i0.mono (by decide +kernel) + +theorem finite_row_works_356 : FiniteTemplate HasSnaky 5 required_356 envelope_356 := by + refine finite_compose HasSnaky 4 childrenC_356 childrenD_356 finite_children_work_356 (3, 5) + required_356 envelope_356 pivot_mem_356 child_required_sub_356 child_envelope_sub_356 ?_ + intro b hb + exact common_sub_356 (mem_commonEnvelope childrenD_356 b hb) + +theorem finite_children_work_357_i2 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_357_i2 j) (childrenD_357_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 2 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_357_i2 : FiniteTemplate HasSnaky 2 required_357_i2 envelope_357_i2 := by + refine finite_compose HasSnaky 1 childrenC_357_i2 childrenD_357_i2 finite_children_work_357_i2 (1, 4) + required_357_i2 envelope_357_i2 pivot_mem_357_i2 child_required_sub_357_i2 child_envelope_sub_357_i2 ?_ + intro b hb + exact common_sub_357_i2 (mem_commonEnvelope childrenD_357_i2 b hb) + +theorem finite_children_work_357_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_357_i1 j) (childrenD_357_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 6 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_357_i2.mono (by decide +kernel) + +theorem finite_row_works_357_i1 : FiniteTemplate HasSnaky 3 required_357_i1 envelope_357_i1 := by + refine finite_compose HasSnaky 2 childrenC_357_i1 childrenD_357_i1 finite_children_work_357_i1 (1, 3) + required_357_i1 envelope_357_i1 pivot_mem_357_i1 child_required_sub_357_i1 child_envelope_sub_357_i1 ?_ + intro b hb + exact common_sub_357_i1 (mem_commonEnvelope childrenD_357_i1 b hb) + +theorem finite_children_work_357_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_357_i0 j) (childrenD_357_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_357_i1.mono (by decide +kernel) + +theorem finite_row_works_357_i0 : FiniteTemplate HasSnaky 4 required_357_i0 envelope_357_i0 := by + refine finite_compose HasSnaky 3 childrenC_357_i0 childrenD_357_i0 finite_children_work_357_i0 (4, 3) + required_357_i0 envelope_357_i0 pivot_mem_357_i0 child_required_sub_357_i0 child_envelope_sub_357_i0 ?_ + intro b hb + exact common_sub_357_i0 (mem_commonEnvelope childrenD_357_i0 b hb) + +theorem finite_children_work_357 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_357 j) (childrenD_357 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_357_i0.mono (by decide +kernel) + +theorem finite_row_works_357 : FiniteTemplate HasSnaky 5 required_357 envelope_357 := by + refine finite_compose HasSnaky 4 childrenC_357 childrenD_357 finite_children_work_357 (2, 3) + required_357 envelope_357 pivot_mem_357 child_required_sub_357 child_envelope_sub_357 ?_ + intro b hb + exact common_sub_357 (mem_commonEnvelope childrenD_357 b hb) + +theorem finite_children_work_359_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_359_i0 j) (childrenD_359_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_359_i0 : FiniteTemplate HasSnaky 4 required_359_i0 envelope_359_i0 := by + refine finite_compose HasSnaky 3 childrenC_359_i0 childrenD_359_i0 finite_children_work_359_i0 (1, 6) + required_359_i0 envelope_359_i0 pivot_mem_359_i0 child_required_sub_359_i0 child_envelope_sub_359_i0 ?_ + intro b hb + exact common_sub_359_i0 (mem_commonEnvelope childrenD_359_i0 b hb) + +theorem finite_children_work_359 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_359 j) (childrenD_359 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_359_i0.mono (by decide +kernel) + +theorem finite_row_works_359 : FiniteTemplate HasSnaky 5 required_359 envelope_359 := by + refine finite_compose HasSnaky 4 childrenC_359 childrenD_359 finite_children_work_359 (1, 4) + required_359 envelope_359 pivot_mem_359 child_required_sub_359 child_envelope_sub_359 ?_ + intro b hb + exact common_sub_359 (mem_commonEnvelope childrenD_359 b hb) + +theorem finite_children_work_362_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_362_i0 j) (childrenD_362_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 6 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 6 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_362_i0 : FiniteTemplate HasSnaky 4 required_362_i0 envelope_362_i0 := by + refine finite_compose HasSnaky 3 childrenC_362_i0 childrenD_362_i0 finite_children_work_362_i0 (1, 4) + required_362_i0 envelope_362_i0 pivot_mem_362_i0 child_required_sub_362_i0 child_envelope_sub_362_i0 ?_ + intro b hb + exact common_sub_362_i0 (mem_commonEnvelope childrenD_362_i0 b hb) + +theorem finite_children_work_362 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_362 j) (childrenD_362 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_362_i0.mono (by decide +kernel) + +theorem finite_row_works_362 : FiniteTemplate HasSnaky 5 required_362 envelope_362 := by + refine finite_compose HasSnaky 4 childrenC_362 childrenD_362 finite_children_work_362 (1, 3) + required_362 envelope_362 pivot_mem_362 child_required_sub_362 child_envelope_sub_362 ?_ + intro b hb + exact common_sub_362 (mem_commonEnvelope childrenD_362 b hb) + +theorem finite_children_work_366 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_366 j) (childrenD_366 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_365 2 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_366 : FiniteTemplate HasSnaky 5 required_366 envelope_366 := by + refine finite_compose HasSnaky 4 childrenC_366 childrenD_366 finite_children_work_366 (1, 1) + required_366 envelope_366 pivot_mem_366 child_required_sub_366 child_envelope_sub_366 ?_ + intro b hb + exact common_sub_366 (mem_commonEnvelope childrenD_366 b hb) + +theorem finite_children_work_370_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_370_i0 j) (childrenD_370_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_16 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_210.mono (by decide +kernel) + +theorem finite_row_works_370_i0 : FiniteTemplate HasSnaky 4 required_370_i0 envelope_370_i0 := by + refine finite_compose HasSnaky 3 childrenC_370_i0 childrenD_370_i0 finite_children_work_370_i0 (1, 2) + required_370_i0 envelope_370_i0 pivot_mem_370_i0 child_required_sub_370_i0 child_envelope_sub_370_i0 ?_ + intro b hb + exact common_sub_370_i0 (mem_commonEnvelope childrenD_370_i0 b hb) + +theorem finite_children_work_370 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_370 j) (childrenD_370 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_370_i0.mono (by decide +kernel) + +theorem finite_row_works_370 : FiniteTemplate HasSnaky 5 required_370 envelope_370 := by + refine finite_compose HasSnaky 4 childrenC_370 childrenD_370 finite_children_work_370 (4, 1) + required_370 envelope_370 pivot_mem_370 child_required_sub_370 child_envelope_sub_370 ?_ + intro b hb + exact common_sub_370 (mem_commonEnvelope childrenD_370 b hb) + +theorem finite_children_work_377 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_377 j) (childrenD_377 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_9.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_376 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_377 : FiniteTemplate HasSnaky 5 required_377 envelope_377 := by + refine finite_compose HasSnaky 4 childrenC_377 childrenD_377 finite_children_work_377 (1, 4) + required_377 envelope_377 pivot_mem_377 child_required_sub_377 child_envelope_sub_377 ?_ + intro b hb + exact common_sub_377 (mem_commonEnvelope childrenD_377 b hb) + +theorem finite_children_work_382 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_382 j) (childrenD_382 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 2 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_381 5 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_382 : FiniteTemplate HasSnaky 5 required_382 envelope_382 := by + refine finite_compose HasSnaky 4 childrenC_382 childrenD_382 finite_children_work_382 (1, 4) + required_382 envelope_382 pivot_mem_382 child_required_sub_382 child_envelope_sub_382 ?_ + intro b hb + exact common_sub_382 (mem_commonEnvelope childrenD_382 b hb) + +theorem finite_children_work_383_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_383_i0 j) (childrenD_383_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_219 4 (2, 5)).mono (by decide +kernel) + +theorem finite_row_works_383_i0 : FiniteTemplate HasSnaky 4 required_383_i0 envelope_383_i0 := by + refine finite_compose HasSnaky 3 childrenC_383_i0 childrenD_383_i0 finite_children_work_383_i0 (3, 3) + required_383_i0 envelope_383_i0 pivot_mem_383_i0 child_required_sub_383_i0 child_envelope_sub_383_i0 ?_ + intro b hb + exact common_sub_383_i0 (mem_commonEnvelope childrenD_383_i0 b hb) + +theorem finite_children_work_383 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_383 j) (childrenD_383 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_383_i0.mono (by decide +kernel) + +theorem finite_row_works_383 : FiniteTemplate HasSnaky 5 required_383 envelope_383 := by + refine finite_compose HasSnaky 4 childrenC_383 childrenD_383 finite_children_work_383 (3, 1) + required_383 envelope_383 pivot_mem_383 child_required_sub_383 child_envelope_sub_383 ?_ + intro b hb + exact common_sub_383 (mem_commonEnvelope childrenD_383 b hb) + +theorem finite_children_work_386_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_386_i1 j) (childrenD_386_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_386_i1 : FiniteTemplate HasSnaky 3 required_386_i1 envelope_386_i1 := by + refine finite_compose HasSnaky 2 childrenC_386_i1 childrenD_386_i1 finite_children_work_386_i1 (3, 4) + required_386_i1 envelope_386_i1 pivot_mem_386_i1 child_required_sub_386_i1 child_envelope_sub_386_i1 ?_ + intro b hb + exact common_sub_386_i1 (mem_commonEnvelope childrenD_386_i1 b hb) + +theorem finite_children_work_386_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_386_i0 j) (childrenD_386_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_386_i1.mono (by decide +kernel) + +theorem finite_row_works_386_i0 : FiniteTemplate HasSnaky 4 required_386_i0 envelope_386_i0 := by + refine finite_compose HasSnaky 3 childrenC_386_i0 childrenD_386_i0 finite_children_work_386_i0 (3, 3) + required_386_i0 envelope_386_i0 pivot_mem_386_i0 child_required_sub_386_i0 child_envelope_sub_386_i0 ?_ + intro b hb + exact common_sub_386_i0 (mem_commonEnvelope childrenD_386_i0 b hb) + +theorem finite_children_work_386 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_386 j) (childrenD_386 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_386_i0.mono (by decide +kernel) + +theorem finite_row_works_386 : FiniteTemplate HasSnaky 5 required_386 envelope_386 := by + refine finite_compose HasSnaky 4 childrenC_386 childrenD_386 finite_children_work_386 (3, 1) + required_386 envelope_386 pivot_mem_386 child_required_sub_386 child_envelope_sub_386 ?_ + intro b hb + exact common_sub_386 (mem_commonEnvelope childrenD_386 b hb) + +theorem finite_children_work_389_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_389_i0 j) (childrenD_389_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_23 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_389_i0 : FiniteTemplate HasSnaky 3 required_389_i0 envelope_389_i0 := by + refine finite_compose HasSnaky 2 childrenC_389_i0 childrenD_389_i0 finite_children_work_389_i0 (1, 3) + required_389_i0 envelope_389_i0 pivot_mem_389_i0 child_required_sub_389_i0 child_envelope_sub_389_i0 ?_ + intro b hb + exact common_sub_389_i0 (mem_commonEnvelope childrenD_389_i0 b hb) + +theorem finite_children_work_389 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_389 j) (childrenD_389 j) := by + intro j + fin_cases j + · exact finite_row_works_6.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_21 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_27 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_389_i0.mono (by decide +kernel) + +theorem finite_row_works_389 : FiniteTemplate HasSnaky 5 required_389 envelope_389 := by + refine finite_compose HasSnaky 4 childrenC_389 childrenD_389 finite_children_work_389 (0, 4) + required_389 envelope_389 pivot_mem_389 child_required_sub_389 child_envelope_sub_389 ?_ + intro b hb + exact common_sub_389 (mem_commonEnvelope childrenD_389 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height05Part05.lean b/lean/snaky/FiniteCards/Height05Part05.lean new file mode 100644 index 0000000..ad1735c --- /dev/null +++ b/lean/snaky/FiniteCards/Height05Part05.lean @@ -0,0 +1,294 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_391_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_391_i1 j) (childrenD_391_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_36 4 (2, 4)).mono (by decide +kernel) + +theorem finite_row_works_391_i1 : FiniteTemplate HasSnaky 3 required_391_i1 envelope_391_i1 := by + refine finite_compose HasSnaky 2 childrenC_391_i1 childrenD_391_i1 finite_children_work_391_i1 (3, 1) + required_391_i1 envelope_391_i1 pivot_mem_391_i1 child_required_sub_391_i1 child_envelope_sub_391_i1 ?_ + intro b hb + exact common_sub_391_i1 (mem_commonEnvelope childrenD_391_i1 b hb) + +theorem finite_children_work_391_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_391_i0 j) (childrenD_391_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_391_i1.mono (by decide +kernel) + +theorem finite_row_works_391_i0 : FiniteTemplate HasSnaky 4 required_391_i0 envelope_391_i0 := by + refine finite_compose HasSnaky 3 childrenC_391_i0 childrenD_391_i0 finite_children_work_391_i0 (2, 1) + required_391_i0 envelope_391_i0 pivot_mem_391_i0 child_required_sub_391_i0 child_envelope_sub_391_i0 ?_ + intro b hb + exact common_sub_391_i0 (mem_commonEnvelope childrenD_391_i0 b hb) + +theorem finite_children_work_391 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_391 j) (childrenD_391 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_391_i0.mono (by decide +kernel) + +theorem finite_row_works_391 : FiniteTemplate HasSnaky 5 required_391 envelope_391 := by + refine finite_compose HasSnaky 4 childrenC_391 childrenD_391 finite_children_work_391 (2, 4) + required_391 envelope_391 pivot_mem_391 child_required_sub_391 child_envelope_sub_391 ?_ + intro b hb + exact common_sub_391 (mem_commonEnvelope childrenD_391 b hb) + +theorem finite_children_work_413_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_413_i0 j) (childrenD_413_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_45 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_413_i0 : FiniteTemplate HasSnaky 4 required_413_i0 envelope_413_i0 := by + refine finite_compose HasSnaky 3 childrenC_413_i0 childrenD_413_i0 finite_children_work_413_i0 (2, 3) + required_413_i0 envelope_413_i0 pivot_mem_413_i0 child_required_sub_413_i0 child_envelope_sub_413_i0 ?_ + intro b hb + exact common_sub_413_i0 (mem_commonEnvelope childrenD_413_i0 b hb) + +theorem finite_children_work_413 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_413 j) (childrenD_413 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_413_i0.mono (by decide +kernel) + +theorem finite_row_works_413 : FiniteTemplate HasSnaky 5 required_413 envelope_413 := by + refine finite_compose HasSnaky 4 childrenC_413 childrenD_413 finite_children_work_413 (2, 4) + required_413 envelope_413 pivot_mem_413 child_required_sub_413 child_envelope_sub_413 ?_ + intro b hb + exact common_sub_413 (mem_commonEnvelope childrenD_413 b hb) + +theorem finite_children_work_416_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_416_i0 j) (childrenD_416_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_239 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_416_i0 : FiniteTemplate HasSnaky 4 required_416_i0 envelope_416_i0 := by + refine finite_compose HasSnaky 3 childrenC_416_i0 childrenD_416_i0 finite_children_work_416_i0 (3, 1) + required_416_i0 envelope_416_i0 pivot_mem_416_i0 child_required_sub_416_i0 child_envelope_sub_416_i0 ?_ + intro b hb + exact common_sub_416_i0 (mem_commonEnvelope childrenD_416_i0 b hb) + +theorem finite_children_work_416 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_416 j) (childrenD_416 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_416_i0.mono (by decide +kernel) + +theorem finite_row_works_416 : FiniteTemplate HasSnaky 5 required_416 envelope_416 := by + refine finite_compose HasSnaky 4 childrenC_416 childrenD_416 finite_children_work_416 (3, 3) + required_416 envelope_416 pivot_mem_416 child_required_sub_416 child_envelope_sub_416 ?_ + intro b hb + exact common_sub_416 (mem_commonEnvelope childrenD_416 b hb) + +theorem finite_children_work_425_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_425_i0 j) (childrenD_425_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 0 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_425_i0 : FiniteTemplate HasSnaky 4 required_425_i0 envelope_425_i0 := by + refine finite_compose HasSnaky 3 childrenC_425_i0 childrenD_425_i0 finite_children_work_425_i0 (3, 2) + required_425_i0 envelope_425_i0 pivot_mem_425_i0 child_required_sub_425_i0 child_envelope_sub_425_i0 ?_ + intro b hb + exact common_sub_425_i0 (mem_commonEnvelope childrenD_425_i0 b hb) + +theorem finite_children_work_425 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_425 j) (childrenD_425 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 6 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_425_i0.mono (by decide +kernel) + +theorem finite_row_works_425 : FiniteTemplate HasSnaky 5 required_425 envelope_425 := by + refine finite_compose HasSnaky 4 childrenC_425 childrenD_425 finite_children_work_425 (4, 3) + required_425 envelope_425 pivot_mem_425 child_required_sub_425 child_envelope_sub_425 ?_ + intro b hb + exact common_sub_425 (mem_commonEnvelope childrenD_425 b hb) + +theorem finite_children_work_426_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_426_i0 j) (childrenD_426_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_221 2 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_426_i0 : FiniteTemplate HasSnaky 4 required_426_i0 envelope_426_i0 := by + refine finite_compose HasSnaky 3 childrenC_426_i0 childrenD_426_i0 finite_children_work_426_i0 (3, 3) + required_426_i0 envelope_426_i0 pivot_mem_426_i0 child_required_sub_426_i0 child_envelope_sub_426_i0 ?_ + intro b hb + exact common_sub_426_i0 (mem_commonEnvelope childrenD_426_i0 b hb) + +theorem finite_children_work_426 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_426 j) (childrenD_426 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 2 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_426_i0.mono (by decide +kernel) + +theorem finite_row_works_426 : FiniteTemplate HasSnaky 5 required_426 envelope_426 := by + refine finite_compose HasSnaky 4 childrenC_426 childrenD_426 finite_children_work_426 (2, 4) + required_426 envelope_426 pivot_mem_426 child_required_sub_426 child_envelope_sub_426 ?_ + intro b hb + exact common_sub_426 (mem_commonEnvelope childrenD_426 b hb) + +theorem finite_children_work_433 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_433 j) (childrenD_433 j) := by + intro j + fin_cases j + · exact finite_row_works_86.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_432 5 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_433 : FiniteTemplate HasSnaky 5 required_433 envelope_433 := by + refine finite_compose HasSnaky 4 childrenC_433 childrenD_433 finite_children_work_433 (3, 4) + required_433 envelope_433 pivot_mem_433 child_required_sub_433 child_envelope_sub_433 ?_ + intro b hb + exact common_sub_433 (mem_commonEnvelope childrenD_433 b hb) + +theorem finite_children_work_445_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_445_i0 j) (childrenD_445_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_20 0 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_29 2 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_221 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_445_i0 : FiniteTemplate HasSnaky 4 required_445_i0 envelope_445_i0 := by + refine finite_compose HasSnaky 3 childrenC_445_i0 childrenD_445_i0 finite_children_work_445_i0 (3, 3) + required_445_i0 envelope_445_i0 pivot_mem_445_i0 child_required_sub_445_i0 child_envelope_sub_445_i0 ?_ + intro b hb + exact common_sub_445_i0 (mem_commonEnvelope childrenD_445_i0 b hb) + +theorem finite_children_work_445 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_445 j) (childrenD_445 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_445_i0.mono (by decide +kernel) + +theorem finite_row_works_445 : FiniteTemplate HasSnaky 5 required_445 envelope_445 := by + refine finite_compose HasSnaky 4 childrenC_445 childrenD_445 finite_children_work_445 (3, 0) + required_445 envelope_445 pivot_mem_445 child_required_sub_445 child_envelope_sub_445 ?_ + intro b hb + exact common_sub_445 (mem_commonEnvelope childrenD_445 b hb) + +theorem finite_children_work_451_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_451_i0 j) (childrenD_451_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_402.mono (by decide +kernel) + +theorem finite_row_works_451_i0 : FiniteTemplate HasSnaky 4 required_451_i0 envelope_451_i0 := by + refine finite_compose HasSnaky 3 childrenC_451_i0 childrenD_451_i0 finite_children_work_451_i0 (2, 3) + required_451_i0 envelope_451_i0 pivot_mem_451_i0 child_required_sub_451_i0 child_envelope_sub_451_i0 ?_ + intro b hb + exact common_sub_451_i0 (mem_commonEnvelope childrenD_451_i0 b hb) + +theorem finite_children_work_451 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_451 j) (childrenD_451 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 2 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_451_i0.mono (by decide +kernel) + +theorem finite_row_works_451 : FiniteTemplate HasSnaky 5 required_451 envelope_451 := by + refine finite_compose HasSnaky 4 childrenC_451 childrenD_451 finite_children_work_451 (1, 4) + required_451 envelope_451 pivot_mem_451 child_required_sub_451 child_envelope_sub_451 ?_ + intro b hb + exact common_sub_451 (mem_commonEnvelope childrenD_451 b hb) + +theorem finite_children_work_464_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_464_i1 j) (childrenD_464_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 5 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_464_i1 : FiniteTemplate HasSnaky 3 required_464_i1 envelope_464_i1 := by + refine finite_compose HasSnaky 2 childrenC_464_i1 childrenD_464_i1 finite_children_work_464_i1 (1, 1) + required_464_i1 envelope_464_i1 pivot_mem_464_i1 child_required_sub_464_i1 child_envelope_sub_464_i1 ?_ + intro b hb + exact common_sub_464_i1 (mem_commonEnvelope childrenD_464_i1 b hb) + +theorem finite_children_work_464_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_464_i0 j) (childrenD_464_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_464_i1.mono (by decide +kernel) + +theorem finite_row_works_464_i0 : FiniteTemplate HasSnaky 4 required_464_i0 envelope_464_i0 := by + refine finite_compose HasSnaky 3 childrenC_464_i0 childrenD_464_i0 finite_children_work_464_i0 (2, 2) + required_464_i0 envelope_464_i0 pivot_mem_464_i0 child_required_sub_464_i0 child_envelope_sub_464_i0 ?_ + intro b hb + exact common_sub_464_i0 (mem_commonEnvelope childrenD_464_i0 b hb) + +theorem finite_children_work_464_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_464_i2 j) (childrenD_464_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_29 2 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_38 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_464_i2 : FiniteTemplate HasSnaky 4 required_464_i2 envelope_464_i2 := by + refine finite_compose HasSnaky 3 childrenC_464_i2 childrenD_464_i2 finite_children_work_464_i2 (1, 5) + required_464_i2 envelope_464_i2 pivot_mem_464_i2 child_required_sub_464_i2 child_envelope_sub_464_i2 ?_ + intro b hb + exact common_sub_464_i2 (mem_commonEnvelope childrenD_464_i2 b hb) + +theorem finite_children_work_464 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_464 j) (childrenD_464 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 2 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_464_i0.mono (by decide +kernel) + · exact finite_row_works_464_i2.mono (by decide +kernel) + +theorem finite_row_works_464 : FiniteTemplate HasSnaky 5 required_464 envelope_464 := by + refine finite_compose HasSnaky 4 childrenC_464 childrenD_464 finite_children_work_464 (1, 2) + required_464 envelope_464 pivot_mem_464 child_required_sub_464 child_envelope_sub_464 ?_ + intro b hb + exact common_sub_464 (mem_commonEnvelope childrenD_464 b hb) + +theorem finite_children_work_492_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_492_i1 j) (childrenD_492_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_32 5 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_492_i1 : FiniteTemplate HasSnaky 3 required_492_i1 envelope_492_i1 := by + refine finite_compose HasSnaky 2 childrenC_492_i1 childrenD_492_i1 finite_children_work_492_i1 (2, 3) + required_492_i1 envelope_492_i1 pivot_mem_492_i1 child_required_sub_492_i1 child_envelope_sub_492_i1 ?_ + intro b hb + exact common_sub_492_i1 (mem_commonEnvelope childrenD_492_i1 b hb) + +theorem finite_children_work_492_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_492_i0 j) (childrenD_492_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_492_i1.mono (by decide +kernel) + +theorem finite_row_works_492_i0 : FiniteTemplate HasSnaky 4 required_492_i0 envelope_492_i0 := by + refine finite_compose HasSnaky 3 childrenC_492_i0 childrenD_492_i0 finite_children_work_492_i0 (1, 3) + required_492_i0 envelope_492_i0 pivot_mem_492_i0 child_required_sub_492_i0 child_envelope_sub_492_i0 ?_ + intro b hb + exact common_sub_492_i0 (mem_commonEnvelope childrenD_492_i0 b hb) + +theorem finite_children_work_492 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_492 j) (childrenD_492 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_78 7 (4, 4)).mono (by decide +kernel) + · exact finite_row_works_492_i0.mono (by decide +kernel) + +theorem finite_row_works_492 : FiniteTemplate HasSnaky 5 required_492 envelope_492 := by + refine finite_compose HasSnaky 4 childrenC_492 childrenD_492 finite_children_work_492 (1, 2) + required_492 envelope_492 pivot_mem_492 child_required_sub_492 child_envelope_sub_492 ?_ + intro b hb + exact common_sub_492 (mem_commonEnvelope childrenD_492 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height05Part06.lean b/lean/snaky/FiniteCards/Height05Part06.lean new file mode 100644 index 0000000..dce132b --- /dev/null +++ b/lean/snaky/FiniteCards/Height05Part06.lean @@ -0,0 +1,307 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height04Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_495_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_495_i0 j) (childrenD_495_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_221 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_495_i0 : FiniteTemplate HasSnaky 4 required_495_i0 envelope_495_i0 := by + refine finite_compose HasSnaky 3 childrenC_495_i0 childrenD_495_i0 finite_children_work_495_i0 (2, 2) + required_495_i0 envelope_495_i0 pivot_mem_495_i0 child_required_sub_495_i0 child_envelope_sub_495_i0 ?_ + intro b hb + exact common_sub_495_i0 (mem_commonEnvelope childrenD_495_i0 b hb) + +theorem finite_children_work_495 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_495 j) (childrenD_495 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (2, 6)).mono (by decide +kernel) + · exact finite_row_works_495_i0.mono (by decide +kernel) + +theorem finite_row_works_495 : FiniteTemplate HasSnaky 5 required_495 envelope_495 := by + refine finite_compose HasSnaky 4 childrenC_495 childrenD_495 finite_children_work_495 (2, 4) + required_495 envelope_495 pivot_mem_495 child_required_sub_495 child_envelope_sub_495 ?_ + intro b hb + exact common_sub_495 (mem_commonEnvelope childrenD_495 b hb) + +theorem finite_children_work_497 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_497 j) (childrenD_497 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_496.mono (by decide +kernel) + +theorem finite_row_works_497 : FiniteTemplate HasSnaky 5 required_497 envelope_497 := by + refine finite_compose HasSnaky 4 childrenC_497 childrenD_497 finite_children_work_497 (0, 3) + required_497 envelope_497 pivot_mem_497 child_required_sub_497 child_envelope_sub_497 ?_ + intro b hb + exact common_sub_497 (mem_commonEnvelope childrenD_497 b hb) + +theorem finite_children_work_501 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_501 j) (childrenD_501 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 2 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_500.mono (by decide +kernel) + +theorem finite_row_works_501 : FiniteTemplate HasSnaky 5 required_501 envelope_501 := by + refine finite_compose HasSnaky 4 childrenC_501 childrenD_501 finite_children_work_501 (1, 3) + required_501 envelope_501 pivot_mem_501 child_required_sub_501 child_envelope_sub_501 ?_ + intro b hb + exact common_sub_501 (mem_commonEnvelope childrenD_501 b hb) + +theorem finite_children_work_502_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_502_i0 j) (childrenD_502_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 4 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_502_i0 : FiniteTemplate HasSnaky 4 required_502_i0 envelope_502_i0 := by + refine finite_compose HasSnaky 3 childrenC_502_i0 childrenD_502_i0 finite_children_work_502_i0 (2, 4) + required_502_i0 envelope_502_i0 pivot_mem_502_i0 child_required_sub_502_i0 child_envelope_sub_502_i0 ?_ + intro b hb + exact common_sub_502_i0 (mem_commonEnvelope childrenD_502_i0 b hb) + +theorem finite_children_work_502 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_502 j) (childrenD_502 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_69 4 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_502_i0.mono (by decide +kernel) + +theorem finite_row_works_502 : FiniteTemplate HasSnaky 5 required_502 envelope_502 := by + refine finite_compose HasSnaky 4 childrenC_502 childrenD_502 finite_children_work_502 (4, 3) + required_502 envelope_502 pivot_mem_502 child_required_sub_502 child_envelope_sub_502 ?_ + intro b hb + exact common_sub_502 (mem_commonEnvelope childrenD_502 b hb) + +theorem finite_children_work_505_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_505_i0 j) (childrenD_505_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_350 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_505_i0 : FiniteTemplate HasSnaky 4 required_505_i0 envelope_505_i0 := by + refine finite_compose HasSnaky 3 childrenC_505_i0 childrenD_505_i0 finite_children_work_505_i0 (4, 2) + required_505_i0 envelope_505_i0 pivot_mem_505_i0 child_required_sub_505_i0 child_envelope_sub_505_i0 ?_ + intro b hb + exact common_sub_505_i0 (mem_commonEnvelope childrenD_505_i0 b hb) + +theorem finite_children_work_505_i2 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_505_i2 j) (childrenD_505_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 0 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_505_i2 : FiniteTemplate HasSnaky 3 required_505_i2 envelope_505_i2 := by + refine finite_compose HasSnaky 2 childrenC_505_i2 childrenD_505_i2 finite_children_work_505_i2 (4, 3) + required_505_i2 envelope_505_i2 pivot_mem_505_i2 child_required_sub_505_i2 child_envelope_sub_505_i2 ?_ + intro b hb + exact common_sub_505_i2 (mem_commonEnvelope childrenD_505_i2 b hb) + +theorem finite_children_work_505_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_505_i1 j) (childrenD_505_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_505_i2.mono (by decide +kernel) + +theorem finite_row_works_505_i1 : FiniteTemplate HasSnaky 4 required_505_i1 envelope_505_i1 := by + refine finite_compose HasSnaky 3 childrenC_505_i1 childrenD_505_i1 finite_children_work_505_i1 (4, 2) + required_505_i1 envelope_505_i1 pivot_mem_505_i1 child_required_sub_505_i1 child_envelope_sub_505_i1 ?_ + intro b hb + exact common_sub_505_i1 (mem_commonEnvelope childrenD_505_i1 b hb) + +theorem finite_children_work_505 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_505 j) (childrenD_505 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_505_i0.mono (by decide +kernel) + · exact finite_row_works_505_i1.mono (by decide +kernel) + +theorem finite_row_works_505 : FiniteTemplate HasSnaky 5 required_505 envelope_505 := by + refine finite_compose HasSnaky 4 childrenC_505 childrenD_505 finite_children_work_505 (4, 1) + required_505 envelope_505 pivot_mem_505 child_required_sub_505 child_envelope_sub_505 ?_ + intro b hb + exact common_sub_505 (mem_commonEnvelope childrenD_505 b hb) + +theorem finite_children_work_506_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_506_i0 j) (childrenD_506_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_32 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_506_i0 : FiniteTemplate HasSnaky 4 required_506_i0 envelope_506_i0 := by + refine finite_compose HasSnaky 3 childrenC_506_i0 childrenD_506_i0 finite_children_work_506_i0 (1, 2) + required_506_i0 envelope_506_i0 pivot_mem_506_i0 child_required_sub_506_i0 child_envelope_sub_506_i0 ?_ + intro b hb + exact common_sub_506_i0 (mem_commonEnvelope childrenD_506_i0 b hb) + +theorem finite_children_work_506 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_506 j) (childrenD_506 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_67 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_506_i0.mono (by decide +kernel) + +theorem finite_row_works_506 : FiniteTemplate HasSnaky 5 required_506 envelope_506 := by + refine finite_compose HasSnaky 4 childrenC_506 childrenD_506 finite_children_work_506 (1, 5) + required_506 envelope_506 pivot_mem_506 child_required_sub_506 child_envelope_sub_506 ?_ + intro b hb + exact common_sub_506 (mem_commonEnvelope childrenD_506 b hb) + +theorem finite_children_work_515_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_515_i0 j) (childrenD_515_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_78.mono (by decide +kernel) + +theorem finite_row_works_515_i0 : FiniteTemplate HasSnaky 4 required_515_i0 envelope_515_i0 := by + refine finite_compose HasSnaky 3 childrenC_515_i0 childrenD_515_i0 finite_children_work_515_i0 (3, 1) + required_515_i0 envelope_515_i0 pivot_mem_515_i0 child_required_sub_515_i0 child_envelope_sub_515_i0 ?_ + intro b hb + exact common_sub_515_i0 (mem_commonEnvelope childrenD_515_i0 b hb) + +theorem finite_children_work_515 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_515 j) (childrenD_515 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 7 (2, 4)).mono (by decide +kernel) + · exact finite_row_works_515_i0.mono (by decide +kernel) + +theorem finite_row_works_515 : FiniteTemplate HasSnaky 5 required_515 envelope_515 := by + refine finite_compose HasSnaky 4 childrenC_515 childrenD_515 finite_children_work_515 (2, 1) + required_515 envelope_515 pivot_mem_515 child_required_sub_515 child_envelope_sub_515 ?_ + intro b hb + exact common_sub_515 (mem_commonEnvelope childrenD_515 b hb) + +theorem finite_children_work_592_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_592_i0 j) (childrenD_592_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_158 4 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_592_i0 : FiniteTemplate HasSnaky 4 required_592_i0 envelope_592_i0 := by + refine finite_compose HasSnaky 3 childrenC_592_i0 childrenD_592_i0 finite_children_work_592_i0 (1, 5) + required_592_i0 envelope_592_i0 pivot_mem_592_i0 child_required_sub_592_i0 child_envelope_sub_592_i0 ?_ + intro b hb + exact common_sub_592_i0 (mem_commonEnvelope childrenD_592_i0 b hb) + +theorem finite_children_work_592 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_592 j) (childrenD_592 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 4 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_36 6 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_150.mono (by decide +kernel) + · exact finite_row_works_592_i0.mono (by decide +kernel) + +theorem finite_row_works_592 : FiniteTemplate HasSnaky 5 required_592 envelope_592 := by + refine finite_compose HasSnaky 4 childrenC_592 childrenD_592 finite_children_work_592 (1, 4) + required_592 envelope_592 pivot_mem_592 child_required_sub_592 child_envelope_sub_592 ?_ + intro b hb + exact common_sub_592 (mem_commonEnvelope childrenD_592 b hb) + +theorem finite_children_work_612_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_612_i1 j) (childrenD_612_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 2 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_612_i1 : FiniteTemplate HasSnaky 3 required_612_i1 envelope_612_i1 := by + refine finite_compose HasSnaky 2 childrenC_612_i1 childrenD_612_i1 finite_children_work_612_i1 (1, 2) + required_612_i1 envelope_612_i1 pivot_mem_612_i1 child_required_sub_612_i1 child_envelope_sub_612_i1 ?_ + intro b hb + exact common_sub_612_i1 (mem_commonEnvelope childrenD_612_i1 b hb) + +theorem finite_children_work_612_i2 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_612_i2 j) (childrenD_612_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_3 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_612_i2 : FiniteTemplate HasSnaky 2 required_612_i2 envelope_612_i2 := by + refine finite_compose HasSnaky 1 childrenC_612_i2 childrenD_612_i2 finite_children_work_612_i2 (0, 2) + required_612_i2 envelope_612_i2 pivot_mem_612_i2 child_required_sub_612_i2 child_envelope_sub_612_i2 ?_ + intro b hb + exact common_sub_612_i2 (mem_commonEnvelope childrenD_612_i2 b hb) + +theorem finite_children_work_612_i3 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_612_i3 j) (childrenD_612_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_612_i3 : FiniteTemplate HasSnaky 3 required_612_i3 envelope_612_i3 := by + refine finite_compose HasSnaky 2 childrenC_612_i3 childrenD_612_i3 finite_children_work_612_i3 (1, 2) + required_612_i3 envelope_612_i3 pivot_mem_612_i3 child_required_sub_612_i3 child_envelope_sub_612_i3 ?_ + intro b hb + exact common_sub_612_i3 (mem_commonEnvelope childrenD_612_i3 b hb) + +theorem finite_children_work_612_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_612_i0 j) (childrenD_612_i0 j) := by + intro j + fin_cases j + · exact finite_row_works_612_i1.mono (by decide +kernel) + · exact finite_row_works_612_i2.mono (by decide +kernel) + · exact finite_row_works_612_i3.mono (by decide +kernel) + +theorem finite_row_works_612_i0 : FiniteTemplate HasSnaky 4 required_612_i0 envelope_612_i0 := by + refine finite_compose HasSnaky 3 childrenC_612_i0 childrenD_612_i0 finite_children_work_612_i0 (1, 5) + required_612_i0 envelope_612_i0 pivot_mem_612_i0 child_required_sub_612_i0 child_envelope_sub_612_i0 ?_ + intro b hb + exact common_sub_612_i0 (mem_commonEnvelope childrenD_612_i0 b hb) + +theorem finite_children_work_612 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_612 j) (childrenD_612 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_36 6 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_50.mono (by decide +kernel) + · exact finite_row_works_54.mono (by decide +kernel) + · exact finite_row_works_612_i0.mono (by decide +kernel) + +theorem finite_row_works_612 : FiniteTemplate HasSnaky 5 required_612 envelope_612 := by + refine finite_compose HasSnaky 4 childrenC_612 childrenD_612 finite_children_work_612 (1, 4) + required_612 envelope_612 pivot_mem_612 child_required_sub_612 child_envelope_sub_612 ?_ + intro b hb + exact common_sub_612 (mem_commonEnvelope childrenD_612 b hb) + +theorem finite_children_work_672_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_672_i0 j) (childrenD_672_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_22 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_672_i0 : FiniteTemplate HasSnaky 3 required_672_i0 envelope_672_i0 := by + refine finite_compose HasSnaky 2 childrenC_672_i0 childrenD_672_i0 finite_children_work_672_i0 (2, 1) + required_672_i0 envelope_672_i0 pivot_mem_672_i0 child_required_sub_672_i0 child_envelope_sub_672_i0 ?_ + intro b hb + exact common_sub_672_i0 (mem_commonEnvelope childrenD_672_i0 b hb) + +theorem finite_children_work_672 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_672 j) (childrenD_672 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_34 3 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_305 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_672_i0.mono (by decide +kernel) + +theorem finite_row_works_672 : FiniteTemplate HasSnaky 5 required_672 envelope_672 := by + refine finite_compose HasSnaky 4 childrenC_672 childrenD_672 finite_children_work_672 (2, 2) + required_672 envelope_672 pivot_mem_672 child_required_sub_672 child_envelope_sub_672 ?_ + intro b hb + exact common_sub_672 (mem_commonEnvelope childrenD_672 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height05Part07.lean b/lean/snaky/FiniteCards/Height05Part07.lean new file mode 100644 index 0000000..2e0a1d3 --- /dev/null +++ b/lean/snaky/FiniteCards/Height05Part07.lean @@ -0,0 +1,37 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part07 +import FiniteCards.Height01Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_679_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_679_i0 j) (childrenD_679_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 4 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_222 5 (5, 1)).mono (by decide +kernel) + +theorem finite_row_works_679_i0 : FiniteTemplate HasSnaky 4 required_679_i0 envelope_679_i0 := by + refine finite_compose HasSnaky 3 childrenC_679_i0 childrenD_679_i0 finite_children_work_679_i0 (3, 3) + required_679_i0 envelope_679_i0 pivot_mem_679_i0 child_required_sub_679_i0 child_envelope_sub_679_i0 ?_ + intro b hb + exact common_sub_679_i0 (mem_commonEnvelope childrenD_679_i0 b hb) + +theorem finite_children_work_679 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_679 j) (childrenD_679 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_679_i0.mono (by decide +kernel) + +theorem finite_row_works_679 : FiniteTemplate HasSnaky 5 required_679 envelope_679 := by + refine finite_compose HasSnaky 4 childrenC_679 childrenD_679 finite_children_work_679 (2, 3) + required_679 envelope_679 pivot_mem_679 child_required_sub_679 child_envelope_sub_679 ?_ + intro b hb + exact common_sub_679 (mem_commonEnvelope childrenD_679 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height06Part01.lean b/lean/snaky/FiniteCards/Height06Part01.lean new file mode 100644 index 0000000..5043274 --- /dev/null +++ b/lean/snaky/FiniteCards/Height06Part01.lean @@ -0,0 +1,319 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_85 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_85 j) (childrenD_85 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_65 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_72 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_85 : FiniteTemplate HasSnaky 6 required_85 envelope_85 := by + refine finite_compose HasSnaky 5 childrenC_85 childrenD_85 finite_children_work_85 (2, 5) + required_85 envelope_85 pivot_mem_85 child_required_sub_85 child_envelope_sub_85 ?_ + intro b hb + exact common_sub_85 (mem_commonEnvelope childrenD_85 b hb) + +theorem finite_children_work_95 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_95 j) (childrenD_95 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_19 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_49 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_49 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_95 : FiniteTemplate HasSnaky 6 required_95 envelope_95 := by + refine finite_compose HasSnaky 5 childrenC_95 childrenD_95 finite_children_work_95 (1, 5) + required_95 envelope_95 pivot_mem_95 child_required_sub_95 child_envelope_sub_95 ?_ + intro b hb + exact common_sub_95 (mem_commonEnvelope childrenD_95 b hb) + +theorem finite_children_work_110 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_110 j) (childrenD_110 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_28 5 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_58 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_100 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_110 : FiniteTemplate HasSnaky 6 required_110 envelope_110 := by + refine finite_compose HasSnaky 5 childrenC_110 childrenD_110 finite_children_work_110 (3, 4) + required_110 envelope_110 pivot_mem_110 child_required_sub_110 child_envelope_sub_110 ?_ + intro b hb + exact common_sub_110 (mem_commonEnvelope childrenD_110 b hb) + +theorem finite_children_work_115 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_115 j) (childrenD_115 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_114.mono (by decide +kernel) + +theorem finite_row_works_115 : FiniteTemplate HasSnaky 6 required_115 envelope_115 := by + refine finite_compose HasSnaky 5 childrenC_115 childrenD_115 finite_children_work_115 (3, 2) + required_115 envelope_115 pivot_mem_115 child_required_sub_115 child_envelope_sub_115 ?_ + intro b hb + exact common_sub_115 (mem_commonEnvelope childrenD_115 b hb) + +theorem finite_children_work_119 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_119 j) (childrenD_119 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_114.mono (by decide +kernel) + +theorem finite_row_works_119 : FiniteTemplate HasSnaky 6 required_119 envelope_119 := by + refine finite_compose HasSnaky 5 childrenC_119 childrenD_119 finite_children_work_119 (2, 3) + required_119 envelope_119 pivot_mem_119 child_required_sub_119 child_envelope_sub_119 ?_ + intro b hb + exact common_sub_119 (mem_commonEnvelope childrenD_119 b hb) + +theorem finite_children_work_134 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_134 j) (childrenD_134 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_16 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 4 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_133 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_134 : FiniteTemplate HasSnaky 6 required_134 envelope_134 := by + refine finite_compose HasSnaky 5 childrenC_134 childrenD_134 finite_children_work_134 (4, 2) + required_134 envelope_134 pivot_mem_134 child_required_sub_134 child_envelope_sub_134 ?_ + intro b hb + exact common_sub_134 (mem_commonEnvelope childrenD_134 b hb) + +theorem finite_children_work_135 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_135 j) (childrenD_135 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 6 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_133 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_135 : FiniteTemplate HasSnaky 6 required_135 envelope_135 := by + refine finite_compose HasSnaky 5 childrenC_135 childrenD_135 finite_children_work_135 (2, 5) + required_135 envelope_135 pivot_mem_135 child_required_sub_135 child_envelope_sub_135 ?_ + intro b hb + exact common_sub_135 (mem_commonEnvelope childrenD_135 b hb) + +theorem finite_children_work_136 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_136 j) (childrenD_136 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 2 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_37 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_133 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_136 : FiniteTemplate HasSnaky 6 required_136 envelope_136 := by + refine finite_compose HasSnaky 5 childrenC_136 childrenD_136 finite_children_work_136 (2, 4) + required_136 envelope_136 pivot_mem_136 child_required_sub_136 child_envelope_sub_136 ?_ + intro b hb + exact common_sub_136 (mem_commonEnvelope childrenD_136 b hb) + +theorem finite_children_work_137 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_137 j) (childrenD_137 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_133 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_137 : FiniteTemplate HasSnaky 6 required_137 envelope_137 := by + refine finite_compose HasSnaky 5 childrenC_137 childrenD_137 finite_children_work_137 (4, 2) + required_137 envelope_137 pivot_mem_137 child_required_sub_137 child_envelope_sub_137 ?_ + intro b hb + exact common_sub_137 (mem_commonEnvelope childrenD_137 b hb) + +theorem finite_children_work_161 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_161 j) (childrenD_161 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 1 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_142.mono (by decide +kernel) + +theorem finite_row_works_161 : FiniteTemplate HasSnaky 6 required_161 envelope_161 := by + refine finite_compose HasSnaky 5 childrenC_161 childrenD_161 finite_children_work_161 (4, 3) + required_161 envelope_161 pivot_mem_161 child_required_sub_161 child_envelope_sub_161 ?_ + intro b hb + exact common_sub_161 (mem_commonEnvelope childrenD_161 b hb) + +theorem finite_children_work_162 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_162 j) (childrenD_162 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_142.mono (by decide +kernel) + +theorem finite_row_works_162 : FiniteTemplate HasSnaky 6 required_162 envelope_162 := by + refine finite_compose HasSnaky 5 childrenC_162 childrenD_162 finite_children_work_162 (4, 3) + required_162 envelope_162 pivot_mem_162 child_required_sub_162 child_envelope_sub_162 ?_ + intro b hb + exact common_sub_162 (mem_commonEnvelope childrenD_162 b hb) + +theorem finite_children_work_166 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_166 j) (childrenD_166 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_28 5 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_58 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_100 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_166 : FiniteTemplate HasSnaky 6 required_166 envelope_166 := by + refine finite_compose HasSnaky 5 childrenC_166 childrenD_166 finite_children_work_166 (3, 3) + required_166 envelope_166 pivot_mem_166 child_required_sub_166 child_envelope_sub_166 ?_ + intro b hb + exact common_sub_166 (mem_commonEnvelope childrenD_166 b hb) + +theorem finite_children_work_167 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_167 j) (childrenD_167 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_152 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_167 : FiniteTemplate HasSnaky 6 required_167 envelope_167 := by + refine finite_compose HasSnaky 5 childrenC_167 childrenD_167 finite_children_work_167 (3, 2) + required_167 envelope_167 pivot_mem_167 child_required_sub_167 child_envelope_sub_167 ?_ + intro b hb + exact common_sub_167 (mem_commonEnvelope childrenD_167 b hb) + +theorem finite_children_work_172 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_172 j) (childrenD_172 j) := by + intro j + fin_cases j + · exact finite_row_works_142.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_142 6 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_172 : FiniteTemplate HasSnaky 6 required_172 envelope_172 := by + refine finite_compose HasSnaky 5 childrenC_172 childrenD_172 finite_children_work_172 (4, 3) + required_172 envelope_172 pivot_mem_172 child_required_sub_172 child_envelope_sub_172 ?_ + intro b hb + exact common_sub_172 (mem_commonEnvelope childrenD_172 b hb) + +theorem finite_children_work_173 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_173 j) (childrenD_173 j) := by + intro j + fin_cases j + · exact finite_row_works_142.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_142 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_173 : FiniteTemplate HasSnaky 6 required_173 envelope_173 := by + refine finite_compose HasSnaky 5 childrenC_173 childrenD_173 finite_children_work_173 (4, 3) + required_173 envelope_173 pivot_mem_173 child_required_sub_173 child_envelope_sub_173 ?_ + intro b hb + exact common_sub_173 (mem_commonEnvelope childrenD_173 b hb) + +theorem finite_children_work_180 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_180 j) (childrenD_180 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_16 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 4 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_180 : FiniteTemplate HasSnaky 6 required_180 envelope_180 := by + refine finite_compose HasSnaky 5 childrenC_180 childrenD_180 finite_children_work_180 (4, 2) + required_180 envelope_180 pivot_mem_180 child_required_sub_180 child_envelope_sub_180 ?_ + intro b hb + exact common_sub_180 (mem_commonEnvelope childrenD_180 b hb) + +theorem finite_children_work_181 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_181 j) (childrenD_181 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_181 : FiniteTemplate HasSnaky 6 required_181 envelope_181 := by + refine finite_compose HasSnaky 5 childrenC_181 childrenD_181 finite_children_work_181 (4, 2) + required_181 envelope_181 pivot_mem_181 child_required_sub_181 child_envelope_sub_181 ?_ + intro b hb + exact common_sub_181 (mem_commonEnvelope childrenD_181 b hb) + +theorem finite_children_work_182 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_182 j) (childrenD_182 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_182 : FiniteTemplate HasSnaky 6 required_182 envelope_182 := by + refine finite_compose HasSnaky 5 childrenC_182 childrenD_182 finite_children_work_182 (2, 5) + required_182 envelope_182 pivot_mem_182 child_required_sub_182 child_envelope_sub_182 ?_ + intro b hb + exact common_sub_182 (mem_commonEnvelope childrenD_182 b hb) + +theorem finite_children_work_184 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_184 j) (childrenD_184 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_99 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 6 (5, 5)).mono (by decide +kernel) + +theorem finite_row_works_184 : FiniteTemplate HasSnaky 6 required_184 envelope_184 := by + refine finite_compose HasSnaky 5 childrenC_184 childrenD_184 finite_children_work_184 (2, 3) + required_184 envelope_184 pivot_mem_184 child_required_sub_184 child_envelope_sub_184 ?_ + intro b hb + exact common_sub_184 (mem_commonEnvelope childrenD_184 b hb) + +theorem finite_children_work_188 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_188 j) (childrenD_188 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 5 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_133 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_186 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_187 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_188 : FiniteTemplate HasSnaky 6 required_188 envelope_188 := by + refine finite_compose HasSnaky 5 childrenC_188 childrenD_188 finite_children_work_188 (2, 5) + required_188 envelope_188 pivot_mem_188 child_required_sub_188 child_envelope_sub_188 ?_ + intro b hb + exact common_sub_188 (mem_commonEnvelope childrenD_188 b hb) + +theorem finite_children_work_189 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_189 j) (childrenD_189 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_62 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_186 6 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_187 2 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_189 : FiniteTemplate HasSnaky 6 required_189 envelope_189 := by + refine finite_compose HasSnaky 5 childrenC_189 childrenD_189 finite_children_work_189 (1, 5) + required_189 envelope_189 pivot_mem_189 child_required_sub_189 child_envelope_sub_189 ?_ + intro b hb + exact common_sub_189 (mem_commonEnvelope childrenD_189 b hb) + +theorem finite_children_work_190 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_190 j) (childrenD_190 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_186 6 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_187 2 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_190 : FiniteTemplate HasSnaky 6 required_190 envelope_190 := by + refine finite_compose HasSnaky 5 childrenC_190 childrenD_190 finite_children_work_190 (2, 5) + required_190 envelope_190 pivot_mem_190 child_required_sub_190 child_envelope_sub_190 ?_ + intro b hb + exact common_sub_190 (mem_commonEnvelope childrenD_190 b hb) + +theorem finite_children_work_192 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_192 j) (childrenD_192 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 6 (2, 6)).mono (by decide +kernel) + · exact finite_row_works_186.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_187 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_191 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_192 : FiniteTemplate HasSnaky 6 required_192 envelope_192 := by + refine finite_compose HasSnaky 5 childrenC_192 childrenD_192 finite_children_work_192 (1, 5) + required_192 envelope_192 pivot_mem_192 child_required_sub_192 child_envelope_sub_192 ?_ + intro b hb + exact common_sub_192 (mem_commonEnvelope childrenD_192 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height06Part02.lean b/lean/snaky/FiniteCards/Height06Part02.lean new file mode 100644 index 0000000..ec83d4b --- /dev/null +++ b/lean/snaky/FiniteCards/Height06Part02.lean @@ -0,0 +1,312 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_193 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_193 j) (childrenD_193 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 5 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_191 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_193 : FiniteTemplate HasSnaky 6 required_193 envelope_193 := by + refine finite_compose HasSnaky 5 childrenC_193 childrenD_193 finite_children_work_193 (1, 5) + required_193 envelope_193 pivot_mem_193 child_required_sub_193 child_envelope_sub_193 ?_ + intro b hb + exact common_sub_193 (mem_commonEnvelope childrenD_193 b hb) + +theorem finite_children_work_203 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_203 j) (childrenD_203 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_202 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_203 : FiniteTemplate HasSnaky 6 required_203 envelope_203 := by + refine finite_compose HasSnaky 5 childrenC_203 childrenD_203 finite_children_work_203 (1, 3) + required_203 envelope_203 pivot_mem_203 child_required_sub_203 child_envelope_sub_203 ?_ + intro b hb + exact common_sub_203 (mem_commonEnvelope childrenD_203 b hb) + +theorem finite_children_work_217 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_217 j) (childrenD_217 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 2 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_37 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_217 : FiniteTemplate HasSnaky 6 required_217 envelope_217 := by + refine finite_compose HasSnaky 5 childrenC_217 childrenD_217 finite_children_work_217 (2, 4) + required_217 envelope_217 pivot_mem_217 child_required_sub_217 child_envelope_sub_217 ?_ + intro b hb + exact common_sub_217 (mem_commonEnvelope childrenD_217 b hb) + +theorem finite_children_work_238 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_238 j) (childrenD_238 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_133 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_238 : FiniteTemplate HasSnaky 6 required_238 envelope_238 := by + refine finite_compose HasSnaky 5 childrenC_238 childrenD_238 finite_children_work_238 (2, 4) + required_238 envelope_238 pivot_mem_238 child_required_sub_238 child_envelope_sub_238 ?_ + intro b hb + exact common_sub_238 (mem_commonEnvelope childrenD_238 b hb) + +theorem finite_children_work_248 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_248 j) (childrenD_248 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_47 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_127 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_248 : FiniteTemplate HasSnaky 6 required_248 envelope_248 := by + refine finite_compose HasSnaky 5 childrenC_248 childrenD_248 finite_children_work_248 (2, 5) + required_248 envelope_248 pivot_mem_248 child_required_sub_248 child_envelope_sub_248 ?_ + intro b hb + exact common_sub_248 (mem_commonEnvelope childrenD_248 b hb) + +theorem finite_children_work_253 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_253 j) (childrenD_253 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_18 1 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_252.mono (by decide +kernel) + +theorem finite_row_works_253 : FiniteTemplate HasSnaky 6 required_253 envelope_253 := by + refine finite_compose HasSnaky 5 childrenC_253 childrenD_253 finite_children_work_253 (4, 3) + required_253 envelope_253 pivot_mem_253 child_required_sub_253 child_envelope_sub_253 ?_ + intro b hb + exact common_sub_253 (mem_commonEnvelope childrenD_253 b hb) + +theorem finite_children_work_255 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_255 j) (childrenD_255 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_254 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_255 : FiniteTemplate HasSnaky 6 required_255 envelope_255 := by + refine finite_compose HasSnaky 5 childrenC_255 childrenD_255 finite_children_work_255 (3, 2) + required_255 envelope_255 pivot_mem_255 child_required_sub_255 child_envelope_sub_255 ?_ + intro b hb + exact common_sub_255 (mem_commonEnvelope childrenD_255 b hb) + +theorem finite_children_work_267 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_267 j) (childrenD_267 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_75 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_266 2 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_267 : FiniteTemplate HasSnaky 6 required_267 envelope_267 := by + refine finite_compose HasSnaky 5 childrenC_267 childrenD_267 finite_children_work_267 (2, 5) + required_267 envelope_267 pivot_mem_267 child_required_sub_267 child_envelope_sub_267 ?_ + intro b hb + exact common_sub_267 (mem_commonEnvelope childrenD_267 b hb) + +theorem finite_children_work_270 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_270 j) (childrenD_270 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_70 7 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_106 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_122 1 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_269 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_270 : FiniteTemplate HasSnaky 6 required_270 envelope_270 := by + refine finite_compose HasSnaky 5 childrenC_270 childrenD_270 finite_children_work_270 (4, 2) + required_270 envelope_270 pivot_mem_270 child_required_sub_270 child_envelope_sub_270 ?_ + intro b hb + exact common_sub_270 (mem_commonEnvelope childrenD_270 b hb) + +theorem finite_children_work_275 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_275 j) (childrenD_275 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_16 3 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_275 : FiniteTemplate HasSnaky 6 required_275 envelope_275 := by + refine finite_compose HasSnaky 5 childrenC_275 childrenD_275 finite_children_work_275 (4, 2) + required_275 envelope_275 pivot_mem_275 child_required_sub_275 child_envelope_sub_275 ?_ + intro b hb + exact common_sub_275 (mem_commonEnvelope childrenD_275 b hb) + +theorem finite_children_work_283 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_283 j) (childrenD_283 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_282 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_283 : FiniteTemplate HasSnaky 6 required_283 envelope_283 := by + refine finite_compose HasSnaky 5 childrenC_283 childrenD_283 finite_children_work_283 (2, 2) + required_283 envelope_283 pivot_mem_283 child_required_sub_283 child_envelope_sub_283 ?_ + intro b hb + exact common_sub_283 (mem_commonEnvelope childrenD_283 b hb) + +theorem finite_children_work_284 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_284 j) (childrenD_284 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_19 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_75 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_284 : FiniteTemplate HasSnaky 6 required_284 envelope_284 := by + refine finite_compose HasSnaky 5 childrenC_284 childrenD_284 finite_children_work_284 (1, 3) + required_284 envelope_284 pivot_mem_284 child_required_sub_284 child_envelope_sub_284 ?_ + intro b hb + exact common_sub_284 (mem_commonEnvelope childrenD_284 b hb) + +theorem finite_children_work_287 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_287 j) (childrenD_287 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_169 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_230 5 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_287 : FiniteTemplate HasSnaky 6 required_287 envelope_287 := by + refine finite_compose HasSnaky 5 childrenC_287 childrenD_287 finite_children_work_287 (1, 6) + required_287 envelope_287 pivot_mem_287 child_required_sub_287 child_envelope_sub_287 ?_ + intro b hb + exact common_sub_287 (mem_commonEnvelope childrenD_287 b hb) + +theorem finite_children_work_292 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_292 j) (childrenD_292 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_19 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_214.mono (by decide +kernel) + +theorem finite_row_works_292 : FiniteTemplate HasSnaky 6 required_292 envelope_292 := by + refine finite_compose HasSnaky 5 childrenC_292 childrenD_292 finite_children_work_292 (4, 3) + required_292 envelope_292 pivot_mem_292 child_required_sub_292 child_envelope_sub_292 ?_ + intro b hb + exact common_sub_292 (mem_commonEnvelope childrenD_292 b hb) + +theorem finite_children_work_300 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_300 j) (childrenD_300 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_128 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_155 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_300 : FiniteTemplate HasSnaky 6 required_300 envelope_300 := by + refine finite_compose HasSnaky 5 childrenC_300 childrenD_300 finite_children_work_300 (2, 5) + required_300 envelope_300 pivot_mem_300 child_required_sub_300 child_envelope_sub_300 ?_ + intro b hb + exact common_sub_300 (mem_commonEnvelope childrenD_300 b hb) + +theorem finite_children_work_302 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_302 j) (childrenD_302 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 7 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_214 4 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_302 : FiniteTemplate HasSnaky 6 required_302 envelope_302 := by + refine finite_compose HasSnaky 5 childrenC_302 childrenD_302 finite_children_work_302 (5, 3) + required_302 envelope_302 pivot_mem_302 child_required_sub_302 child_envelope_sub_302 ?_ + intro b hb + exact common_sub_302 (mem_commonEnvelope childrenD_302 b hb) + +theorem finite_children_work_303 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_303 j) (childrenD_303 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_55 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_234 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_303 : FiniteTemplate HasSnaky 6 required_303 envelope_303 := by + refine finite_compose HasSnaky 5 childrenC_303 childrenD_303 finite_children_work_303 (3, 4) + required_303 envelope_303 pivot_mem_303 child_required_sub_303 child_envelope_sub_303 ?_ + intro b hb + exact common_sub_303 (mem_commonEnvelope childrenD_303 b hb) + +theorem finite_children_work_313 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_313 j) (childrenD_313 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_312 5 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_313 : FiniteTemplate HasSnaky 6 required_313 envelope_313 := by + refine finite_compose HasSnaky 5 childrenC_313 childrenD_313 finite_children_work_313 (3, 0) + required_313 envelope_313 pivot_mem_313 child_required_sub_313 child_envelope_sub_313 ?_ + intro b hb + exact common_sub_313 (mem_commonEnvelope childrenD_313 b hb) + +theorem finite_children_work_315 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_315 j) (childrenD_315 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_315 : FiniteTemplate HasSnaky 6 required_315 envelope_315 := by + refine finite_compose HasSnaky 5 childrenC_315 childrenD_315 finite_children_work_315 (1, 4) + required_315 envelope_315 pivot_mem_315 child_required_sub_315 child_envelope_sub_315 ?_ + intro b hb + exact common_sub_315 (mem_commonEnvelope childrenD_315 b hb) + +theorem finite_children_work_316 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_316 j) (childrenD_316 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_316 : FiniteTemplate HasSnaky 6 required_316 envelope_316 := by + refine finite_compose HasSnaky 5 childrenC_316 childrenD_316 finite_children_work_316 (1, 2) + required_316 envelope_316 pivot_mem_316 child_required_sub_316 child_envelope_sub_316 ?_ + intro b hb + exact common_sub_316 (mem_commonEnvelope childrenD_316 b hb) + +theorem finite_children_work_331_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_331_i1 j) (childrenD_331_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_20 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_29 6 (3, 5)).mono (by decide +kernel) + +theorem finite_row_works_331_i1 : FiniteTemplate HasSnaky 4 required_331_i1 envelope_331_i1 := by + refine finite_compose HasSnaky 3 childrenC_331_i1 childrenD_331_i1 finite_children_work_331_i1 (3, 5) + required_331_i1 envelope_331_i1 pivot_mem_331_i1 child_required_sub_331_i1 child_envelope_sub_331_i1 ?_ + intro b hb + exact common_sub_331_i1 (mem_commonEnvelope childrenD_331_i1 b hb) + +theorem finite_children_work_331_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_331_i0 j) (childrenD_331_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_331_i1.mono (by decide +kernel) + +theorem finite_row_works_331_i0 : FiniteTemplate HasSnaky 5 required_331_i0 envelope_331_i0 := by + refine finite_compose HasSnaky 4 childrenC_331_i0 childrenD_331_i0 finite_children_work_331_i0 (3, 2) + required_331_i0 envelope_331_i0 pivot_mem_331_i0 child_required_sub_331_i0 child_envelope_sub_331_i0 ?_ + intro b hb + exact common_sub_331_i0 (mem_commonEnvelope childrenD_331_i0 b hb) + +theorem finite_children_work_331 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_331 j) (childrenD_331 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_331_i0.mono (by decide +kernel) + +theorem finite_row_works_331 : FiniteTemplate HasSnaky 6 required_331 envelope_331 := by + refine finite_compose HasSnaky 5 childrenC_331 childrenD_331 finite_children_work_331 (3, 4) + required_331 envelope_331 pivot_mem_331 child_required_sub_331 child_envelope_sub_331 ?_ + intro b hb + exact common_sub_331 (mem_commonEnvelope childrenD_331 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height06Part03.lean b/lean/snaky/FiniteCards/Height06Part03.lean new file mode 100644 index 0000000..74dc53a --- /dev/null +++ b/lean/snaky/FiniteCards/Height06Part03.lean @@ -0,0 +1,310 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_336_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_336_i1 j) (childrenD_336_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_37 2 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_336_i1 : FiniteTemplate HasSnaky 4 required_336_i1 envelope_336_i1 := by + refine finite_compose HasSnaky 3 childrenC_336_i1 childrenD_336_i1 finite_children_work_336_i1 (1, 5) + required_336_i1 envelope_336_i1 pivot_mem_336_i1 child_required_sub_336_i1 child_envelope_sub_336_i1 ?_ + intro b hb + exact common_sub_336_i1 (mem_commonEnvelope childrenD_336_i1 b hb) + +theorem finite_children_work_336_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_336_i0 j) (childrenD_336_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_336_i1.mono (by decide +kernel) + +theorem finite_row_works_336_i0 : FiniteTemplate HasSnaky 5 required_336_i0 envelope_336_i0 := by + refine finite_compose HasSnaky 4 childrenC_336_i0 childrenD_336_i0 finite_children_work_336_i0 (2, 3) + required_336_i0 envelope_336_i0 pivot_mem_336_i0 child_required_sub_336_i0 child_envelope_sub_336_i0 ?_ + intro b hb + exact common_sub_336_i0 (mem_commonEnvelope childrenD_336_i0 b hb) + +theorem finite_children_work_336 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_336 j) (childrenD_336 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_18 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_336_i0.mono (by decide +kernel) + +theorem finite_row_works_336 : FiniteTemplate HasSnaky 6 required_336 envelope_336 := by + refine finite_compose HasSnaky 5 childrenC_336 childrenD_336 finite_children_work_336 (1, 4) + required_336 envelope_336 pivot_mem_336 child_required_sub_336 child_envelope_sub_336 ?_ + intro b hb + exact common_sub_336 (mem_commonEnvelope childrenD_336 b hb) + +theorem finite_children_work_340_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_340_i0 j) (childrenD_340_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_91 0 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_340_i0 : FiniteTemplate HasSnaky 5 required_340_i0 envelope_340_i0 := by + refine finite_compose HasSnaky 4 childrenC_340_i0 childrenD_340_i0 finite_children_work_340_i0 (1, 6) + required_340_i0 envelope_340_i0 pivot_mem_340_i0 child_required_sub_340_i0 child_envelope_sub_340_i0 ?_ + intro b hb + exact common_sub_340_i0 (mem_commonEnvelope childrenD_340_i0 b hb) + +theorem finite_children_work_340 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_340 j) (childrenD_340 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_139 2 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_148 4 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_340_i0.mono (by decide +kernel) + +theorem finite_row_works_340 : FiniteTemplate HasSnaky 6 required_340 envelope_340 := by + refine finite_compose HasSnaky 5 childrenC_340 childrenD_340 finite_children_work_340 (0, 6) + required_340 envelope_340 pivot_mem_340 child_required_sub_340 child_envelope_sub_340 ?_ + intro b hb + exact common_sub_340 (mem_commonEnvelope childrenD_340 b hb) + +theorem finite_children_work_343 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_343 j) (childrenD_343 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_342.mono (by decide +kernel) + +theorem finite_row_works_343 : FiniteTemplate HasSnaky 6 required_343 envelope_343 := by + refine finite_compose HasSnaky 5 childrenC_343 childrenD_343 finite_children_work_343 (3, 3) + required_343 envelope_343 pivot_mem_343 child_required_sub_343 child_envelope_sub_343 ?_ + intro b hb + exact common_sub_343 (mem_commonEnvelope childrenD_343 b hb) + +theorem finite_children_work_346 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_346 j) (childrenD_346 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_342 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_346 : FiniteTemplate HasSnaky 6 required_346 envelope_346 := by + refine finite_compose HasSnaky 5 childrenC_346 childrenD_346 finite_children_work_346 (2, 3) + required_346 envelope_346 pivot_mem_346 child_required_sub_346 child_envelope_sub_346 ?_ + intro b hb + exact common_sub_346 (mem_commonEnvelope childrenD_346 b hb) + +theorem finite_children_work_348_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_348_i0 j) (childrenD_348_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_311 1 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_348_i0 : FiniteTemplate HasSnaky 5 required_348_i0 envelope_348_i0 := by + refine finite_compose HasSnaky 4 childrenC_348_i0 childrenD_348_i0 finite_children_work_348_i0 (3, 0) + required_348_i0 envelope_348_i0 pivot_mem_348_i0 child_required_sub_348_i0 child_envelope_sub_348_i0 ?_ + intro b hb + exact common_sub_348_i0 (mem_commonEnvelope childrenD_348_i0 b hb) + +theorem finite_children_work_348 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_348 j) (childrenD_348 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_348_i0.mono (by decide +kernel) + +theorem finite_row_works_348 : FiniteTemplate HasSnaky 6 required_348 envelope_348 := by + refine finite_compose HasSnaky 5 childrenC_348 childrenD_348 finite_children_work_348 (3, 1) + required_348 envelope_348 pivot_mem_348 child_required_sub_348 child_envelope_sub_348 ?_ + intro b hb + exact common_sub_348 (mem_commonEnvelope childrenD_348 b hb) + +theorem finite_children_work_349_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_349_i0 j) (childrenD_349_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_54 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_349_i0 : FiniteTemplate HasSnaky 5 required_349_i0 envelope_349_i0 := by + refine finite_compose HasSnaky 4 childrenC_349_i0 childrenD_349_i0 finite_children_work_349_i0 (4, 3) + required_349_i0 envelope_349_i0 pivot_mem_349_i0 child_required_sub_349_i0 child_envelope_sub_349_i0 ?_ + intro b hb + exact common_sub_349_i0 (mem_commonEnvelope childrenD_349_i0 b hb) + +theorem finite_children_work_349 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_349 j) (childrenD_349 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_165 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_216 4 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_349_i0.mono (by decide +kernel) + +theorem finite_row_works_349 : FiniteTemplate HasSnaky 6 required_349 envelope_349 := by + refine finite_compose HasSnaky 5 childrenC_349 childrenD_349 finite_children_work_349 (3, 5) + required_349 envelope_349 pivot_mem_349 child_required_sub_349 child_envelope_sub_349 ?_ + intro b hb + exact common_sub_349 (mem_commonEnvelope childrenD_349 b hb) + +theorem finite_children_work_358 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_358 j) (childrenD_358 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_357 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_358 : FiniteTemplate HasSnaky 6 required_358 envelope_358 := by + refine finite_compose HasSnaky 5 childrenC_358 childrenD_358 finite_children_work_358 (2, 4) + required_358 envelope_358 pivot_mem_358 child_required_sub_358 child_envelope_sub_358 ?_ + intro b hb + exact common_sub_358 (mem_commonEnvelope childrenD_358 b hb) + +theorem finite_children_work_360_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_360_i0 j) (childrenD_360_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_45 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_360_i0 : FiniteTemplate HasSnaky 4 required_360_i0 envelope_360_i0 := by + refine finite_compose HasSnaky 3 childrenC_360_i0 childrenD_360_i0 finite_children_work_360_i0 (2, 3) + required_360_i0 envelope_360_i0 pivot_mem_360_i0 child_required_sub_360_i0 child_envelope_sub_360_i0 ?_ + intro b hb + exact common_sub_360_i0 (mem_commonEnvelope childrenD_360_i0 b hb) + +theorem finite_children_work_360 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_360 j) (childrenD_360 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 2 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_347 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_360_i0.mono (by decide +kernel) + +theorem finite_row_works_360 : FiniteTemplate HasSnaky 6 required_360 envelope_360 := by + refine finite_compose HasSnaky 5 childrenC_360 childrenD_360 finite_children_work_360 (2, 4) + required_360 envelope_360 pivot_mem_360 child_required_sub_360 child_envelope_sub_360 ?_ + intro b hb + exact common_sub_360 (mem_commonEnvelope childrenD_360 b hb) + +theorem finite_children_work_363 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_363 j) (childrenD_363 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 0 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_362.mono (by decide +kernel) + +theorem finite_row_works_363 : FiniteTemplate HasSnaky 6 required_363 envelope_363 := by + refine finite_compose HasSnaky 5 childrenC_363 childrenD_363 finite_children_work_363 (4, 4) + required_363 envelope_363 pivot_mem_363 child_required_sub_363 child_envelope_sub_363 ?_ + intro b hb + exact common_sub_363 (mem_commonEnvelope childrenD_363 b hb) + +theorem finite_children_work_364 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_364 j) (childrenD_364 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 0 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_362.mono (by decide +kernel) + +theorem finite_row_works_364 : FiniteTemplate HasSnaky 6 required_364 envelope_364 := by + refine finite_compose HasSnaky 5 childrenC_364 childrenD_364 finite_children_work_364 (4, 4) + required_364 envelope_364 pivot_mem_364 child_required_sub_364 child_envelope_sub_364 ?_ + intro b hb + exact common_sub_364 (mem_commonEnvelope childrenD_364 b hb) + +theorem finite_children_work_367 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_367 j) (childrenD_367 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 6 (2, 6)).mono (by decide +kernel) + · exact finite_row_works_366.mono (by decide +kernel) + +theorem finite_row_works_367 : FiniteTemplate HasSnaky 6 required_367 envelope_367 := by + refine finite_compose HasSnaky 5 childrenC_367 childrenD_367 finite_children_work_367 (1, 5) + required_367 envelope_367 pivot_mem_367 child_required_sub_367 child_envelope_sub_367 ?_ + intro b hb + exact common_sub_367 (mem_commonEnvelope childrenD_367 b hb) + +theorem finite_children_work_369_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_369_i0 j) (childrenD_369_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 2 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_365 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_369_i0 : FiniteTemplate HasSnaky 5 required_369_i0 envelope_369_i0 := by + refine finite_compose HasSnaky 4 childrenC_369_i0 childrenD_369_i0 finite_children_work_369_i0 (1, 7) + required_369_i0 envelope_369_i0 pivot_mem_369_i0 child_required_sub_369_i0 child_envelope_sub_369_i0 ?_ + intro b hb + exact common_sub_369_i0 (mem_commonEnvelope childrenD_369_i0 b hb) + +theorem finite_children_work_369 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_369 j) (childrenD_369 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 6 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_19 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_187 6 (1, 8)).mono (by decide +kernel) + · exact finite_row_works_369_i0.mono (by decide +kernel) + +theorem finite_row_works_369 : FiniteTemplate HasSnaky 6 required_369 envelope_369 := by + refine finite_compose HasSnaky 5 childrenC_369 childrenD_369 finite_children_work_369 (1, 6) + required_369 envelope_369 pivot_mem_369 child_required_sub_369 child_envelope_sub_369 ?_ + intro b hb + exact common_sub_369 (mem_commonEnvelope childrenD_369 b hb) + +theorem finite_children_work_371_i2 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_371_i2 j) (childrenD_371_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_371_i2 : FiniteTemplate HasSnaky 2 required_371_i2 envelope_371_i2 := by + refine finite_compose HasSnaky 1 childrenC_371_i2 childrenD_371_i2 finite_children_work_371_i2 (3, 2) + required_371_i2 envelope_371_i2 pivot_mem_371_i2 child_required_sub_371_i2 child_envelope_sub_371_i2 ?_ + intro b hb + exact common_sub_371_i2 (mem_commonEnvelope childrenD_371_i2 b hb) + +theorem finite_children_work_371_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_371_i1 j) (childrenD_371_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_210 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_371_i2.mono (by decide +kernel) + +theorem finite_row_works_371_i1 : FiniteTemplate HasSnaky 3 required_371_i1 envelope_371_i1 := by + refine finite_compose HasSnaky 2 childrenC_371_i1 childrenD_371_i1 finite_children_work_371_i1 (2, 2) + required_371_i1 envelope_371_i1 pivot_mem_371_i1 child_required_sub_371_i1 child_envelope_sub_371_i1 ?_ + intro b hb + exact common_sub_371_i1 (mem_commonEnvelope childrenD_371_i1 b hb) + +theorem finite_children_work_371_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_371_i0 j) (childrenD_371_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_371_i1.mono (by decide +kernel) + +theorem finite_row_works_371_i0 : FiniteTemplate HasSnaky 4 required_371_i0 envelope_371_i0 := by + refine finite_compose HasSnaky 3 childrenC_371_i0 childrenD_371_i0 finite_children_work_371_i0 (5, 1) + required_371_i0 envelope_371_i0 pivot_mem_371_i0 child_required_sub_371_i0 child_envelope_sub_371_i0 ?_ + intro b hb + exact common_sub_371_i0 (mem_commonEnvelope childrenD_371_i0 b hb) + +theorem finite_children_work_371 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_371 j) (childrenD_371 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_370 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_371_i0.mono (by decide +kernel) + +theorem finite_row_works_371 : FiniteTemplate HasSnaky 6 required_371 envelope_371 := by + refine finite_compose HasSnaky 5 childrenC_371 childrenD_371 finite_children_work_371 (4, 1) + required_371 envelope_371 pivot_mem_371 child_required_sub_371 child_envelope_sub_371 ?_ + intro b hb + exact common_sub_371 (mem_commonEnvelope childrenD_371 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height06Part04.lean b/lean/snaky/FiniteCards/Height06Part04.lean new file mode 100644 index 0000000..ead625b --- /dev/null +++ b/lean/snaky/FiniteCards/Height06Part04.lean @@ -0,0 +1,272 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part04 +import FiniteCards.Height04Part05 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_378_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_378_i0 j) (childrenD_378_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_18 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_378_i0 : FiniteTemplate HasSnaky 5 required_378_i0 envelope_378_i0 := by + refine finite_compose HasSnaky 4 childrenC_378_i0 childrenD_378_i0 finite_children_work_378_i0 (3, 3) + required_378_i0 envelope_378_i0 pivot_mem_378_i0 child_required_sub_378_i0 child_envelope_sub_378_i0 ?_ + intro b hb + exact common_sub_378_i0 (mem_commonEnvelope childrenD_378_i0 b hb) + +theorem finite_children_work_378 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_378 j) (childrenD_378 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_378_i0.mono (by decide +kernel) + +theorem finite_row_works_378 : FiniteTemplate HasSnaky 6 required_378 envelope_378 := by + refine finite_compose HasSnaky 5 childrenC_378 childrenD_378 finite_children_work_378 (3, 1) + required_378 envelope_378 pivot_mem_378 child_required_sub_378 child_envelope_sub_378 ?_ + intro b hb + exact common_sub_378 (mem_commonEnvelope childrenD_378 b hb) + +theorem finite_children_work_384 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_384 j) (childrenD_384 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_383 7 (5, 4)).mono (by decide +kernel) + +theorem finite_row_works_384 : FiniteTemplate HasSnaky 6 required_384 envelope_384 := by + refine finite_compose HasSnaky 5 childrenC_384 childrenD_384 finite_children_work_384 (3, 3) + required_384 envelope_384 pivot_mem_384 child_required_sub_384 child_envelope_sub_384 ?_ + intro b hb + exact common_sub_384 (mem_commonEnvelope childrenD_384 b hb) + +theorem finite_children_work_387 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_387 j) (childrenD_387 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_200 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_376 1 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_386 1 (0, 0)).mono (by decide +kernel) + +theorem finite_row_works_387 : FiniteTemplate HasSnaky 6 required_387 envelope_387 := by + refine finite_compose HasSnaky 5 childrenC_387 childrenD_387 finite_children_work_387 (4, 2) + required_387 envelope_387 pivot_mem_387 child_required_sub_387 child_envelope_sub_387 ?_ + intro b hb + exact common_sub_387 (mem_commonEnvelope childrenD_387 b hb) + +theorem finite_children_work_390 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_390 j) (childrenD_390 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 2 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 0 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_389 6 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_390 : FiniteTemplate HasSnaky 6 required_390 envelope_390 := by + refine finite_compose HasSnaky 5 childrenC_390 childrenD_390 finite_children_work_390 (1, 7) + required_390 envelope_390 pivot_mem_390 child_required_sub_390 child_envelope_sub_390 ?_ + intro b hb + exact common_sub_390 (mem_commonEnvelope childrenD_390 b hb) + +theorem finite_children_work_392 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_392 j) (childrenD_392 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_391.mono (by decide +kernel) + +theorem finite_row_works_392 : FiniteTemplate HasSnaky 6 required_392 envelope_392 := by + refine finite_compose HasSnaky 5 childrenC_392 childrenD_392 finite_children_work_392 (3, 3) + required_392 envelope_392 pivot_mem_392 child_required_sub_392 child_envelope_sub_392 ?_ + intro b hb + exact common_sub_392 (mem_commonEnvelope childrenD_392 b hb) + +theorem finite_children_work_393 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_393 j) (childrenD_393 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_20 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_391 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_393 : FiniteTemplate HasSnaky 6 required_393 envelope_393 := by + refine finite_compose HasSnaky 5 childrenC_393 childrenD_393 finite_children_work_393 (1, 4) + required_393 envelope_393 pivot_mem_393 child_required_sub_393 child_envelope_sub_393 ?_ + intro b hb + exact common_sub_393 (mem_commonEnvelope childrenD_393 b hb) + +theorem finite_children_work_403_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_403_i0 j) (childrenD_403_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 5 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_381 5 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_403_i0 : FiniteTemplate HasSnaky 5 required_403_i0 envelope_403_i0 := by + refine finite_compose HasSnaky 4 childrenC_403_i0 childrenD_403_i0 finite_children_work_403_i0 (2, 5) + required_403_i0 envelope_403_i0 pivot_mem_403_i0 child_required_sub_403_i0 child_envelope_sub_403_i0 ?_ + intro b hb + exact common_sub_403_i0 (mem_commonEnvelope childrenD_403_i0 b hb) + +theorem finite_children_work_403 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_403 j) (childrenD_403 j) := by + intro j + fin_cases j + · exact finite_row_works_86.mono (by decide +kernel) + · exact finite_row_works_403_i0.mono (by decide +kernel) + +theorem finite_row_works_403 : FiniteTemplate HasSnaky 6 required_403 envelope_403 := by + refine finite_compose HasSnaky 5 childrenC_403 childrenD_403 finite_children_work_403 (1, 5) + required_403 envelope_403 pivot_mem_403 child_required_sub_403 child_envelope_sub_403 ?_ + intro b hb + exact common_sub_403 (mem_commonEnvelope childrenD_403 b hb) + +theorem finite_children_work_414 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_414 j) (childrenD_414 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_413.mono (by decide +kernel) + +theorem finite_row_works_414 : FiniteTemplate HasSnaky 6 required_414 envelope_414 := by + refine finite_compose HasSnaky 5 childrenC_414 childrenD_414 finite_children_work_414 (1, 4) + required_414 envelope_414 pivot_mem_414 child_required_sub_414 child_envelope_sub_414 ?_ + intro b hb + exact common_sub_414 (mem_commonEnvelope childrenD_414 b hb) + +theorem finite_children_work_417 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_417 j) (childrenD_417 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_416.mono (by decide +kernel) + +theorem finite_row_works_417 : FiniteTemplate HasSnaky 6 required_417 envelope_417 := by + refine finite_compose HasSnaky 5 childrenC_417 childrenD_417 finite_children_work_417 (3, 2) + required_417 envelope_417 pivot_mem_417 child_required_sub_417 child_envelope_sub_417 ?_ + intro b hb + exact common_sub_417 (mem_commonEnvelope childrenD_417 b hb) + +theorem finite_children_work_423_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_423_i0 j) (childrenD_423_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_244.mono (by decide +kernel) + +theorem finite_row_works_423_i0 : FiniteTemplate HasSnaky 3 required_423_i0 envelope_423_i0 := by + refine finite_compose HasSnaky 2 childrenC_423_i0 childrenD_423_i0 finite_children_work_423_i0 (1, 2) + required_423_i0 envelope_423_i0 pivot_mem_423_i0 child_required_sub_423_i0 child_envelope_sub_423_i0 ?_ + intro b hb + exact common_sub_423_i0 (mem_commonEnvelope childrenD_423_i0 b hb) + +theorem finite_children_work_423 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_423 j) (childrenD_423 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_383 4 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_423_i0.mono (by decide +kernel) + +theorem finite_row_works_423 : FiniteTemplate HasSnaky 6 required_423 envelope_423 := by + refine finite_compose HasSnaky 5 childrenC_423 childrenD_423 finite_children_work_423 (2, 3) + required_423 envelope_423 pivot_mem_423 child_required_sub_423 child_envelope_sub_423 ?_ + intro b hb + exact common_sub_423 (mem_commonEnvelope childrenD_423 b hb) + +theorem finite_children_work_429_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_429_i0 j) (childrenD_429_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_46 5 (5, 1)).mono (by decide +kernel) + +theorem finite_row_works_429_i0 : FiniteTemplate HasSnaky 5 required_429_i0 envelope_429_i0 := by + refine finite_compose HasSnaky 4 childrenC_429_i0 childrenD_429_i0 finite_children_work_429_i0 (4, 3) + required_429_i0 envelope_429_i0 pivot_mem_429_i0 child_required_sub_429_i0 child_envelope_sub_429_i0 ?_ + intro b hb + exact common_sub_429_i0 (mem_commonEnvelope childrenD_429_i0 b hb) + +theorem finite_children_work_429 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_429 j) (childrenD_429 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 0 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_429_i0.mono (by decide +kernel) + +theorem finite_row_works_429 : FiniteTemplate HasSnaky 6 required_429 envelope_429 := by + refine finite_compose HasSnaky 5 childrenC_429 childrenD_429 finite_children_work_429 (3, 4) + required_429 envelope_429 pivot_mem_429 child_required_sub_429 child_envelope_sub_429 ?_ + intro b hb + exact common_sub_429 (mem_commonEnvelope childrenD_429 b hb) + +theorem finite_children_work_435_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_435_i1 j) (childrenD_435_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 4 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_212 2 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_435_i1 : FiniteTemplate HasSnaky 4 required_435_i1 envelope_435_i1 := by + refine finite_compose HasSnaky 3 childrenC_435_i1 childrenD_435_i1 finite_children_work_435_i1 (3, 2) + required_435_i1 envelope_435_i1 pivot_mem_435_i1 child_required_sub_435_i1 child_envelope_sub_435_i1 ?_ + intro b hb + exact common_sub_435_i1 (mem_commonEnvelope childrenD_435_i1 b hb) + +theorem finite_children_work_435_i3 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_435_i3 j) (childrenD_435_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 2 (3, 1)).mono (by decide +kernel) + +theorem finite_row_works_435_i3 : FiniteTemplate HasSnaky 3 required_435_i3 envelope_435_i3 := by + refine finite_compose HasSnaky 2 childrenC_435_i3 childrenD_435_i3 finite_children_work_435_i3 (3, 2) + required_435_i3 envelope_435_i3 pivot_mem_435_i3 child_required_sub_435_i3 child_envelope_sub_435_i3 ?_ + intro b hb + exact common_sub_435_i3 (mem_commonEnvelope childrenD_435_i3 b hb) + +theorem finite_children_work_435_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_435_i2 j) (childrenD_435_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_76 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_130 4 (3, 5)).mono (by decide +kernel) + · exact finite_row_works_435_i3.mono (by decide +kernel) + +theorem finite_row_works_435_i2 : FiniteTemplate HasSnaky 4 required_435_i2 envelope_435_i2 := by + refine finite_compose HasSnaky 3 childrenC_435_i2 childrenD_435_i2 finite_children_work_435_i2 (3, 5) + required_435_i2 envelope_435_i2 pivot_mem_435_i2 child_required_sub_435_i2 child_envelope_sub_435_i2 ?_ + intro b hb + exact common_sub_435_i2 (mem_commonEnvelope childrenD_435_i2 b hb) + +theorem finite_children_work_435_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_435_i0 j) (childrenD_435_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_76 5 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_435_i1.mono (by decide +kernel) + · exact finite_row_works_435_i2.mono (by decide +kernel) + +theorem finite_row_works_435_i0 : FiniteTemplate HasSnaky 5 required_435_i0 envelope_435_i0 := by + refine finite_compose HasSnaky 4 childrenC_435_i0 childrenD_435_i0 finite_children_work_435_i0 (3, 4) + required_435_i0 envelope_435_i0 pivot_mem_435_i0 child_required_sub_435_i0 child_envelope_sub_435_i0 ?_ + intro b hb + exact common_sub_435_i0 (mem_commonEnvelope childrenD_435_i0 b hb) + +theorem finite_children_work_435 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_435 j) (childrenD_435 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_130 3 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_140 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_183 4 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_435_i0.mono (by decide +kernel) + +theorem finite_row_works_435 : FiniteTemplate HasSnaky 6 required_435 envelope_435 := by + refine finite_compose HasSnaky 5 childrenC_435 childrenD_435 finite_children_work_435 (4, 2) + required_435 envelope_435 pivot_mem_435 child_required_sub_435 child_envelope_sub_435 ?_ + intro b hb + exact common_sub_435 (mem_commonEnvelope childrenD_435 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height06Part05.lean b/lean/snaky/FiniteCards/Height06Part05.lean new file mode 100644 index 0000000..f2ee931 --- /dev/null +++ b/lean/snaky/FiniteCards/Height06Part05.lean @@ -0,0 +1,294 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part04 +import FiniteCards.Height04Part05 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part05 +import FiniteCards.Height05Part06 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_439_i1 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_439_i1 j) (childrenD_439_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 6 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 3 (3, 5)).mono (by decide +kernel) + +theorem finite_row_works_439_i1 : FiniteTemplate HasSnaky 2 required_439_i1 envelope_439_i1 := by + refine finite_compose HasSnaky 1 childrenC_439_i1 childrenD_439_i1 finite_children_work_439_i1 (4, 2) + required_439_i1 envelope_439_i1 pivot_mem_439_i1 child_required_sub_439_i1 child_envelope_sub_439_i1 ?_ + intro b hb + exact common_sub_439_i1 (mem_commonEnvelope childrenD_439_i1 b hb) + +theorem finite_children_work_439_i4 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_439_i4 j) (childrenD_439_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 2 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_439_i4 : FiniteTemplate HasSnaky 2 required_439_i4 envelope_439_i4 := by + refine finite_compose HasSnaky 1 childrenC_439_i4 childrenD_439_i4 finite_children_work_439_i4 (4, 1) + required_439_i4 envelope_439_i4 pivot_mem_439_i4 child_required_sub_439_i4 child_envelope_sub_439_i4 ?_ + intro b hb + exact common_sub_439_i4 (mem_commonEnvelope childrenD_439_i4 b hb) + +theorem finite_children_work_439_i3 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_439_i3 j) (childrenD_439_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_439_i4.mono (by decide +kernel) + +theorem finite_row_works_439_i3 : FiniteTemplate HasSnaky 3 required_439_i3 envelope_439_i3 := by + refine finite_compose HasSnaky 2 childrenC_439_i3 childrenD_439_i3 finite_children_work_439_i3 (3, 1) + required_439_i3 envelope_439_i3 pivot_mem_439_i3 child_required_sub_439_i3 child_envelope_sub_439_i3 ?_ + intro b hb + exact common_sub_439_i3 (mem_commonEnvelope childrenD_439_i3 b hb) + +theorem finite_children_work_439_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_439_i2 j) (childrenD_439_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (3, 5)).mono (by decide +kernel) + · exact finite_row_works_439_i3.mono (by decide +kernel) + +theorem finite_row_works_439_i2 : FiniteTemplate HasSnaky 4 required_439_i2 envelope_439_i2 := by + refine finite_compose HasSnaky 3 childrenC_439_i2 childrenD_439_i2 finite_children_work_439_i2 (2, 1) + required_439_i2 envelope_439_i2 pivot_mem_439_i2 child_required_sub_439_i2 child_envelope_sub_439_i2 ?_ + intro b hb + exact common_sub_439_i2 (mem_commonEnvelope childrenD_439_i2 b hb) + +theorem finite_children_work_439_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_439_i0 j) (childrenD_439_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_251 7 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_432 7 (4, 5)).mono (by decide +kernel) + · exact finite_row_works_439_i1.mono (by decide +kernel) + · exact finite_row_works_439_i2.mono (by decide +kernel) + +theorem finite_row_works_439_i0 : FiniteTemplate HasSnaky 5 required_439_i0 envelope_439_i0 := by + refine finite_compose HasSnaky 4 childrenC_439_i0 childrenD_439_i0 finite_children_work_439_i0 (3, 2) + required_439_i0 envelope_439_i0 pivot_mem_439_i0 child_required_sub_439_i0 child_envelope_sub_439_i0 ?_ + intro b hb + exact common_sub_439_i0 (mem_commonEnvelope childrenD_439_i0 b hb) + +theorem finite_children_work_439 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_439 j) (childrenD_439 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_439_i0.mono (by decide +kernel) + +theorem finite_row_works_439 : FiniteTemplate HasSnaky 6 required_439 envelope_439 := by + refine finite_compose HasSnaky 5 childrenC_439 childrenD_439 finite_children_work_439 (3, 3) + required_439 envelope_439 pivot_mem_439 child_required_sub_439 child_envelope_sub_439 ?_ + intro b hb + exact common_sub_439 (mem_commonEnvelope childrenD_439 b hb) + +theorem finite_children_work_465_i3 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_465_i3 j) (childrenD_465_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_4 0 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_465_i3 : FiniteTemplate HasSnaky 2 required_465_i3 envelope_465_i3 := by + refine finite_compose HasSnaky 1 childrenC_465_i3 childrenD_465_i3 finite_children_work_465_i3 (3, 4) + required_465_i3 envelope_465_i3 pivot_mem_465_i3 child_required_sub_465_i3 child_envelope_sub_465_i3 ?_ + intro b hb + exact common_sub_465_i3 (mem_commonEnvelope childrenD_465_i3 b hb) + +theorem finite_children_work_465_i2 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_465_i2 j) (childrenD_465_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_465_i3.mono (by decide +kernel) + +theorem finite_row_works_465_i2 : FiniteTemplate HasSnaky 3 required_465_i2 envelope_465_i2 := by + refine finite_compose HasSnaky 2 childrenC_465_i2 childrenD_465_i2 finite_children_work_465_i2 (2, 4) + required_465_i2 envelope_465_i2 pivot_mem_465_i2 child_required_sub_465_i2 child_envelope_sub_465_i2 ?_ + intro b hb + exact common_sub_465_i2 (mem_commonEnvelope childrenD_465_i2 b hb) + +theorem finite_children_work_465_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_465_i1 j) (childrenD_465_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_465_i2.mono (by decide +kernel) + +theorem finite_row_works_465_i1 : FiniteTemplate HasSnaky 4 required_465_i1 envelope_465_i1 := by + refine finite_compose HasSnaky 3 childrenC_465_i1 childrenD_465_i1 finite_children_work_465_i1 (0, 4) + required_465_i1 envelope_465_i1 pivot_mem_465_i1 child_required_sub_465_i1 child_envelope_sub_465_i1 ?_ + intro b hb + exact common_sub_465_i1 (mem_commonEnvelope childrenD_465_i1 b hb) + +theorem finite_children_work_465_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_465_i0 j) (childrenD_465_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_39 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_42 0 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_465_i1.mono (by decide +kernel) + +theorem finite_row_works_465_i0 : FiniteTemplate HasSnaky 5 required_465_i0 envelope_465_i0 := by + refine finite_compose HasSnaky 4 childrenC_465_i0 childrenD_465_i0 finite_children_work_465_i0 (4, 5) + required_465_i0 envelope_465_i0 pivot_mem_465_i0 child_required_sub_465_i0 child_envelope_sub_465_i0 ?_ + intro b hb + exact common_sub_465_i0 (mem_commonEnvelope childrenD_465_i0 b hb) + +theorem finite_children_work_465 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_465 j) (childrenD_465 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_25 3 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_465_i0.mono (by decide +kernel) + +theorem finite_row_works_465 : FiniteTemplate HasSnaky 6 required_465 envelope_465 := by + refine finite_compose HasSnaky 5 childrenC_465 childrenD_465 finite_children_work_465 (3, 2) + required_465 envelope_465 pivot_mem_465 child_required_sub_465 child_envelope_sub_465 ?_ + intro b hb + exact common_sub_465 (mem_commonEnvelope childrenD_465 b hb) + +theorem finite_children_work_471_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_471_i0 j) (childrenD_471_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 2 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_354 5 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_471_i0 : FiniteTemplate HasSnaky 5 required_471_i0 envelope_471_i0 := by + refine finite_compose HasSnaky 4 childrenC_471_i0 childrenD_471_i0 finite_children_work_471_i0 (3, 4) + required_471_i0 envelope_471_i0 pivot_mem_471_i0 child_required_sub_471_i0 child_envelope_sub_471_i0 ?_ + intro b hb + exact common_sub_471_i0 (mem_commonEnvelope childrenD_471_i0 b hb) + +theorem finite_children_work_471 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_471 j) (childrenD_471 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_471_i0.mono (by decide +kernel) + +theorem finite_row_works_471 : FiniteTemplate HasSnaky 6 required_471 envelope_471 := by + refine finite_compose HasSnaky 5 childrenC_471 childrenD_471 finite_children_work_471 (3, 3) + required_471 envelope_471 pivot_mem_471 child_required_sub_471 child_envelope_sub_471 ?_ + intro b hb + exact common_sub_471 (mem_commonEnvelope childrenD_471 b hb) + +theorem finite_children_work_486_i2 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_486_i2 j) (childrenD_486_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_156 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_486_i2 : FiniteTemplate HasSnaky 3 required_486_i2 envelope_486_i2 := by + refine finite_compose HasSnaky 2 childrenC_486_i2 childrenD_486_i2 finite_children_work_486_i2 (1, 4) + required_486_i2 envelope_486_i2 pivot_mem_486_i2 child_required_sub_486_i2 child_envelope_sub_486_i2 ?_ + intro b hb + exact common_sub_486_i2 (mem_commonEnvelope childrenD_486_i2 b hb) + +theorem finite_children_work_486_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_486_i1 j) (childrenD_486_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_486_i2.mono (by decide +kernel) + +theorem finite_row_works_486_i1 : FiniteTemplate HasSnaky 4 required_486_i1 envelope_486_i1 := by + refine finite_compose HasSnaky 3 childrenC_486_i1 childrenD_486_i1 finite_children_work_486_i1 (4, 2) + required_486_i1 envelope_486_i1 pivot_mem_486_i1 child_required_sub_486_i1 child_envelope_sub_486_i1 ?_ + intro b hb + exact common_sub_486_i1 (mem_commonEnvelope childrenD_486_i1 b hb) + +theorem finite_children_work_486_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_486_i0 j) (childrenD_486_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_486_i1.mono (by decide +kernel) + +theorem finite_row_works_486_i0 : FiniteTemplate HasSnaky 5 required_486_i0 envelope_486_i0 := by + refine finite_compose HasSnaky 4 childrenC_486_i0 childrenD_486_i0 finite_children_work_486_i0 (1, 2) + required_486_i0 envelope_486_i0 pivot_mem_486_i0 child_required_sub_486_i0 child_envelope_sub_486_i0 ?_ + intro b hb + exact common_sub_486_i0 (mem_commonEnvelope childrenD_486_i0 b hb) + +theorem finite_children_work_486 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_486 j) (childrenD_486 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_84 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_486_i0.mono (by decide +kernel) + +theorem finite_row_works_486 : FiniteTemplate HasSnaky 6 required_486 envelope_486 := by + refine finite_compose HasSnaky 5 childrenC_486 childrenD_486 finite_children_work_486 (4, 3) + required_486 envelope_486 pivot_mem_486 child_required_sub_486 child_envelope_sub_486 ?_ + intro b hb + exact common_sub_486 (mem_commonEnvelope childrenD_486 b hb) + +theorem finite_children_work_493 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_493 j) (childrenD_493 j) := by + intro j + fin_cases j + · exact finite_row_works_87.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 5 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_492.mono (by decide +kernel) + +theorem finite_row_works_493 : FiniteTemplate HasSnaky 6 required_493 envelope_493 := by + refine finite_compose HasSnaky 5 childrenC_493 childrenD_493 finite_children_work_493 (3, 3) + required_493 envelope_493 pivot_mem_493 child_required_sub_493 child_envelope_sub_493 ?_ + intro b hb + exact common_sub_493 (mem_commonEnvelope childrenD_493 b hb) + +theorem finite_children_work_498 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_498 j) (childrenD_498 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_114 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_496 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_498 : FiniteTemplate HasSnaky 6 required_498 envelope_498 := by + refine finite_compose HasSnaky 5 childrenC_498 childrenD_498 finite_children_work_498 (4, 3) + required_498 envelope_498 pivot_mem_498 child_required_sub_498 child_envelope_sub_498 ?_ + intro b hb + exact common_sub_498 (mem_commonEnvelope childrenD_498 b hb) + +theorem finite_children_work_503 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_503 j) (childrenD_503 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 4 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_502.mono (by decide +kernel) + +theorem finite_row_works_503 : FiniteTemplate HasSnaky 6 required_503 envelope_503 := by + refine finite_compose HasSnaky 5 childrenC_503 childrenD_503 finite_children_work_503 (2, 3) + required_503 envelope_503 pivot_mem_503 child_required_sub_503 child_envelope_sub_503 ?_ + intro b hb + exact common_sub_503 (mem_commonEnvelope childrenD_503 b hb) + +theorem finite_children_work_516_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_516_i0 j) (childrenD_516_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 6 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_83 6 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_516_i0 : FiniteTemplate HasSnaky 3 required_516_i0 envelope_516_i0 := by + refine finite_compose HasSnaky 2 childrenC_516_i0 childrenD_516_i0 finite_children_work_516_i0 (2, 3) + required_516_i0 envelope_516_i0 pivot_mem_516_i0 child_required_sub_516_i0 child_envelope_sub_516_i0 ?_ + intro b hb + exact common_sub_516_i0 (mem_commonEnvelope childrenD_516_i0 b hb) + +theorem finite_children_work_516 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_516 j) (childrenD_516 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 0 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_516_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_515 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_516 : FiniteTemplate HasSnaky 6 required_516 envelope_516 := by + refine finite_compose HasSnaky 5 childrenC_516 childrenD_516 finite_children_work_516 (4, 3) + required_516 envelope_516 pivot_mem_516 child_required_sub_516 child_envelope_sub_516 ?_ + intro b hb + exact common_sub_516 (mem_commonEnvelope childrenD_516 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height06Part06.lean b/lean/snaky/FiniteCards/Height06Part06.lean new file mode 100644 index 0000000..d537645 --- /dev/null +++ b/lean/snaky/FiniteCards/Height06Part06.lean @@ -0,0 +1,289 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_521_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_521_i1 j) (childrenD_521_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_45 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_45 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_521_i1 : FiniteTemplate HasSnaky 4 required_521_i1 envelope_521_i1 := by + refine finite_compose HasSnaky 3 childrenC_521_i1 childrenD_521_i1 finite_children_work_521_i1 (2, 3) + required_521_i1 envelope_521_i1 pivot_mem_521_i1 child_required_sub_521_i1 child_envelope_sub_521_i1 ?_ + intro b hb + exact common_sub_521_i1 (mem_commonEnvelope childrenD_521_i1 b hb) + +theorem finite_children_work_521_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_521_i0 j) (childrenD_521_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_521_i1.mono (by decide +kernel) + +theorem finite_row_works_521_i0 : FiniteTemplate HasSnaky 5 required_521_i0 envelope_521_i0 := by + refine finite_compose HasSnaky 4 childrenC_521_i0 childrenD_521_i0 finite_children_work_521_i0 (2, 4) + required_521_i0 envelope_521_i0 pivot_mem_521_i0 child_required_sub_521_i0 child_envelope_sub_521_i0 ?_ + intro b hb + exact common_sub_521_i0 (mem_commonEnvelope childrenD_521_i0 b hb) + +theorem finite_children_work_521 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_521 j) (childrenD_521 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_521_i0.mono (by decide +kernel) + +theorem finite_row_works_521 : FiniteTemplate HasSnaky 6 required_521 envelope_521 := by + refine finite_compose HasSnaky 5 childrenC_521 childrenD_521 finite_children_work_521 (2, 1) + required_521 envelope_521 pivot_mem_521 child_required_sub_521 child_envelope_sub_521 ?_ + intro b hb + exact common_sub_521 (mem_commonEnvelope childrenD_521 b hb) + +theorem finite_children_work_525_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_525_i1 j) (childrenD_525_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 2 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_37 0 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 5 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_525_i1 : FiniteTemplate HasSnaky 4 required_525_i1 envelope_525_i1 := by + refine finite_compose HasSnaky 3 childrenC_525_i1 childrenD_525_i1 finite_children_work_525_i1 (3, 3) + required_525_i1 envelope_525_i1 pivot_mem_525_i1 child_required_sub_525_i1 child_envelope_sub_525_i1 ?_ + intro b hb + exact common_sub_525_i1 (mem_commonEnvelope childrenD_525_i1 b hb) + +theorem finite_children_work_525_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_525_i0 j) (childrenD_525_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_525_i1.mono (by decide +kernel) + +theorem finite_row_works_525_i0 : FiniteTemplate HasSnaky 5 required_525_i0 envelope_525_i0 := by + refine finite_compose HasSnaky 4 childrenC_525_i0 childrenD_525_i0 finite_children_work_525_i0 (3, 2) + required_525_i0 envelope_525_i0 pivot_mem_525_i0 child_required_sub_525_i0 child_envelope_sub_525_i0 ?_ + intro b hb + exact common_sub_525_i0 (mem_commonEnvelope childrenD_525_i0 b hb) + +theorem finite_children_work_525 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_525 j) (childrenD_525 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_525_i0.mono (by decide +kernel) + +theorem finite_row_works_525 : FiniteTemplate HasSnaky 6 required_525 envelope_525 := by + refine finite_compose HasSnaky 5 childrenC_525 childrenD_525 finite_children_work_525 (3, 0) + required_525 envelope_525 pivot_mem_525 child_required_sub_525 child_envelope_sub_525 ?_ + intro b hb + exact common_sub_525 (mem_commonEnvelope childrenD_525 b hb) + +theorem finite_children_work_544_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_544_i1 j) (childrenD_544_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_62 7 (6, 4)).mono (by decide +kernel) + +theorem finite_row_works_544_i1 : FiniteTemplate HasSnaky 4 required_544_i1 envelope_544_i1 := by + refine finite_compose HasSnaky 3 childrenC_544_i1 childrenD_544_i1 finite_children_work_544_i1 (5, 3) + required_544_i1 envelope_544_i1 pivot_mem_544_i1 child_required_sub_544_i1 child_envelope_sub_544_i1 ?_ + intro b hb + exact common_sub_544_i1 (mem_commonEnvelope childrenD_544_i1 b hb) + +theorem finite_children_work_544_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_544_i0 j) (childrenD_544_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 5 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_259 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_544_i1.mono (by decide +kernel) + +theorem finite_row_works_544_i0 : FiniteTemplate HasSnaky 5 required_544_i0 envelope_544_i0 := by + refine finite_compose HasSnaky 4 childrenC_544_i0 childrenD_544_i0 finite_children_work_544_i0 (4, 3) + required_544_i0 envelope_544_i0 pivot_mem_544_i0 child_required_sub_544_i0 child_envelope_sub_544_i0 ?_ + intro b hb + exact common_sub_544_i0 (mem_commonEnvelope childrenD_544_i0 b hb) + +theorem finite_children_work_544 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_544 j) (childrenD_544 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_23 4 (2, 5)).mono (by decide +kernel) + · exact finite_row_works_544_i0.mono (by decide +kernel) + +theorem finite_row_works_544 : FiniteTemplate HasSnaky 6 required_544 envelope_544 := by + refine finite_compose HasSnaky 5 childrenC_544 childrenD_544 finite_children_work_544 (3, 4) + required_544 envelope_544 pivot_mem_544 child_required_sub_544 child_envelope_sub_544 ?_ + intro b hb + exact common_sub_544 (mem_commonEnvelope childrenD_544 b hb) + +theorem finite_children_work_600_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_600_i0 j) (childrenD_600_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_20 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_55 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_600_i0 : FiniteTemplate HasSnaky 5 required_600_i0 envelope_600_i0 := by + refine finite_compose HasSnaky 4 childrenC_600_i0 childrenD_600_i0 finite_children_work_600_i0 (3, 5) + required_600_i0 envelope_600_i0 pivot_mem_600_i0 child_required_sub_600_i0 child_envelope_sub_600_i0 ?_ + intro b hb + exact common_sub_600_i0 (mem_commonEnvelope childrenD_600_i0 b hb) + +theorem finite_children_work_600 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_600 j) (childrenD_600 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_23 6 (3, 5)).mono (by decide +kernel) + · exact finite_row_works_600_i0.mono (by decide +kernel) + +theorem finite_row_works_600 : FiniteTemplate HasSnaky 6 required_600 envelope_600 := by + refine finite_compose HasSnaky 5 childrenC_600 childrenD_600 finite_children_work_600 (3, 2) + required_600 envelope_600 pivot_mem_600 child_required_sub_600 child_envelope_sub_600 ?_ + intro b hb + exact common_sub_600 (mem_commonEnvelope childrenD_600 b hb) + +theorem finite_children_work_606_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_606_i0 j) (childrenD_606_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_240 2 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_606_i0 : FiniteTemplate HasSnaky 5 required_606_i0 envelope_606_i0 := by + refine finite_compose HasSnaky 4 childrenC_606_i0 childrenD_606_i0 finite_children_work_606_i0 (3, 4) + required_606_i0 envelope_606_i0 pivot_mem_606_i0 child_required_sub_606_i0 child_envelope_sub_606_i0 ?_ + intro b hb + exact common_sub_606_i0 (mem_commonEnvelope childrenD_606_i0 b hb) + +theorem finite_children_work_606 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_606 j) (childrenD_606 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_28 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_168 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_606_i0.mono (by decide +kernel) + +theorem finite_row_works_606 : FiniteTemplate HasSnaky 6 required_606 envelope_606 := by + refine finite_compose HasSnaky 5 childrenC_606 childrenD_606 finite_children_work_606 (3, 3) + required_606 envelope_606 pivot_mem_606 child_required_sub_606 child_envelope_sub_606 ?_ + intro b hb + exact common_sub_606 (mem_commonEnvelope childrenD_606 b hb) + +theorem finite_children_work_609_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_609_i0 j) (childrenD_609_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_48 3 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_609_i0 : FiniteTemplate HasSnaky 5 required_609_i0 envelope_609_i0 := by + refine finite_compose HasSnaky 4 childrenC_609_i0 childrenD_609_i0 finite_children_work_609_i0 (2, 1) + required_609_i0 envelope_609_i0 pivot_mem_609_i0 child_required_sub_609_i0 child_envelope_sub_609_i0 ?_ + intro b hb + exact common_sub_609_i0 (mem_commonEnvelope childrenD_609_i0 b hb) + +theorem finite_children_work_609_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_609_i1 j) (childrenD_609_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_25 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_54 0 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_609_i1 : FiniteTemplate HasSnaky 4 required_609_i1 envelope_609_i1 := by + refine finite_compose HasSnaky 3 childrenC_609_i1 childrenD_609_i1 finite_children_work_609_i1 (3, 3) + required_609_i1 envelope_609_i1 pivot_mem_609_i1 child_required_sub_609_i1 child_envelope_sub_609_i1 ?_ + intro b hb + exact common_sub_609_i1 (mem_commonEnvelope childrenD_609_i1 b hb) + +theorem finite_children_work_609 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_609 j) (childrenD_609 j) := by + intro j + fin_cases j + · exact finite_row_works_609_i0.mono (by decide +kernel) + · exact finite_row_works_609_i1.mono (by decide +kernel) + +theorem finite_row_works_609 : FiniteTemplate HasSnaky 6 required_609 envelope_609 := by + refine finite_compose HasSnaky 5 childrenC_609 childrenD_609 finite_children_work_609 (3, 1) + required_609 envelope_609 pivot_mem_609 child_required_sub_609 child_envelope_sub_609 ?_ + intro b hb + exact common_sub_609 (mem_commonEnvelope childrenD_609 b hb) + +theorem finite_children_work_611_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_611_i0 j) (childrenD_611_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 0 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_93 3 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_611_i0 : FiniteTemplate HasSnaky 5 required_611_i0 envelope_611_i0 := by + refine finite_compose HasSnaky 4 childrenC_611_i0 childrenD_611_i0 finite_children_work_611_i0 (2, 3) + required_611_i0 envelope_611_i0 pivot_mem_611_i0 child_required_sub_611_i0 child_envelope_sub_611_i0 ?_ + intro b hb + exact common_sub_611_i0 (mem_commonEnvelope childrenD_611_i0 b hb) + +theorem finite_children_work_611 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_611 j) (childrenD_611 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_27 2 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_47 3 (0, 7)).mono (by decide +kernel) + · exact finite_row_works_611_i0.mono (by decide +kernel) + +theorem finite_row_works_611 : FiniteTemplate HasSnaky 6 required_611 envelope_611 := by + refine finite_compose HasSnaky 5 childrenC_611 childrenD_611 finite_children_work_611 (2, 5) + required_611 envelope_611 pivot_mem_611 child_required_sub_611 child_envelope_sub_611 ?_ + intro b hb + exact common_sub_611 (mem_commonEnvelope childrenD_611 b hb) + +theorem finite_children_work_641_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_641_i0 j) (childrenD_641_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 0 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_60 2 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_641_i0 : FiniteTemplate HasSnaky 5 required_641_i0 envelope_641_i0 := by + refine finite_compose HasSnaky 4 childrenC_641_i0 childrenD_641_i0 finite_children_work_641_i0 (3, 4) + required_641_i0 envelope_641_i0 pivot_mem_641_i0 child_required_sub_641_i0 child_envelope_sub_641_i0 ?_ + intro b hb + exact common_sub_641_i0 (mem_commonEnvelope childrenD_641_i0 b hb) + +theorem finite_children_work_641 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_641 j) (childrenD_641 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_144 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_641_i0.mono (by decide +kernel) + +theorem finite_row_works_641 : FiniteTemplate HasSnaky 6 required_641 envelope_641 := by + refine finite_compose HasSnaky 5 childrenC_641 childrenD_641 finite_children_work_641 (2, 3) + required_641 envelope_641 pivot_mem_641 child_required_sub_641 child_envelope_sub_641 ?_ + intro b hb + exact common_sub_641 (mem_commonEnvelope childrenD_641 b hb) + +theorem finite_children_work_714_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_714_i0 j) (childrenD_714_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_41 0 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_55 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_714_i0 : FiniteTemplate HasSnaky 5 required_714_i0 envelope_714_i0 := by + refine finite_compose HasSnaky 4 childrenC_714_i0 childrenD_714_i0 finite_children_work_714_i0 (3, 6) + required_714_i0 envelope_714_i0 pivot_mem_714_i0 child_required_sub_714_i0 child_envelope_sub_714_i0 ?_ + intro b hb + exact common_sub_714_i0 (mem_commonEnvelope childrenD_714_i0 b hb) + +theorem finite_children_work_714 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_714 j) (childrenD_714 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 2 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_88 3 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_714_i0.mono (by decide +kernel) + +theorem finite_row_works_714 : FiniteTemplate HasSnaky 6 required_714 envelope_714 := by + refine finite_compose HasSnaky 5 childrenC_714 childrenD_714 finite_children_work_714 (3, 3) + required_714 envelope_714 pivot_mem_714 child_required_sub_714 child_envelope_sub_714 ?_ + intro b hb + exact common_sub_714 (mem_commonEnvelope childrenD_714 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height07Part01.lean b/lean/snaky/FiniteCards/Height07Part01.lean new file mode 100644 index 0000000..467c9ac --- /dev/null +++ b/lean/snaky/FiniteCards/Height07Part01.lean @@ -0,0 +1,316 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_116 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_116 j) (childrenD_116 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_115 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_116 : FiniteTemplate HasSnaky 7 required_116 envelope_116 := by + refine finite_compose HasSnaky 6 childrenC_116 childrenD_116 finite_children_work_116 (4, 3) + required_116 envelope_116 pivot_mem_116 child_required_sub_116 child_envelope_sub_116 ?_ + intro b hb + exact common_sub_116 (mem_commonEnvelope childrenD_116 b hb) + +theorem finite_children_work_117 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_117 j) (childrenD_117 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_115 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_117 : FiniteTemplate HasSnaky 7 required_117 envelope_117 := by + refine finite_compose HasSnaky 6 childrenC_117 childrenD_117 finite_children_work_117 (4, 3) + required_117 envelope_117 pivot_mem_117 child_required_sub_117 child_envelope_sub_117 ?_ + intro b hb + exact common_sub_117 (mem_commonEnvelope childrenD_117 b hb) + +theorem finite_children_work_118 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_118 j) (childrenD_118 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_115 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_118 : FiniteTemplate HasSnaky 7 required_118 envelope_118 := by + refine finite_compose HasSnaky 6 childrenC_118 childrenD_118 finite_children_work_118 (4, 3) + required_118 envelope_118 pivot_mem_118 child_required_sub_118 child_envelope_sub_118 ?_ + intro b hb + exact common_sub_118 (mem_commonEnvelope childrenD_118 b hb) + +theorem finite_children_work_204 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_204 j) (childrenD_204 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_203 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_204 : FiniteTemplate HasSnaky 7 required_204 envelope_204 := by + refine finite_compose HasSnaky 6 childrenC_204 childrenD_204 finite_children_work_204 (2, 3) + required_204 envelope_204 pivot_mem_204 child_required_sub_204 child_envelope_sub_204 ?_ + intro b hb + exact common_sub_204 (mem_commonEnvelope childrenD_204 b hb) + +theorem finite_children_work_256 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_256 j) (childrenD_256 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_255.mono (by decide +kernel) + +theorem finite_row_works_256 : FiniteTemplate HasSnaky 7 required_256 envelope_256 := by + refine finite_compose HasSnaky 6 childrenC_256 childrenD_256 finite_children_work_256 (3, 4) + required_256 envelope_256 pivot_mem_256 child_required_sub_256 child_envelope_sub_256 ?_ + intro b hb + exact common_sub_256 (mem_commonEnvelope childrenD_256 b hb) + +theorem finite_children_work_276 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_276 j) (childrenD_276 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_155 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_275 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_276 : FiniteTemplate HasSnaky 7 required_276 envelope_276 := by + refine finite_compose HasSnaky 6 childrenC_276 childrenD_276 finite_children_work_276 (2, 4) + required_276 envelope_276 pivot_mem_276 child_required_sub_276 child_envelope_sub_276 ?_ + intro b hb + exact common_sub_276 (mem_commonEnvelope childrenD_276 b hb) + +theorem finite_children_work_286 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_286 j) (childrenD_286 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_35 7 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_253 5 (6, 1)).mono (by decide +kernel) + +theorem finite_row_works_286 : FiniteTemplate HasSnaky 7 required_286 envelope_286 := by + refine finite_compose HasSnaky 6 childrenC_286 childrenD_286 finite_children_work_286 (4, 2) + required_286 envelope_286 pivot_mem_286 child_required_sub_286 child_envelope_sub_286 ?_ + intro b hb + exact common_sub_286 (mem_commonEnvelope childrenD_286 b hb) + +theorem finite_children_work_290 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_290 j) (childrenD_290 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_203.mono (by decide +kernel) + +theorem finite_row_works_290 : FiniteTemplate HasSnaky 7 required_290 envelope_290 := by + refine finite_compose HasSnaky 6 childrenC_290 childrenD_290 finite_children_work_290 (2, 1) + required_290 envelope_290 pivot_mem_290 child_required_sub_290 child_envelope_sub_290 ?_ + intro b hb + exact common_sub_290 (mem_commonEnvelope childrenD_290 b hb) + +theorem finite_children_work_295 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_295 j) (childrenD_295 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_34 5 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 5 (6, 0)).mono (by decide +kernel) + +theorem finite_row_works_295 : FiniteTemplate HasSnaky 7 required_295 envelope_295 := by + refine finite_compose HasSnaky 6 childrenC_295 childrenD_295 finite_children_work_295 (3, 1) + required_295 envelope_295 pivot_mem_295 child_required_sub_295 child_envelope_sub_295 ?_ + intro b hb + exact common_sub_295 (mem_commonEnvelope childrenD_295 b hb) + +theorem finite_children_work_297 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_297 j) (childrenD_297 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 7 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_142 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_162 4 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_297 : FiniteTemplate HasSnaky 7 required_297 envelope_297 := by + refine finite_compose HasSnaky 6 childrenC_297 childrenD_297 finite_children_work_297 (5, 3) + required_297 envelope_297 pivot_mem_297 child_required_sub_297 child_envelope_sub_297 ?_ + intro b hb + exact common_sub_297 (mem_commonEnvelope childrenD_297 b hb) + +theorem finite_children_work_298 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_298 j) (childrenD_298 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 7 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_142 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_161 4 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_298 : FiniteTemplate HasSnaky 7 required_298 envelope_298 := by + refine finite_compose HasSnaky 6 childrenC_298 childrenD_298 finite_children_work_298 (5, 3) + required_298 envelope_298 pivot_mem_298 child_required_sub_298 child_envelope_sub_298 ?_ + intro b hb + exact common_sub_298 (mem_commonEnvelope childrenD_298 b hb) + +theorem finite_children_work_309 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_309 j) (childrenD_309 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_19 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_115 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_309 : FiniteTemplate HasSnaky 7 required_309 envelope_309 := by + refine finite_compose HasSnaky 6 childrenC_309 childrenD_309 finite_children_work_309 (4, 3) + required_309 envelope_309 pivot_mem_309 child_required_sub_309 child_envelope_sub_309 ?_ + intro b hb + exact common_sub_309 (mem_commonEnvelope childrenD_309 b hb) + +theorem finite_children_work_317 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_317 j) (childrenD_317 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_60 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_316 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_317 : FiniteTemplate HasSnaky 7 required_317 envelope_317 := by + refine finite_compose HasSnaky 6 childrenC_317 childrenD_317 finite_children_work_317 (3, 5) + required_317 envelope_317 pivot_mem_317 child_required_sub_317 child_envelope_sub_317 ?_ + intro b hb + exact common_sub_317 (mem_commonEnvelope childrenD_317 b hb) + +theorem finite_children_work_318 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_318 j) (childrenD_318 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_315 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_318 : FiniteTemplate HasSnaky 7 required_318 envelope_318 := by + refine finite_compose HasSnaky 6 childrenC_318 childrenD_318 finite_children_work_318 (1, 3) + required_318 envelope_318 pivot_mem_318 child_required_sub_318 child_envelope_sub_318 ?_ + intro b hb + exact common_sub_318 (mem_commonEnvelope childrenD_318 b hb) + +theorem finite_children_work_320 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_320 j) (childrenD_320 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_316 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_320 : FiniteTemplate HasSnaky 7 required_320 envelope_320 := by + refine finite_compose HasSnaky 6 childrenC_320 childrenD_320 finite_children_work_320 (3, 5) + required_320 envelope_320 pivot_mem_320 child_required_sub_320 child_envelope_sub_320 ?_ + intro b hb + exact common_sub_320 (mem_commonEnvelope childrenD_320 b hb) + +theorem finite_children_work_324 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_324 j) (childrenD_324 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_60 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_237 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_307 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_316 2 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_324 : FiniteTemplate HasSnaky 7 required_324 envelope_324 := by + refine finite_compose HasSnaky 6 childrenC_324 childrenD_324 finite_children_work_324 (1, 3) + required_324 envelope_324 pivot_mem_324 child_required_sub_324 child_envelope_sub_324 ?_ + intro b hb + exact common_sub_324 (mem_commonEnvelope childrenD_324 b hb) + +theorem finite_children_work_329 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_329 j) (childrenD_329 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_315 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_329 : FiniteTemplate HasSnaky 7 required_329 envelope_329 := by + refine finite_compose HasSnaky 6 childrenC_329 childrenD_329 finite_children_work_329 (1, 4) + required_329 envelope_329 pivot_mem_329 child_required_sub_329 child_envelope_sub_329 ?_ + intro b hb + exact common_sub_329 (mem_commonEnvelope childrenD_329 b hb) + +theorem finite_children_work_332 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_332 j) (childrenD_332 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_331 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_332 : FiniteTemplate HasSnaky 7 required_332 envelope_332 := by + refine finite_compose HasSnaky 6 childrenC_332 childrenD_332 finite_children_work_332 (4, 3) + required_332 envelope_332 pivot_mem_332 child_required_sub_332 child_envelope_sub_332 ?_ + intro b hb + exact common_sub_332 (mem_commonEnvelope childrenD_332 b hb) + +theorem finite_children_work_337 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_337 j) (childrenD_337 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_143 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_336 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_337 : FiniteTemplate HasSnaky 7 required_337 envelope_337 := by + refine finite_compose HasSnaky 6 childrenC_337 childrenD_337 finite_children_work_337 (1, 2) + required_337 envelope_337 pivot_mem_337 child_required_sub_337 child_envelope_sub_337 ?_ + intro b hb + exact common_sub_337 (mem_commonEnvelope childrenD_337 b hb) + +theorem finite_children_work_339 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_339 j) (childrenD_339 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_35 7 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_336 2 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_339 : FiniteTemplate HasSnaky 7 required_339 envelope_339 := by + refine finite_compose HasSnaky 6 childrenC_339 childrenD_339 finite_children_work_339 (4, 2) + required_339 envelope_339 pivot_mem_339 child_required_sub_339 child_envelope_sub_339 ?_ + intro b hb + exact common_sub_339 (mem_commonEnvelope childrenD_339 b hb) + +theorem finite_children_work_341 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_341 j) (childrenD_341 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 7 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_57 5 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_340 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_341 : FiniteTemplate HasSnaky 7 required_341 envelope_341 := by + refine finite_compose HasSnaky 6 childrenC_341 childrenD_341 finite_children_work_341 (4, 4) + required_341 envelope_341 pivot_mem_341 child_required_sub_341 child_envelope_sub_341 ?_ + intro b hb + exact common_sub_341 (mem_commonEnvelope childrenD_341 b hb) + +theorem finite_children_work_344 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_344 j) (childrenD_344 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_343 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_344 : FiniteTemplate HasSnaky 7 required_344 envelope_344 := by + refine finite_compose HasSnaky 6 childrenC_344 childrenD_344 finite_children_work_344 (1, 3) + required_344 envelope_344 pivot_mem_344 child_required_sub_344 child_envelope_sub_344 ?_ + intro b hb + exact common_sub_344 (mem_commonEnvelope childrenD_344 b hb) + +theorem finite_children_work_353 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_353 j) (childrenD_353 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_95 6 (5, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_352 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_353 : FiniteTemplate HasSnaky 7 required_353 envelope_353 := by + refine finite_compose HasSnaky 6 childrenC_353 childrenD_353 finite_children_work_353 (4, 6) + required_353 envelope_353 pivot_mem_353 child_required_sub_353 child_envelope_sub_353 ?_ + intro b hb + exact common_sub_353 (mem_commonEnvelope childrenD_353 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height07Part02.lean b/lean/snaky/FiniteCards/Height07Part02.lean new file mode 100644 index 0000000..6208068 --- /dev/null +++ b/lean/snaky/FiniteCards/Height07Part02.lean @@ -0,0 +1,313 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_361 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_361 j) (childrenD_361 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 2 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_57 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_360 1 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_361 : FiniteTemplate HasSnaky 7 required_361 envelope_361 := by + refine finite_compose HasSnaky 6 childrenC_361 childrenD_361 finite_children_work_361 (3, 1) + required_361 envelope_361 pivot_mem_361 child_required_sub_361 child_envelope_sub_361 ?_ + intro b hb + exact common_sub_361 (mem_commonEnvelope childrenD_361 b hb) + +theorem finite_children_work_372_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_372_i0 j) (childrenD_372_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_81 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_351 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_372_i0 : FiniteTemplate HasSnaky 6 required_372_i0 envelope_372_i0 := by + refine finite_compose HasSnaky 5 childrenC_372_i0 childrenD_372_i0 finite_children_work_372_i0 (4, 4) + required_372_i0 envelope_372_i0 pivot_mem_372_i0 child_required_sub_372_i0 child_envelope_sub_372_i0 ?_ + intro b hb + exact common_sub_372_i0 (mem_commonEnvelope childrenD_372_i0 b hb) + +theorem finite_children_work_372 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_372 j) (childrenD_372 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_96 3 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_372_i0.mono (by decide +kernel) + +theorem finite_row_works_372 : FiniteTemplate HasSnaky 7 required_372 envelope_372 := by + refine finite_compose HasSnaky 6 childrenC_372 childrenD_372 finite_children_work_372 (4, 2) + required_372 envelope_372 pivot_mem_372 child_required_sub_372 child_envelope_sub_372 ?_ + intro b hb + exact common_sub_372 (mem_commonEnvelope childrenD_372 b hb) + +theorem finite_children_work_379 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_379 j) (childrenD_379 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 3 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_37 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_378.mono (by decide +kernel) + +theorem finite_row_works_379 : FiniteTemplate HasSnaky 7 required_379 envelope_379 := by + refine finite_compose HasSnaky 6 childrenC_379 childrenD_379 finite_children_work_379 (3, 2) + required_379 envelope_379 pivot_mem_379 child_required_sub_379 child_envelope_sub_379 ?_ + intro b hb + exact common_sub_379 (mem_commonEnvelope childrenD_379 b hb) + +theorem finite_children_work_385 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_385 j) (childrenD_385 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_115 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_383 7 (5, 4)).mono (by decide +kernel) + +theorem finite_row_works_385 : FiniteTemplate HasSnaky 7 required_385 envelope_385 := by + refine finite_compose HasSnaky 6 childrenC_385 childrenD_385 finite_children_work_385 (3, 3) + required_385 envelope_385 pivot_mem_385 child_required_sub_385 child_envelope_sub_385 ?_ + intro b hb + exact common_sub_385 (mem_commonEnvelope childrenD_385 b hb) + +theorem finite_children_work_388 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_388 j) (childrenD_388 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 2 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_387 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_388 : FiniteTemplate HasSnaky 7 required_388 envelope_388 := by + refine finite_compose HasSnaky 6 childrenC_388 childrenD_388 finite_children_work_388 (2, 4) + required_388 envelope_388 pivot_mem_388 child_required_sub_388 child_envelope_sub_388 ?_ + intro b hb + exact common_sub_388 (mem_commonEnvelope childrenD_388 b hb) + +theorem finite_children_work_394 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_394 j) (childrenD_394 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_17 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_241.mono (by decide +kernel) + · exact finite_row_works_392.mono (by decide +kernel) + +theorem finite_row_works_394 : FiniteTemplate HasSnaky 7 required_394 envelope_394 := by + refine finite_compose HasSnaky 6 childrenC_394 childrenD_394 finite_children_work_394 (1, 4) + required_394 envelope_394 pivot_mem_394 child_required_sub_394 child_envelope_sub_394 ?_ + intro b hb + exact common_sub_394 (mem_commonEnvelope childrenD_394 b hb) + +theorem finite_children_work_404_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_404_i1 j) (childrenD_404_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_354.mono (by decide +kernel) + +theorem finite_row_works_404_i1 : FiniteTemplate HasSnaky 5 required_404_i1 envelope_404_i1 := by + refine finite_compose HasSnaky 4 childrenC_404_i1 childrenD_404_i1 finite_children_work_404_i1 (3, 1) + required_404_i1 envelope_404_i1 pivot_mem_404_i1 child_required_sub_404_i1 child_envelope_sub_404_i1 ?_ + intro b hb + exact common_sub_404_i1 (mem_commonEnvelope childrenD_404_i1 b hb) + +theorem finite_children_work_404_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_404_i0 j) (childrenD_404_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_404_i1.mono (by decide +kernel) + +theorem finite_row_works_404_i0 : FiniteTemplate HasSnaky 6 required_404_i0 envelope_404_i0 := by + refine finite_compose HasSnaky 5 childrenC_404_i0 childrenD_404_i0 finite_children_work_404_i0 (2, 1) + required_404_i0 envelope_404_i0 pivot_mem_404_i0 child_required_sub_404_i0 child_envelope_sub_404_i0 ?_ + intro b hb + exact common_sub_404_i0 (mem_commonEnvelope childrenD_404_i0 b hb) + +theorem finite_children_work_404 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_404 j) (childrenD_404 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_404_i0.mono (by decide +kernel) + +theorem finite_row_works_404 : FiniteTemplate HasSnaky 7 required_404 envelope_404 := by + refine finite_compose HasSnaky 6 childrenC_404 childrenD_404 finite_children_work_404 (2, 4) + required_404 envelope_404 pivot_mem_404 child_required_sub_404 child_envelope_sub_404 ?_ + intro b hb + exact common_sub_404 (mem_commonEnvelope childrenD_404 b hb) + +theorem finite_children_work_415 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_415 j) (childrenD_415 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_414 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_415 : FiniteTemplate HasSnaky 7 required_415 envelope_415 := by + refine finite_compose HasSnaky 6 childrenC_415 childrenD_415 finite_children_work_415 (3, 2) + required_415 envelope_415 pivot_mem_415 child_required_sub_415 child_envelope_sub_415 ?_ + intro b hb + exact common_sub_415 (mem_commonEnvelope childrenD_415 b hb) + +theorem finite_children_work_418_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_418_i2 j) (childrenD_418_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_29 2 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_418_i2 : FiniteTemplate HasSnaky 4 required_418_i2 envelope_418_i2 := by + refine finite_compose HasSnaky 3 childrenC_418_i2 childrenD_418_i2 finite_children_work_418_i2 (2, 2) + required_418_i2 envelope_418_i2 pivot_mem_418_i2 child_required_sub_418_i2 child_envelope_sub_418_i2 ?_ + intro b hb + exact common_sub_418_i2 (mem_commonEnvelope childrenD_418_i2 b hb) + +theorem finite_children_work_418_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_418_i1 j) (childrenD_418_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_25 5 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_41 0 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_418_i2.mono (by decide +kernel) + +theorem finite_row_works_418_i1 : FiniteTemplate HasSnaky 5 required_418_i1 envelope_418_i1 := by + refine finite_compose HasSnaky 4 childrenC_418_i1 childrenD_418_i1 finite_children_work_418_i1 (3, 3) + required_418_i1 envelope_418_i1 pivot_mem_418_i1 child_required_sub_418_i1 child_envelope_sub_418_i1 ?_ + intro b hb + exact common_sub_418_i1 (mem_commonEnvelope childrenD_418_i1 b hb) + +theorem finite_children_work_418_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_418_i0 j) (childrenD_418_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_418_i1.mono (by decide +kernel) + +theorem finite_row_works_418_i0 : FiniteTemplate HasSnaky 6 required_418_i0 envelope_418_i0 := by + refine finite_compose HasSnaky 5 childrenC_418_i0 childrenD_418_i0 finite_children_work_418_i0 (3, 2) + required_418_i0 envelope_418_i0 pivot_mem_418_i0 child_required_sub_418_i0 child_envelope_sub_418_i0 ?_ + intro b hb + exact common_sub_418_i0 (mem_commonEnvelope childrenD_418_i0 b hb) + +theorem finite_children_work_418 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_418 j) (childrenD_418 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_418_i0.mono (by decide +kernel) + +theorem finite_row_works_418 : FiniteTemplate HasSnaky 7 required_418 envelope_418 := by + refine finite_compose HasSnaky 6 childrenC_418 childrenD_418 finite_children_work_418 (3, 0) + required_418 envelope_418 pivot_mem_418 child_required_sub_418 child_envelope_sub_418 ?_ + intro b hb + exact common_sub_418 (mem_commonEnvelope childrenD_418 b hb) + +theorem finite_children_work_422_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_422_i0 j) (childrenD_422_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_69 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_413 5 (5, 1)).mono (by decide +kernel) + +theorem finite_row_works_422_i0 : FiniteTemplate HasSnaky 6 required_422_i0 envelope_422_i0 := by + refine finite_compose HasSnaky 5 childrenC_422_i0 childrenD_422_i0 finite_children_work_422_i0 (4, 2) + required_422_i0 envelope_422_i0 pivot_mem_422_i0 child_required_sub_422_i0 child_envelope_sub_422_i0 ?_ + intro b hb + exact common_sub_422_i0 (mem_commonEnvelope childrenD_422_i0 b hb) + +theorem finite_children_work_422 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_422 j) (childrenD_422 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_422_i0.mono (by decide +kernel) + +theorem finite_row_works_422 : FiniteTemplate HasSnaky 7 required_422 envelope_422 := by + refine finite_compose HasSnaky 6 childrenC_422 childrenD_422 finite_children_work_422 (2, 2) + required_422 envelope_422 pivot_mem_422 child_required_sub_422 child_envelope_sub_422 ?_ + intro b hb + exact common_sub_422 (mem_commonEnvelope childrenD_422 b hb) + +theorem finite_children_work_430 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_430 j) (childrenD_430 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_31 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_58 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_100 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_429 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_430 : FiniteTemplate HasSnaky 7 required_430 envelope_430 := by + refine finite_compose HasSnaky 6 childrenC_430 childrenD_430 finite_children_work_430 (3, 5) + required_430 envelope_430 pivot_mem_430 child_required_sub_430 child_envelope_sub_430 ?_ + intro b hb + exact common_sub_430 (mem_commonEnvelope childrenD_430 b hb) + +theorem finite_children_work_431 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_431 j) (childrenD_431 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_160 7 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_243 2 (5, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_429 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_431 : FiniteTemplate HasSnaky 7 required_431 envelope_431 := by + refine finite_compose HasSnaky 6 childrenC_431 childrenD_431 finite_children_work_431 (4, 4) + required_431 envelope_431 pivot_mem_431 child_required_sub_431 child_envelope_sub_431 ?_ + intro b hb + exact common_sub_431 (mem_commonEnvelope childrenD_431 b hb) + +theorem finite_children_work_436 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_436 j) (childrenD_436 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_47 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (6, 2)).mono (by decide +kernel) + +theorem finite_row_works_436 : FiniteTemplate HasSnaky 7 required_436 envelope_436 := by + refine finite_compose HasSnaky 6 childrenC_436 childrenD_436 finite_children_work_436 (3, 5) + required_436 envelope_436 pivot_mem_436 child_required_sub_436 child_envelope_sub_436 ?_ + intro b hb + exact common_sub_436 (mem_commonEnvelope childrenD_436 b hb) + +theorem finite_children_work_437 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_437 j) (childrenD_437 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_47 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (6, 2)).mono (by decide +kernel) + +theorem finite_row_works_437 : FiniteTemplate HasSnaky 7 required_437 envelope_437 := by + refine finite_compose HasSnaky 6 childrenC_437 childrenD_437 finite_children_work_437 (3, 4) + required_437 envelope_437 pivot_mem_437 child_required_sub_437 child_envelope_sub_437 ?_ + intro b hb + exact common_sub_437 (mem_commonEnvelope childrenD_437 b hb) + +theorem finite_children_work_446_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_446_i0 j) (childrenD_446_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_72 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_446_i0 : FiniteTemplate HasSnaky 6 required_446_i0 envelope_446_i0 := by + refine finite_compose HasSnaky 5 childrenC_446_i0 childrenD_446_i0 finite_children_work_446_i0 (2, 4) + required_446_i0 envelope_446_i0 pivot_mem_446_i0 child_required_sub_446_i0 child_envelope_sub_446_i0 ?_ + intro b hb + exact common_sub_446_i0 (mem_commonEnvelope childrenD_446_i0 b hb) + +theorem finite_children_work_446 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_446 j) (childrenD_446 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_446_i0.mono (by decide +kernel) + +theorem finite_row_works_446 : FiniteTemplate HasSnaky 7 required_446 envelope_446 := by + refine finite_compose HasSnaky 6 childrenC_446 childrenD_446 finite_children_work_446 (2, 3) + required_446 envelope_446 pivot_mem_446 child_required_sub_446 child_envelope_sub_446 ?_ + intro b hb + exact common_sub_446 (mem_commonEnvelope childrenD_446 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height07Part03.lean b/lean/snaky/FiniteCards/Height07Part03.lean new file mode 100644 index 0000000..b5866ce --- /dev/null +++ b/lean/snaky/FiniteCards/Height07Part03.lean @@ -0,0 +1,296 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_447_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_447_i0 j) (childrenD_447_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_445 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_447_i0 : FiniteTemplate HasSnaky 6 required_447_i0 envelope_447_i0 := by + refine finite_compose HasSnaky 5 childrenC_447_i0 childrenD_447_i0 finite_children_work_447_i0 (2, 3) + required_447_i0 envelope_447_i0 pivot_mem_447_i0 child_required_sub_447_i0 child_envelope_sub_447_i0 ?_ + intro b hb + exact common_sub_447_i0 (mem_commonEnvelope childrenD_447_i0 b hb) + +theorem finite_children_work_447 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_447 j) (childrenD_447 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_447_i0.mono (by decide +kernel) + +theorem finite_row_works_447 : FiniteTemplate HasSnaky 7 required_447 envelope_447 := by + refine finite_compose HasSnaky 6 childrenC_447 childrenD_447 finite_children_work_447 (2, 4) + required_447 envelope_447 pivot_mem_447 child_required_sub_447 child_envelope_sub_447 ?_ + intro b hb + exact common_sub_447 (mem_commonEnvelope childrenD_447 b hb) + +theorem finite_children_work_453_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_453_i1 j) (childrenD_453_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 2 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_37 0 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_354 5 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_453_i1 : FiniteTemplate HasSnaky 5 required_453_i1 envelope_453_i1 := by + refine finite_compose HasSnaky 4 childrenC_453_i1 childrenD_453_i1 finite_children_work_453_i1 (3, 3) + required_453_i1 envelope_453_i1 pivot_mem_453_i1 child_required_sub_453_i1 child_envelope_sub_453_i1 ?_ + intro b hb + exact common_sub_453_i1 (mem_commonEnvelope childrenD_453_i1 b hb) + +theorem finite_children_work_453_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_453_i0 j) (childrenD_453_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_453_i1.mono (by decide +kernel) + +theorem finite_row_works_453_i0 : FiniteTemplate HasSnaky 6 required_453_i0 envelope_453_i0 := by + refine finite_compose HasSnaky 5 childrenC_453_i0 childrenD_453_i0 finite_children_work_453_i0 (3, 0) + required_453_i0 envelope_453_i0 pivot_mem_453_i0 child_required_sub_453_i0 child_envelope_sub_453_i0 ?_ + intro b hb + exact common_sub_453_i0 (mem_commonEnvelope childrenD_453_i0 b hb) + +theorem finite_children_work_453 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_453 j) (childrenD_453 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_453_i0.mono (by decide +kernel) + +theorem finite_row_works_453 : FiniteTemplate HasSnaky 7 required_453 envelope_453 := by + refine finite_compose HasSnaky 6 childrenC_453 childrenD_453 finite_children_work_453 (3, 2) + required_453 envelope_453 pivot_mem_453 child_required_sub_453 child_envelope_sub_453 ?_ + intro b hb + exact common_sub_453 (mem_commonEnvelope childrenD_453 b hb) + +theorem finite_children_work_466 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_466 j) (childrenD_466 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_9.mono (by decide +kernel) + · exact finite_row_works_465.mono (by decide +kernel) + +theorem finite_row_works_466 : FiniteTemplate HasSnaky 7 required_466 envelope_466 := by + refine finite_compose HasSnaky 6 childrenC_466 childrenD_466 finite_children_work_466 (1, 4) + required_466 envelope_466 pivot_mem_466 child_required_sub_466 child_envelope_sub_466 ?_ + intro b hb + exact common_sub_466 (mem_commonEnvelope childrenD_466 b hb) + +theorem finite_children_work_469_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_469_i0 j) (childrenD_469_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_101 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 5 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_469_i0 : FiniteTemplate HasSnaky 6 required_469_i0 envelope_469_i0 := by + refine finite_compose HasSnaky 5 childrenC_469_i0 childrenD_469_i0 finite_children_work_469_i0 (2, 3) + required_469_i0 envelope_469_i0 pivot_mem_469_i0 child_required_sub_469_i0 child_envelope_sub_469_i0 ?_ + intro b hb + exact common_sub_469_i0 (mem_commonEnvelope childrenD_469_i0 b hb) + +theorem finite_children_work_469 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_469 j) (childrenD_469 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_78 3 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_469_i0.mono (by decide +kernel) + +theorem finite_row_works_469 : FiniteTemplate HasSnaky 7 required_469 envelope_469 := by + refine finite_compose HasSnaky 6 childrenC_469 childrenD_469 finite_children_work_469 (3, 2) + required_469 envelope_469 pivot_mem_469 child_required_sub_469 child_envelope_sub_469 ?_ + intro b hb + exact common_sub_469 (mem_commonEnvelope childrenD_469 b hb) + +theorem finite_children_work_472 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_472 j) (childrenD_472 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_471 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_472 : FiniteTemplate HasSnaky 7 required_472 envelope_472 := by + refine finite_compose HasSnaky 6 childrenC_472 childrenD_472 finite_children_work_472 (4, 3) + required_472 envelope_472 pivot_mem_472 child_required_sub_472 child_envelope_sub_472 ?_ + intro b hb + exact common_sub_472 (mem_commonEnvelope childrenD_472 b hb) + +theorem finite_children_work_487 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_487 j) (childrenD_487 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_486.mono (by decide +kernel) + +theorem finite_row_works_487 : FiniteTemplate HasSnaky 7 required_487 envelope_487 := by + refine finite_compose HasSnaky 6 childrenC_487 childrenD_487 finite_children_work_487 (2, 3) + required_487 envelope_487 pivot_mem_487 child_required_sub_487 child_envelope_sub_487 ?_ + intro b hb + exact common_sub_487 (mem_commonEnvelope childrenD_487 b hb) + +theorem finite_children_work_488_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_488_i1 j) (childrenD_488_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_34 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_488_i1 : FiniteTemplate HasSnaky 3 required_488_i1 envelope_488_i1 := by + refine finite_compose HasSnaky 2 childrenC_488_i1 childrenD_488_i1 finite_children_work_488_i1 (1, 6) + required_488_i1 envelope_488_i1 pivot_mem_488_i1 child_required_sub_488_i1 child_envelope_sub_488_i1 ?_ + intro b hb + exact common_sub_488_i1 (mem_commonEnvelope childrenD_488_i1 b hb) + +theorem finite_children_work_488_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_488_i0 j) (childrenD_488_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 1 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_488_i1.mono (by decide +kernel) + +theorem finite_row_works_488_i0 : FiniteTemplate HasSnaky 4 required_488_i0 envelope_488_i0 := by + refine finite_compose HasSnaky 3 childrenC_488_i0 childrenD_488_i0 finite_children_work_488_i0 (2, 6) + required_488_i0 envelope_488_i0 pivot_mem_488_i0 child_required_sub_488_i0 child_envelope_sub_488_i0 ?_ + intro b hb + exact common_sub_488_i0 (mem_commonEnvelope childrenD_488_i0 b hb) + +theorem finite_children_work_488_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_488_i2 j) (childrenD_488_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_357 0 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_488_i2 : FiniteTemplate HasSnaky 6 required_488_i2 envelope_488_i2 := by + refine finite_compose HasSnaky 5 childrenC_488_i2 childrenD_488_i2 finite_children_work_488_i2 (4, 4) + required_488_i2 envelope_488_i2 pivot_mem_488_i2 child_required_sub_488_i2 child_envelope_sub_488_i2 ?_ + intro b hb + exact common_sub_488_i2 (mem_commonEnvelope childrenD_488_i2 b hb) + +theorem finite_children_work_488 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_488 j) (childrenD_488 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_95 6 (5, 9)).mono (by decide +kernel) + · exact finite_row_works_488_i0.mono (by decide +kernel) + · exact finite_row_works_488_i2.mono (by decide +kernel) + +theorem finite_row_works_488 : FiniteTemplate HasSnaky 7 required_488 envelope_488 := by + refine finite_compose HasSnaky 6 childrenC_488 childrenD_488 finite_children_work_488 (4, 6) + required_488 envelope_488 pivot_mem_488 child_required_sub_488 child_envelope_sub_488 ?_ + intro b hb + exact common_sub_488 (mem_commonEnvelope childrenD_488 b hb) + +theorem finite_children_work_499_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_499_i0 j) (childrenD_499_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 6 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_347 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_499_i0 : FiniteTemplate HasSnaky 6 required_499_i0 envelope_499_i0 := by + refine finite_compose HasSnaky 5 childrenC_499_i0 childrenD_499_i0 finite_children_work_499_i0 (4, 3) + required_499_i0 envelope_499_i0 pivot_mem_499_i0 child_required_sub_499_i0 child_envelope_sub_499_i0 ?_ + intro b hb + exact common_sub_499_i0 (mem_commonEnvelope childrenD_499_i0 b hb) + +theorem finite_children_work_499_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_499_i1 j) (childrenD_499_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_43 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_499_i1 : FiniteTemplate HasSnaky 4 required_499_i1 envelope_499_i1 := by + refine finite_compose HasSnaky 3 childrenC_499_i1 childrenD_499_i1 finite_children_work_499_i1 (3, 3) + required_499_i1 envelope_499_i1 pivot_mem_499_i1 child_required_sub_499_i1 child_envelope_sub_499_i1 ?_ + intro b hb + exact common_sub_499_i1 (mem_commonEnvelope childrenD_499_i1 b hb) + +theorem finite_children_work_499 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_499 j) (childrenD_499 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 2 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_499_i0.mono (by decide +kernel) + · exact finite_row_works_499_i1.mono (by decide +kernel) + +theorem finite_row_works_499 : FiniteTemplate HasSnaky 7 required_499 envelope_499 := by + refine finite_compose HasSnaky 6 childrenC_499 childrenD_499 finite_children_work_499 (2, 1) + required_499 envelope_499 pivot_mem_499 child_required_sub_499 child_envelope_sub_499 ?_ + intro b hb + exact common_sub_499 (mem_commonEnvelope childrenD_499 b hb) + +theorem finite_children_work_504_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_504_i1 j) (childrenD_504_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_56 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_504_i1 : FiniteTemplate HasSnaky 5 required_504_i1 envelope_504_i1 := by + refine finite_compose HasSnaky 4 childrenC_504_i1 childrenD_504_i1 finite_children_work_504_i1 (2, 3) + required_504_i1 envelope_504_i1 pivot_mem_504_i1 child_required_sub_504_i1 child_envelope_sub_504_i1 ?_ + intro b hb + exact common_sub_504_i1 (mem_commonEnvelope childrenD_504_i1 b hb) + +theorem finite_children_work_504_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_504_i0 j) (childrenD_504_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_18 0 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_504_i1.mono (by decide +kernel) + +theorem finite_row_works_504_i0 : FiniteTemplate HasSnaky 6 required_504_i0 envelope_504_i0 := by + refine finite_compose HasSnaky 5 childrenC_504_i0 childrenD_504_i0 finite_children_work_504_i0 (3, 5) + required_504_i0 envelope_504_i0 pivot_mem_504_i0 child_required_sub_504_i0 child_envelope_sub_504_i0 ?_ + intro b hb + exact common_sub_504_i0 (mem_commonEnvelope childrenD_504_i0 b hb) + +theorem finite_children_work_504 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_504 j) (childrenD_504 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_32 7 (4, 4)).mono (by decide +kernel) + · exact finite_row_works_504_i0.mono (by decide +kernel) + +theorem finite_row_works_504 : FiniteTemplate HasSnaky 7 required_504 envelope_504 := by + refine finite_compose HasSnaky 6 childrenC_504 childrenD_504 finite_children_work_504 (3, 1) + required_504 envelope_504 pivot_mem_504 child_required_sub_504 child_envelope_sub_504 ?_ + intro b hb + exact common_sub_504 (mem_commonEnvelope childrenD_504 b hb) + +theorem finite_children_work_507_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_507_i0 j) (childrenD_507_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_33 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 6 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_47 3 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_507_i0 : FiniteTemplate HasSnaky 6 required_507_i0 envelope_507_i0 := by + refine finite_compose HasSnaky 5 childrenC_507_i0 childrenD_507_i0 finite_children_work_507_i0 (3, 5) + required_507_i0 envelope_507_i0 pivot_mem_507_i0 child_required_sub_507_i0 child_envelope_sub_507_i0 ?_ + intro b hb + exact common_sub_507_i0 (mem_commonEnvelope childrenD_507_i0 b hb) + +theorem finite_children_work_507 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_507 j) (childrenD_507 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 1 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_274.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_506 2 (4, 0)).mono (by decide +kernel) + · exact finite_row_works_507_i0.mono (by decide +kernel) + +theorem finite_row_works_507 : FiniteTemplate HasSnaky 7 required_507 envelope_507 := by + refine finite_compose HasSnaky 6 childrenC_507 childrenD_507 finite_children_work_507 (3, 4) + required_507 envelope_507 pivot_mem_507 child_required_sub_507 child_envelope_sub_507 ?_ + intro b hb + exact common_sub_507 (mem_commonEnvelope childrenD_507 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height07Part04.lean b/lean/snaky/FiniteCards/Height07Part04.lean new file mode 100644 index 0000000..f44d45c --- /dev/null +++ b/lean/snaky/FiniteCards/Height07Part04.lean @@ -0,0 +1,317 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part05 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part06 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_511_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_511_i1 j) (childrenD_511_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 6 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 0 (3, 1)).mono (by decide +kernel) + +theorem finite_row_works_511_i1 : FiniteTemplate HasSnaky 4 required_511_i1 envelope_511_i1 := by + refine finite_compose HasSnaky 3 childrenC_511_i1 childrenD_511_i1 finite_children_work_511_i1 (4, 4) + required_511_i1 envelope_511_i1 pivot_mem_511_i1 child_required_sub_511_i1 child_envelope_sub_511_i1 ?_ + intro b hb + exact common_sub_511_i1 (mem_commonEnvelope childrenD_511_i1 b hb) + +theorem finite_children_work_511_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_511_i3 j) (childrenD_511_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_221 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_511_i3 : FiniteTemplate HasSnaky 4 required_511_i3 envelope_511_i3 := by + refine finite_compose HasSnaky 3 childrenC_511_i3 childrenD_511_i3 finite_children_work_511_i3 (3, 5) + required_511_i3 envelope_511_i3 pivot_mem_511_i3 child_required_sub_511_i3 child_envelope_sub_511_i3 ?_ + intro b hb + exact common_sub_511_i3 (mem_commonEnvelope childrenD_511_i3 b hb) + +theorem finite_children_work_511_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_511_i2 j) (childrenD_511_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 4)).mono (by decide +kernel) + · exact finite_row_works_511_i3.mono (by decide +kernel) + +theorem finite_row_works_511_i2 : FiniteTemplate HasSnaky 5 required_511_i2 envelope_511_i2 := by + refine finite_compose HasSnaky 4 childrenC_511_i2 childrenD_511_i2 finite_children_work_511_i2 (2, 4) + required_511_i2 envelope_511_i2 pivot_mem_511_i2 child_required_sub_511_i2 child_envelope_sub_511_i2 ?_ + intro b hb + exact common_sub_511_i2 (mem_commonEnvelope childrenD_511_i2 b hb) + +theorem finite_children_work_511_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_511_i0 j) (childrenD_511_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_240 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_511_i1.mono (by decide +kernel) + · exact finite_row_works_511_i2.mono (by decide +kernel) + +theorem finite_row_works_511_i0 : FiniteTemplate HasSnaky 6 required_511_i0 envelope_511_i0 := by + refine finite_compose HasSnaky 5 childrenC_511_i0 childrenD_511_i0 finite_children_work_511_i0 (3, 4) + required_511_i0 envelope_511_i0 pivot_mem_511_i0 child_required_sub_511_i0 child_envelope_sub_511_i0 ?_ + intro b hb + exact common_sub_511_i0 (mem_commonEnvelope childrenD_511_i0 b hb) + +theorem finite_children_work_511 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_511 j) (childrenD_511 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 6 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_511_i0.mono (by decide +kernel) + +theorem finite_row_works_511 : FiniteTemplate HasSnaky 7 required_511 envelope_511 := by + refine finite_compose HasSnaky 6 childrenC_511 childrenD_511 finite_children_work_511 (1, 4) + required_511 envelope_511 pivot_mem_511 child_required_sub_511 child_envelope_sub_511 ?_ + intro b hb + exact common_sub_511 (mem_commonEnvelope childrenD_511 b hb) + +theorem finite_children_work_522_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_522_i0 j) (childrenD_522_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_416 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_522_i0 : FiniteTemplate HasSnaky 6 required_522_i0 envelope_522_i0 := by + refine finite_compose HasSnaky 5 childrenC_522_i0 childrenD_522_i0 finite_children_work_522_i0 (1, 3) + required_522_i0 envelope_522_i0 pivot_mem_522_i0 child_required_sub_522_i0 child_envelope_sub_522_i0 ?_ + intro b hb + exact common_sub_522_i0 (mem_commonEnvelope childrenD_522_i0 b hb) + +theorem finite_children_work_522 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_522 j) (childrenD_522 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_522_i0.mono (by decide +kernel) + +theorem finite_row_works_522 : FiniteTemplate HasSnaky 7 required_522 envelope_522 := by + refine finite_compose HasSnaky 6 childrenC_522 childrenD_522 finite_children_work_522 (4, 2) + required_522 envelope_522 pivot_mem_522 child_required_sub_522 child_envelope_sub_522 ?_ + intro b hb + exact common_sub_522 (mem_commonEnvelope childrenD_522 b hb) + +theorem finite_children_work_526 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_526 j) (childrenD_526 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_525.mono (by decide +kernel) + +theorem finite_row_works_526 : FiniteTemplate HasSnaky 7 required_526 envelope_526 := by + refine finite_compose HasSnaky 6 childrenC_526 childrenD_526 finite_children_work_526 (3, 1) + required_526 envelope_526 pivot_mem_526 child_required_sub_526 child_envelope_sub_526 ?_ + intro b hb + exact common_sub_526 (mem_commonEnvelope childrenD_526 b hb) + +theorem finite_children_work_542_i3 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_542_i3 j) (childrenD_542_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_1 4 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_542_i3 : FiniteTemplate HasSnaky 2 required_542_i3 envelope_542_i3 := by + refine finite_compose HasSnaky 1 childrenC_542_i3 childrenD_542_i3 finite_children_work_542_i3 (5, 2) + required_542_i3 envelope_542_i3 pivot_mem_542_i3 child_required_sub_542_i3 child_envelope_sub_542_i3 ?_ + intro b hb + exact common_sub_542_i3 (mem_commonEnvelope childrenD_542_i3 b hb) + +theorem finite_children_work_542_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_542_i2 j) (childrenD_542_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_29 0 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_542_i3.mono (by decide +kernel) + +theorem finite_row_works_542_i2 : FiniteTemplate HasSnaky 4 required_542_i2 envelope_542_i2 := by + refine finite_compose HasSnaky 3 childrenC_542_i2 childrenD_542_i2 finite_children_work_542_i2 (4, 3) + required_542_i2 envelope_542_i2 pivot_mem_542_i2 child_required_sub_542_i2 child_envelope_sub_542_i2 ?_ + intro b hb + exact common_sub_542_i2 (mem_commonEnvelope childrenD_542_i2 b hb) + +theorem finite_children_work_542_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_542_i1 j) (childrenD_542_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_542_i2.mono (by decide +kernel) + +theorem finite_row_works_542_i1 : FiniteTemplate HasSnaky 5 required_542_i1 envelope_542_i1 := by + refine finite_compose HasSnaky 4 childrenC_542_i1 childrenD_542_i1 finite_children_work_542_i1 (4, 2) + required_542_i1 envelope_542_i1 pivot_mem_542_i1 child_required_sub_542_i1 child_envelope_sub_542_i1 ?_ + intro b hb + exact common_sub_542_i1 (mem_commonEnvelope childrenD_542_i1 b hb) + +theorem finite_children_work_542_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_542_i0 j) (childrenD_542_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_542_i1.mono (by decide +kernel) + +theorem finite_row_works_542_i0 : FiniteTemplate HasSnaky 6 required_542_i0 envelope_542_i0 := by + refine finite_compose HasSnaky 5 childrenC_542_i0 childrenD_542_i0 finite_children_work_542_i0 (2, 1) + required_542_i0 envelope_542_i0 pivot_mem_542_i0 child_required_sub_542_i0 child_envelope_sub_542_i0 ?_ + intro b hb + exact common_sub_542_i0 (mem_commonEnvelope childrenD_542_i0 b hb) + +theorem finite_children_work_542 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_542 j) (childrenD_542 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 7 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_542_i0.mono (by decide +kernel) + +theorem finite_row_works_542 : FiniteTemplate HasSnaky 7 required_542 envelope_542 := by + refine finite_compose HasSnaky 6 childrenC_542 childrenD_542 finite_children_work_542 (1, 3) + required_542 envelope_542 pivot_mem_542 child_required_sub_542 child_envelope_sub_542 ?_ + intro b hb + exact common_sub_542 (mem_commonEnvelope childrenD_542 b hb) + +theorem finite_children_work_554_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_554_i0 j) (childrenD_554_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_515 0 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_554_i0 : FiniteTemplate HasSnaky 6 required_554_i0 envelope_554_i0 := by + refine finite_compose HasSnaky 5 childrenC_554_i0 childrenD_554_i0 finite_children_work_554_i0 (1, 3) + required_554_i0 envelope_554_i0 pivot_mem_554_i0 child_required_sub_554_i0 child_envelope_sub_554_i0 ?_ + intro b hb + exact common_sub_554_i0 (mem_commonEnvelope childrenD_554_i0 b hb) + +theorem finite_children_work_554 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_554 j) (childrenD_554 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_554_i0.mono (by decide +kernel) + +theorem finite_row_works_554 : FiniteTemplate HasSnaky 7 required_554 envelope_554 := by + refine finite_compose HasSnaky 6 childrenC_554 childrenD_554 finite_children_work_554 (1, 4) + required_554 envelope_554 pivot_mem_554 child_required_sub_554 child_envelope_sub_554 ?_ + intro b hb + exact common_sub_554 (mem_commonEnvelope childrenD_554 b hb) + +theorem finite_children_work_565_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_565_i0 j) (childrenD_565_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_565_i0 : FiniteTemplate HasSnaky 6 required_565_i0 envelope_565_i0 := by + refine finite_compose HasSnaky 5 childrenC_565_i0 childrenD_565_i0 finite_children_work_565_i0 (5, 3) + required_565_i0 envelope_565_i0 pivot_mem_565_i0 child_required_sub_565_i0 child_envelope_sub_565_i0 ?_ + intro b hb + exact common_sub_565_i0 (mem_commonEnvelope childrenD_565_i0 b hb) + +theorem finite_children_work_565_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_565_i1 j) (childrenD_565_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_142.mono (by decide +kernel) + +theorem finite_row_works_565_i1 : FiniteTemplate HasSnaky 6 required_565_i1 envelope_565_i1 := by + refine finite_compose HasSnaky 5 childrenC_565_i1 childrenD_565_i1 finite_children_work_565_i1 (1, 3) + required_565_i1 envelope_565_i1 pivot_mem_565_i1 child_required_sub_565_i1 child_envelope_sub_565_i1 ?_ + intro b hb + exact common_sub_565_i1 (mem_commonEnvelope childrenD_565_i1 b hb) + +theorem finite_children_work_565 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_565 j) (childrenD_565 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_140 3 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_565_i0.mono (by decide +kernel) + · exact finite_row_works_565_i1.mono (by decide +kernel) + +theorem finite_row_works_565 : FiniteTemplate HasSnaky 7 required_565 envelope_565 := by + refine finite_compose HasSnaky 6 childrenC_565 childrenD_565 finite_children_work_565 (5, 2) + required_565 envelope_565 pivot_mem_565 child_required_sub_565 child_envelope_sub_565 ?_ + intro b hb + exact common_sub_565 (mem_commonEnvelope childrenD_565 b hb) + +theorem finite_children_work_576_i2 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_576_i2 j) (childrenD_576_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (8, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 1 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_576_i2 : FiniteTemplate HasSnaky 2 required_576_i2 envelope_576_i2 := by + refine finite_compose HasSnaky 1 childrenC_576_i2 childrenD_576_i2 finite_children_work_576_i2 (5, 5) + required_576_i2 envelope_576_i2 pivot_mem_576_i2 child_required_sub_576_i2 child_envelope_sub_576_i2 ?_ + intro b hb + exact common_sub_576_i2 (mem_commonEnvelope childrenD_576_i2 b hb) + +theorem finite_children_work_576_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_576_i3 j) (childrenD_576_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_87 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_576_i3 : FiniteTemplate HasSnaky 4 required_576_i3 envelope_576_i3 := by + refine finite_compose HasSnaky 3 childrenC_576_i3 childrenD_576_i3 finite_children_work_576_i3 (3, 2) + required_576_i3 envelope_576_i3 pivot_mem_576_i3 child_required_sub_576_i3 child_envelope_sub_576_i3 ?_ + intro b hb + exact common_sub_576_i3 (mem_commonEnvelope childrenD_576_i3 b hb) + +theorem finite_children_work_576_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_576_i1 j) (childrenD_576_i1 j) := by + intro j + fin_cases j + · exact finite_row_works_576_i2.mono (by decide +kernel) + · exact finite_row_works_576_i3.mono (by decide +kernel) + +theorem finite_row_works_576_i1 : FiniteTemplate HasSnaky 5 required_576_i1 envelope_576_i1 := by + refine finite_compose HasSnaky 4 childrenC_576_i1 childrenD_576_i1 finite_children_work_576_i1 (4, 5) + required_576_i1 envelope_576_i1 pivot_mem_576_i1 child_required_sub_576_i1 child_envelope_sub_576_i1 ?_ + intro b hb + exact common_sub_576_i1 (mem_commonEnvelope childrenD_576_i1 b hb) + +theorem finite_children_work_576_i4 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_576_i4 j) (childrenD_576_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_87 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_215 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_576_i4 : FiniteTemplate HasSnaky 4 required_576_i4 envelope_576_i4 := by + refine finite_compose HasSnaky 3 childrenC_576_i4 childrenD_576_i4 finite_children_work_576_i4 (3, 2) + required_576_i4 envelope_576_i4 pivot_mem_576_i4 child_required_sub_576_i4 child_envelope_sub_576_i4 ?_ + intro b hb + exact common_sub_576_i4 (mem_commonEnvelope childrenD_576_i4 b hb) + +theorem finite_children_work_576_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_576_i0 j) (childrenD_576_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 0 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_246 6 (5, 5)).mono (by decide +kernel) + · exact finite_row_works_576_i1.mono (by decide +kernel) + · exact finite_row_works_576_i4.mono (by decide +kernel) + +theorem finite_row_works_576_i0 : FiniteTemplate HasSnaky 6 required_576_i0 envelope_576_i0 := by + refine finite_compose HasSnaky 5 childrenC_576_i0 childrenD_576_i0 finite_children_work_576_i0 (4, 2) + required_576_i0 envelope_576_i0 pivot_mem_576_i0 child_required_sub_576_i0 child_envelope_sub_576_i0 ?_ + intro b hb + exact common_sub_576_i0 (mem_commonEnvelope childrenD_576_i0 b hb) + +theorem finite_children_work_576 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_576 j) (childrenD_576 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (7, 4)).mono (by decide +kernel) + · exact finite_row_works_576_i0.mono (by decide +kernel) + +theorem finite_row_works_576 : FiniteTemplate HasSnaky 7 required_576 envelope_576 := by + refine finite_compose HasSnaky 6 childrenC_576 childrenD_576 finite_children_work_576 (4, 3) + required_576 envelope_576 pivot_mem_576 child_required_sub_576 child_envelope_sub_576 ?_ + intro b hb + exact common_sub_576 (mem_commonEnvelope childrenD_576 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height07Part05.lean b/lean/snaky/FiniteCards/Height07Part05.lean new file mode 100644 index 0000000..5d61b99 --- /dev/null +++ b/lean/snaky/FiniteCards/Height07Part05.lean @@ -0,0 +1,324 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part05 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part06 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_593_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_593_i0 j) (childrenD_593_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_36 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_105 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_250 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_592 4 (3, 6)).mono (by decide +kernel) + +theorem finite_row_works_593_i0 : FiniteTemplate HasSnaky 6 required_593_i0 envelope_593_i0 := by + refine finite_compose HasSnaky 5 childrenC_593_i0 childrenD_593_i0 finite_children_work_593_i0 (4, 5) + required_593_i0 envelope_593_i0 pivot_mem_593_i0 child_required_sub_593_i0 child_envelope_sub_593_i0 ?_ + intro b hb + exact common_sub_593_i0 (mem_commonEnvelope childrenD_593_i0 b hb) + +theorem finite_children_work_593 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_593 j) (childrenD_593 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_593_i0.mono (by decide +kernel) + +theorem finite_row_works_593 : FiniteTemplate HasSnaky 7 required_593 envelope_593 := by + refine finite_compose HasSnaky 6 childrenC_593 childrenD_593 finite_children_work_593 (4, 3) + required_593 envelope_593 pivot_mem_593 child_required_sub_593 child_envelope_sub_593 ?_ + intro b hb + exact common_sub_593 (mem_commonEnvelope childrenD_593 b hb) + +theorem finite_children_work_610 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_610 j) (childrenD_610 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 5 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_225 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_609 4 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_610 : FiniteTemplate HasSnaky 7 required_610 envelope_610 := by + refine finite_compose HasSnaky 6 childrenC_610 childrenD_610 finite_children_work_610 (1, 5) + required_610 envelope_610 pivot_mem_610 child_required_sub_610 child_envelope_sub_610 ?_ + intro b hb + exact common_sub_610 (mem_commonEnvelope childrenD_610 b hb) + +theorem finite_children_work_620_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_620_i0 j) (childrenD_620_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_17 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_37 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_233 5 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_620_i0 : FiniteTemplate HasSnaky 6 required_620_i0 envelope_620_i0 := by + refine finite_compose HasSnaky 5 childrenC_620_i0 childrenD_620_i0 finite_children_work_620_i0 (3, 3) + required_620_i0 envelope_620_i0 pivot_mem_620_i0 child_required_sub_620_i0 child_envelope_sub_620_i0 ?_ + intro b hb + exact common_sub_620_i0 (mem_commonEnvelope childrenD_620_i0 b hb) + +theorem finite_children_work_620 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_620 j) (childrenD_620 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_57 5 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_57 7 (6, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_293 5 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_293 7 (6, 7)).mono (by decide +kernel) + · exact finite_row_works_620_i0.mono (by decide +kernel) + +theorem finite_row_works_620 : FiniteTemplate HasSnaky 7 required_620 envelope_620 := by + refine finite_compose HasSnaky 6 childrenC_620 childrenD_620 finite_children_work_620 (4, 5) + required_620 envelope_620 pivot_mem_620 child_required_sub_620 child_envelope_sub_620 ?_ + intro b hb + exact common_sub_620 (mem_commonEnvelope childrenD_620 b hb) + +theorem finite_children_work_621_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_621_i0 j) (childrenD_621_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 7 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_159 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_164 6 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_621_i0 : FiniteTemplate HasSnaky 6 required_621_i0 envelope_621_i0 := by + refine finite_compose HasSnaky 5 childrenC_621_i0 childrenD_621_i0 finite_children_work_621_i0 (2, 3) + required_621_i0 envelope_621_i0 pivot_mem_621_i0 child_required_sub_621_i0 child_envelope_sub_621_i0 ?_ + intro b hb + exact common_sub_621_i0 (mem_commonEnvelope childrenD_621_i0 b hb) + +theorem finite_children_work_621_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_621_i1 j) (childrenD_621_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 4 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_133 4 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_621_i1 : FiniteTemplate HasSnaky 6 required_621_i1 envelope_621_i1 := by + refine finite_compose HasSnaky 5 childrenC_621_i1 childrenD_621_i1 finite_children_work_621_i1 (1, 4) + required_621_i1 envelope_621_i1 pivot_mem_621_i1 child_required_sub_621_i1 child_envelope_sub_621_i1 ?_ + intro b hb + exact common_sub_621_i1 (mem_commonEnvelope childrenD_621_i1 b hb) + +theorem finite_children_work_621 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_621 j) (childrenD_621 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_206 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_238 5 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_414 7 (5, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_417 6 (4, 6)).mono (by decide +kernel) + · exact finite_row_works_621_i0.mono (by decide +kernel) + · exact finite_row_works_621_i1.mono (by decide +kernel) + +theorem finite_row_works_621 : FiniteTemplate HasSnaky 7 required_621 envelope_621 := by + refine finite_compose HasSnaky 6 childrenC_621 childrenD_621 finite_children_work_621 (2, 4) + required_621 envelope_621 pivot_mem_621 child_required_sub_621 child_envelope_sub_621 ?_ + intro b hb + exact common_sub_621 (mem_commonEnvelope childrenD_621 b hb) + +theorem finite_children_work_628_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_628_i0 j) (childrenD_628_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_36 7 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 0 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_628_i0 : FiniteTemplate HasSnaky 4 required_628_i0 envelope_628_i0 := by + refine finite_compose HasSnaky 3 childrenC_628_i0 childrenD_628_i0 finite_children_work_628_i0 (3, 2) + required_628_i0 envelope_628_i0 pivot_mem_628_i0 child_required_sub_628_i0 child_envelope_sub_628_i0 ?_ + intro b hb + exact common_sub_628_i0 (mem_commonEnvelope childrenD_628_i0 b hb) + +theorem finite_children_work_628_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_628_i1 j) (childrenD_628_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_34 7 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_464 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_628_i1 : FiniteTemplate HasSnaky 6 required_628_i1 envelope_628_i1 := by + refine finite_compose HasSnaky 5 childrenC_628_i1 childrenD_628_i1 finite_children_work_628_i1 (3, 4) + required_628_i1 envelope_628_i1 pivot_mem_628_i1 child_required_sub_628_i1 child_envelope_sub_628_i1 ?_ + intro b hb + exact common_sub_628_i1 (mem_commonEnvelope childrenD_628_i1 b hb) + +theorem finite_children_work_628_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_628_i2 j) (childrenD_628_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_265 3 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_628_i2 : FiniteTemplate HasSnaky 6 required_628_i2 envelope_628_i2 := by + refine finite_compose HasSnaky 5 childrenC_628_i2 childrenD_628_i2 finite_children_work_628_i2 (2, 3) + required_628_i2 envelope_628_i2 pivot_mem_628_i2 child_required_sub_628_i2 child_envelope_sub_628_i2 ?_ + intro b hb + exact common_sub_628_i2 (mem_commonEnvelope childrenD_628_i2 b hb) + +theorem finite_children_work_628 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_628 j) (childrenD_628 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_126 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_270 4 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_628_i0.mono (by decide +kernel) + · exact finite_row_works_628_i1.mono (by decide +kernel) + · exact finite_row_works_628_i2.mono (by decide +kernel) + +theorem finite_row_works_628 : FiniteTemplate HasSnaky 7 required_628 envelope_628 := by + refine finite_compose HasSnaky 6 childrenC_628 childrenD_628 finite_children_work_628 (3, 3) + required_628 envelope_628 pivot_mem_628 child_required_sub_628 child_envelope_sub_628 ?_ + intro b hb + exact common_sub_628 (mem_commonEnvelope childrenD_628 b hb) + +theorem finite_children_work_633_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_633_i1 j) (childrenD_633_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_93 3 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_633_i1 : FiniteTemplate HasSnaky 5 required_633_i1 envelope_633_i1 := by + refine finite_compose HasSnaky 4 childrenC_633_i1 childrenD_633_i1 finite_children_work_633_i1 (5, 3) + required_633_i1 envelope_633_i1 pivot_mem_633_i1 child_required_sub_633_i1 child_envelope_sub_633_i1 ?_ + intro b hb + exact common_sub_633_i1 (mem_commonEnvelope childrenD_633_i1 b hb) + +theorem finite_children_work_633_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_633_i0 j) (childrenD_633_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_27 2 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_144 3 (3, 6)).mono (by decide +kernel) + · exact finite_row_works_633_i1.mono (by decide +kernel) + +theorem finite_row_works_633_i0 : FiniteTemplate HasSnaky 6 required_633_i0 envelope_633_i0 := by + refine finite_compose HasSnaky 5 childrenC_633_i0 childrenD_633_i0 finite_children_work_633_i0 (5, 6) + required_633_i0 envelope_633_i0 pivot_mem_633_i0 child_required_sub_633_i0 child_envelope_sub_633_i0 ?_ + intro b hb + exact common_sub_633_i0 (mem_commonEnvelope childrenD_633_i0 b hb) + +theorem finite_children_work_633 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_633 j) (childrenD_633 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_47 6 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_144 6 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_633_i0.mono (by decide +kernel) + +theorem finite_row_works_633 : FiniteTemplate HasSnaky 7 required_633 envelope_633 := by + refine finite_compose HasSnaky 6 childrenC_633 childrenD_633 finite_children_work_633 (4, 4) + required_633 envelope_633 pivot_mem_633 child_required_sub_633 child_envelope_sub_633 ?_ + intro b hb + exact common_sub_633 (mem_commonEnvelope childrenD_633 b hb) + +theorem finite_children_work_637_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_637_i2 j) (childrenD_637_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 6 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 1 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_637_i2 : FiniteTemplate HasSnaky 4 required_637_i2 envelope_637_i2 := by + refine finite_compose HasSnaky 3 childrenC_637_i2 childrenD_637_i2 finite_children_work_637_i2 (4, 4) + required_637_i2 envelope_637_i2 pivot_mem_637_i2 child_required_sub_637_i2 child_envelope_sub_637_i2 ?_ + intro b hb + exact common_sub_637_i2 (mem_commonEnvelope childrenD_637_i2 b hb) + +theorem finite_children_work_637_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_637_i1 j) (childrenD_637_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_637_i2.mono (by decide +kernel) + +theorem finite_row_works_637_i1 : FiniteTemplate HasSnaky 5 required_637_i1 envelope_637_i1 := by + refine finite_compose HasSnaky 4 childrenC_637_i1 childrenD_637_i1 finite_children_work_637_i1 (3, 3) + required_637_i1 envelope_637_i1 pivot_mem_637_i1 child_required_sub_637_i1 child_envelope_sub_637_i1 ?_ + intro b hb + exact common_sub_637_i1 (mem_commonEnvelope childrenD_637_i1 b hb) + +theorem finite_children_work_637_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_637_i0 j) (childrenD_637_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_637_i1.mono (by decide +kernel) + +theorem finite_row_works_637_i0 : FiniteTemplate HasSnaky 6 required_637_i0 envelope_637_i0 := by + refine finite_compose HasSnaky 5 childrenC_637_i0 childrenD_637_i0 finite_children_work_637_i0 (4, 3) + required_637_i0 envelope_637_i0 pivot_mem_637_i0 child_required_sub_637_i0 child_envelope_sub_637_i0 ?_ + intro b hb + exact common_sub_637_i0 (mem_commonEnvelope childrenD_637_i0 b hb) + +theorem finite_children_work_637 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_637 j) (childrenD_637 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_41 3 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_48 3 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_637_i0.mono (by decide +kernel) + +theorem finite_row_works_637 : FiniteTemplate HasSnaky 7 required_637 envelope_637 := by + refine finite_compose HasSnaky 6 childrenC_637 childrenD_637 finite_children_work_637 (4, 2) + required_637 envelope_637 pivot_mem_637 child_required_sub_637 child_envelope_sub_637 ?_ + intro b hb + exact common_sub_637 (mem_commonEnvelope childrenD_637 b hb) + +theorem finite_children_work_671_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_671_i0 j) (childrenD_671_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 7 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_464 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_671_i0 : FiniteTemplate HasSnaky 6 required_671_i0 envelope_671_i0 := by + refine finite_compose HasSnaky 5 childrenC_671_i0 childrenD_671_i0 finite_children_work_671_i0 (3, 4) + required_671_i0 envelope_671_i0 pivot_mem_671_i0 child_required_sub_671_i0 child_envelope_sub_671_i0 ?_ + intro b hb + exact common_sub_671_i0 (mem_commonEnvelope childrenD_671_i0 b hb) + +theorem finite_children_work_671 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_671 j) (childrenD_671 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_28 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_126 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_126 3 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_671_i0.mono (by decide +kernel) + +theorem finite_row_works_671 : FiniteTemplate HasSnaky 7 required_671 envelope_671 := by + refine finite_compose HasSnaky 6 childrenC_671 childrenD_671 finite_children_work_671 (3, 3) + required_671 envelope_671 pivot_mem_671 child_required_sub_671 child_envelope_sub_671 ?_ + intro b hb + exact common_sub_671 (mem_commonEnvelope childrenD_671 b hb) + +theorem finite_children_work_680_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_680_i0 j) (childrenD_680_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_56 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 6 (5, 5)).mono (by decide +kernel) + +theorem finite_row_works_680_i0 : FiniteTemplate HasSnaky 6 required_680_i0 envelope_680_i0 := by + refine finite_compose HasSnaky 5 childrenC_680_i0 childrenD_680_i0 finite_children_work_680_i0 (1, 3) + required_680_i0 envelope_680_i0 pivot_mem_680_i0 child_required_sub_680_i0 child_envelope_sub_680_i0 ?_ + intro b hb + exact common_sub_680_i0 (mem_commonEnvelope childrenD_680_i0 b hb) + +theorem finite_children_work_680 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_680 j) (childrenD_680 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_680_i0.mono (by decide +kernel) + +theorem finite_row_works_680 : FiniteTemplate HasSnaky 7 required_680 envelope_680 := by + refine finite_compose HasSnaky 6 childrenC_680 childrenD_680 finite_children_work_680 (3, 3) + required_680 envelope_680 pivot_mem_680 child_required_sub_680 child_envelope_sub_680 ?_ + intro b hb + exact common_sub_680 (mem_commonEnvelope childrenD_680 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height07Part06.lean b/lean/snaky/FiniteCards/Height07Part06.lean new file mode 100644 index 0000000..5642ebe --- /dev/null +++ b/lean/snaky/FiniteCards/Height07Part06.lean @@ -0,0 +1,65 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part06 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_681_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_681_i1 j) (childrenD_681_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_32 7 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_90 3 (3, 6)).mono (by decide +kernel) + +theorem finite_row_works_681_i1 : FiniteTemplate HasSnaky 5 required_681_i1 envelope_681_i1 := by + refine finite_compose HasSnaky 4 childrenC_681_i1 childrenD_681_i1 finite_children_work_681_i1 (4, 3) + required_681_i1 envelope_681_i1 pivot_mem_681_i1 child_required_sub_681_i1 child_envelope_sub_681_i1 ?_ + intro b hb + exact common_sub_681_i1 (mem_commonEnvelope childrenD_681_i1 b hb) + +theorem finite_children_work_681_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_681_i2 j) (childrenD_681_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_17 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_32 7 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_681_i2 : FiniteTemplate HasSnaky 5 required_681_i2 envelope_681_i2 := by + refine finite_compose HasSnaky 4 childrenC_681_i2 childrenD_681_i2 finite_children_work_681_i2 (4, 3) + required_681_i2 envelope_681_i2 pivot_mem_681_i2 child_required_sub_681_i2 child_envelope_sub_681_i2 ?_ + intro b hb + exact common_sub_681_i2 (mem_commonEnvelope childrenD_681_i2 b hb) + +theorem finite_children_work_681_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_681_i0 j) (childrenD_681_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (4, 7)).mono (by decide +kernel) + · exact finite_row_works_681_i1.mono (by decide +kernel) + · exact finite_row_works_681_i2.mono (by decide +kernel) + +theorem finite_row_works_681_i0 : FiniteTemplate HasSnaky 6 required_681_i0 envelope_681_i0 := by + refine finite_compose HasSnaky 5 childrenC_681_i0 childrenD_681_i0 finite_children_work_681_i0 (4, 6) + required_681_i0 envelope_681_i0 pivot_mem_681_i0 child_required_sub_681_i0 child_envelope_sub_681_i0 ?_ + intro b hb + exact common_sub_681_i0 (mem_commonEnvelope childrenD_681_i0 b hb) + +theorem finite_children_work_681 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_681 j) (childrenD_681 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 1 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_681_i0.mono (by decide +kernel) + +theorem finite_row_works_681 : FiniteTemplate HasSnaky 7 required_681 envelope_681 := by + refine finite_compose HasSnaky 6 childrenC_681 childrenD_681 finite_children_work_681 (3, 4) + required_681 envelope_681 pivot_mem_681 child_required_sub_681 child_envelope_sub_681 ?_ + intro b hb + exact common_sub_681 (mem_commonEnvelope childrenD_681 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height08Part01.lean b/lean/snaky/FiniteCards/Height08Part01.lean new file mode 100644 index 0000000..685acb2 --- /dev/null +++ b/lean/snaky/FiniteCards/Height08Part01.lean @@ -0,0 +1,311 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height05Part01 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part05 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_120 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_120 j) (childrenD_120 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 3 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_116.mono (by decide +kernel) + +theorem finite_row_works_120 : FiniteTemplate HasSnaky 8 required_120 envelope_120 := by + refine finite_compose HasSnaky 7 childrenC_120 childrenD_120 finite_children_work_120 (2, 3) + required_120 envelope_120 pivot_mem_120 child_required_sub_120 child_envelope_sub_120 ?_ + intro b hb + exact common_sub_120 (mem_commonEnvelope childrenD_120 b hb) + +theorem finite_children_work_171 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_171 j) (childrenD_171 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 4 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_116 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_171 : FiniteTemplate HasSnaky 8 required_171 envelope_171 := by + refine finite_compose HasSnaky 7 childrenC_171 childrenD_171 finite_children_work_171 (4, 3) + required_171 envelope_171 pivot_mem_171 child_required_sub_171 child_envelope_sub_171 ?_ + intro b hb + exact common_sub_171 (mem_commonEnvelope childrenD_171 b hb) + +theorem finite_children_work_174 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_174 j) (childrenD_174 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_116 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_117 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_135 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_135 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_173 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_173 5 (6, 2)).mono (by decide +kernel) + +theorem finite_row_works_174 : FiniteTemplate HasSnaky 8 required_174 envelope_174 := by + refine finite_compose HasSnaky 7 childrenC_174 childrenD_174 finite_children_work_174 (3, 5) + required_174 envelope_174 pivot_mem_174 child_required_sub_174 child_envelope_sub_174 ?_ + intro b hb + exact common_sub_174 (mem_commonEnvelope childrenD_174 b hb) + +theorem finite_children_work_257 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_257 j) (childrenD_257 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_256 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_257 : FiniteTemplate HasSnaky 8 required_257 envelope_257 := by + refine finite_compose HasSnaky 7 childrenC_257 childrenD_257 finite_children_work_257 (4, 3) + required_257 envelope_257 pivot_mem_257 child_required_sub_257 child_envelope_sub_257 ?_ + intro b hb + exact common_sub_257 (mem_commonEnvelope childrenD_257 b hb) + +theorem finite_children_work_258 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_258 j) (childrenD_258 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_161 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_162 4 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_256.mono (by decide +kernel) + +theorem finite_row_works_258 : FiniteTemplate HasSnaky 8 required_258 envelope_258 := by + refine finite_compose HasSnaky 7 childrenC_258 childrenD_258 finite_children_work_258 (3, 3) + required_258 envelope_258 pivot_mem_258 child_required_sub_258 child_envelope_sub_258 ?_ + intro b hb + exact common_sub_258 (mem_commonEnvelope childrenD_258 b hb) + +theorem finite_children_work_285 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_285 j) (childrenD_285 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_117 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_285 : FiniteTemplate HasSnaky 8 required_285 envelope_285 := by + refine finite_compose HasSnaky 7 childrenC_285 childrenD_285 finite_children_work_285 (4, 3) + required_285 envelope_285 pivot_mem_285 child_required_sub_285 child_envelope_sub_285 ?_ + intro b hb + exact common_sub_285 (mem_commonEnvelope childrenD_285 b hb) + +theorem finite_children_work_319 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_319 j) (childrenD_319 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_318 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_319 : FiniteTemplate HasSnaky 8 required_319 envelope_319 := by + refine finite_compose HasSnaky 7 childrenC_319 childrenD_319 finite_children_work_319 (3, 4) + required_319 envelope_319 pivot_mem_319 child_required_sub_319 child_envelope_sub_319 ?_ + intro b hb + exact common_sub_319 (mem_commonEnvelope childrenD_319 b hb) + +theorem finite_children_work_321 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_321 j) (childrenD_321 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_320.mono (by decide +kernel) + +theorem finite_row_works_321 : FiniteTemplate HasSnaky 8 required_321 envelope_321 := by + refine finite_compose HasSnaky 7 childrenC_321 childrenD_321 finite_children_work_321 (3, 3) + required_321 envelope_321 pivot_mem_321 child_required_sub_321 child_envelope_sub_321 ?_ + intro b hb + exact common_sub_321 (mem_commonEnvelope childrenD_321 b hb) + +theorem finite_children_work_323 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_323 j) (childrenD_323 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 7 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_320 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_323 : FiniteTemplate HasSnaky 8 required_323 envelope_323 := by + refine finite_compose HasSnaky 7 childrenC_323 childrenD_323 finite_children_work_323 (2, 4) + required_323 envelope_323 pivot_mem_323 child_required_sub_323 child_envelope_sub_323 ?_ + intro b hb + exact common_sub_323 (mem_commonEnvelope childrenD_323 b hb) + +theorem finite_children_work_338 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_338 j) (childrenD_338 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_47 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_337 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_338 : FiniteTemplate HasSnaky 8 required_338 envelope_338 := by + refine finite_compose HasSnaky 7 childrenC_338 childrenD_338 finite_children_work_338 (2, 4) + required_338 envelope_338 pivot_mem_338 child_required_sub_338 child_envelope_sub_338 ?_ + intro b hb + exact common_sub_338 (mem_commonEnvelope childrenD_338 b hb) + +theorem finite_children_work_345 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_345 j) (childrenD_345 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_344.mono (by decide +kernel) + +theorem finite_row_works_345 : FiniteTemplate HasSnaky 8 required_345 envelope_345 := by + refine finite_compose HasSnaky 7 childrenC_345 childrenD_345 finite_children_work_345 (4, 2) + required_345 envelope_345 pivot_mem_345 child_required_sub_345 child_envelope_sub_345 ?_ + intro b hb + exact common_sub_345 (mem_commonEnvelope childrenD_345 b hb) + +theorem finite_children_work_373 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_373 j) (childrenD_373 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_372.mono (by decide +kernel) + +theorem finite_row_works_373 : FiniteTemplate HasSnaky 8 required_373 envelope_373 := by + refine finite_compose HasSnaky 7 childrenC_373 childrenD_373 finite_children_work_373 (1, 4) + required_373 envelope_373 pivot_mem_373 child_required_sub_373 child_envelope_sub_373 ?_ + intro b hb + exact common_sub_373 (mem_commonEnvelope childrenD_373 b hb) + +theorem finite_children_work_395_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_395_i0 j) (childrenD_395_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_217 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_395_i0 : FiniteTemplate HasSnaky 7 required_395_i0 envelope_395_i0 := by + refine finite_compose HasSnaky 6 childrenC_395_i0 childrenD_395_i0 finite_children_work_395_i0 (3, 1) + required_395_i0 envelope_395_i0 pivot_mem_395_i0 child_required_sub_395_i0 child_envelope_sub_395_i0 ?_ + intro b hb + exact common_sub_395_i0 (mem_commonEnvelope childrenD_395_i0 b hb) + +theorem finite_children_work_395 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_395 j) (childrenD_395 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_395_i0.mono (by decide +kernel) + +theorem finite_row_works_395 : FiniteTemplate HasSnaky 8 required_395 envelope_395 := by + refine finite_compose HasSnaky 7 childrenC_395 childrenD_395 finite_children_work_395 (3, 3) + required_395 envelope_395 pivot_mem_395 child_required_sub_395 child_envelope_sub_395 ?_ + intro b hb + exact common_sub_395 (mem_commonEnvelope childrenD_395 b hb) + +theorem finite_children_work_405 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_405 j) (childrenD_405 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_404.mono (by decide +kernel) + +theorem finite_row_works_405 : FiniteTemplate HasSnaky 8 required_405 envelope_405 := by + refine finite_compose HasSnaky 7 childrenC_405 childrenD_405 finite_children_work_405 (1, 4) + required_405 envelope_405 pivot_mem_405 child_required_sub_405 child_envelope_sub_405 ?_ + intro b hb + exact common_sub_405 (mem_commonEnvelope childrenD_405 b hb) + +theorem finite_children_work_412_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_412_i0 j) (childrenD_412_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_358.mono (by decide +kernel) + +theorem finite_row_works_412_i0 : FiniteTemplate HasSnaky 7 required_412_i0 envelope_412_i0 := by + refine finite_compose HasSnaky 6 childrenC_412_i0 childrenD_412_i0 finite_children_work_412_i0 (3, 1) + required_412_i0 envelope_412_i0 pivot_mem_412_i0 child_required_sub_412_i0 child_envelope_sub_412_i0 ?_ + intro b hb + exact common_sub_412_i0 (mem_commonEnvelope childrenD_412_i0 b hb) + +theorem finite_children_work_412 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_412 j) (childrenD_412 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_412_i0.mono (by decide +kernel) + +theorem finite_row_works_412 : FiniteTemplate HasSnaky 8 required_412 envelope_412 := by + refine finite_compose HasSnaky 7 childrenC_412 childrenD_412 finite_children_work_412 (2, 1) + required_412 envelope_412 pivot_mem_412 child_required_sub_412 child_envelope_sub_412 ?_ + intro b hb + exact common_sub_412 (mem_commonEnvelope childrenD_412 b hb) + +theorem finite_children_work_419 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_419 j) (childrenD_419 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_418 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_419 : FiniteTemplate HasSnaky 8 required_419 envelope_419 := by + refine finite_compose HasSnaky 7 childrenC_419 childrenD_419 finite_children_work_419 (2, 1) + required_419 envelope_419 pivot_mem_419 child_required_sub_419 child_envelope_sub_419 ?_ + intro b hb + exact common_sub_419 (mem_commonEnvelope childrenD_419 b hb) + +theorem finite_children_work_420 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_420 j) (childrenD_420 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_418.mono (by decide +kernel) + +theorem finite_row_works_420 : FiniteTemplate HasSnaky 8 required_420 envelope_420 := by + refine finite_compose HasSnaky 7 childrenC_420 childrenD_420 finite_children_work_420 (3, 1) + required_420 envelope_420 pivot_mem_420 child_required_sub_420 child_envelope_sub_420 ?_ + intro b hb + exact common_sub_420 (mem_commonEnvelope childrenD_420 b hb) + +theorem finite_children_work_438 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_438 j) (childrenD_438 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 7 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_47 6 (6, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_436 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_438 : FiniteTemplate HasSnaky 8 required_438 envelope_438 := by + refine finite_compose HasSnaky 7 childrenC_438 childrenD_438 finite_children_work_438 (4, 3) + required_438 envelope_438 pivot_mem_438 child_required_sub_438 child_envelope_sub_438 ?_ + intro b hb + exact common_sub_438 (mem_commonEnvelope childrenD_438 b hb) + +theorem finite_children_work_440_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_440_i0 j) (childrenD_440_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_439 7 (5, 4)).mono (by decide +kernel) + +theorem finite_row_works_440_i0 : FiniteTemplate HasSnaky 7 required_440_i0 envelope_440_i0 := by + refine finite_compose HasSnaky 6 childrenC_440_i0 childrenD_440_i0 finite_children_work_440_i0 (1, 1) + required_440_i0 envelope_440_i0 pivot_mem_440_i0 child_required_sub_440_i0 child_envelope_sub_440_i0 ?_ + intro b hb + exact common_sub_440_i0 (mem_commonEnvelope childrenD_440_i0 b hb) + +theorem finite_children_work_440 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_440 j) (childrenD_440 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_440_i0.mono (by decide +kernel) + +theorem finite_row_works_440 : FiniteTemplate HasSnaky 8 required_440 envelope_440 := by + refine finite_compose HasSnaky 7 childrenC_440 childrenD_440 finite_children_work_440 (0, 1) + required_440 envelope_440 pivot_mem_440 child_required_sub_440 child_envelope_sub_440 ?_ + intro b hb + exact common_sub_440 (mem_commonEnvelope childrenD_440 b hb) + +theorem finite_children_work_448 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_448 j) (childrenD_448 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_56 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_447 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_448 : FiniteTemplate HasSnaky 8 required_448 envelope_448 := by + refine finite_compose HasSnaky 7 childrenC_448 childrenD_448 finite_children_work_448 (1, 3) + required_448 envelope_448 pivot_mem_448 child_required_sub_448 child_envelope_sub_448 ?_ + intro b hb + exact common_sub_448 (mem_commonEnvelope childrenD_448 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height08Part02.lean b/lean/snaky/FiniteCards/Height08Part02.lean new file mode 100644 index 0000000..1bd2a01 --- /dev/null +++ b/lean/snaky/FiniteCards/Height08Part02.lean @@ -0,0 +1,292 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height06Part05 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_452_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_452_i0 j) (childrenD_452_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_55 0 (3, 1)).mono (by decide +kernel) + +theorem finite_row_works_452_i0 : FiniteTemplate HasSnaky 5 required_452_i0 envelope_452_i0 := by + refine finite_compose HasSnaky 4 childrenC_452_i0 childrenD_452_i0 finite_children_work_452_i0 (6, 4) + required_452_i0 envelope_452_i0 pivot_mem_452_i0 child_required_sub_452_i0 child_envelope_sub_452_i0 ?_ + intro b hb + exact common_sub_452_i0 (mem_commonEnvelope childrenD_452_i0 b hb) + +theorem finite_children_work_452 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_452 j) (childrenD_452 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 7 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_317 0 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_452_i0.mono (by decide +kernel) + +theorem finite_row_works_452 : FiniteTemplate HasSnaky 8 required_452 envelope_452 := by + refine finite_compose HasSnaky 7 childrenC_452 childrenD_452 finite_children_work_452 (4, 4) + required_452 envelope_452 pivot_mem_452 child_required_sub_452 child_envelope_sub_452 ?_ + intro b hb + exact common_sub_452 (mem_commonEnvelope childrenD_452 b hb) + +theorem finite_children_work_454 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_454 j) (childrenD_454 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_453 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_454 : FiniteTemplate HasSnaky 8 required_454 envelope_454 := by + refine finite_compose HasSnaky 7 childrenC_454 childrenD_454 finite_children_work_454 (1, 3) + required_454 envelope_454 pivot_mem_454 child_required_sub_454 child_envelope_sub_454 ?_ + intro b hb + exact common_sub_454 (mem_commonEnvelope childrenD_454 b hb) + +theorem finite_children_work_455 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_455 j) (childrenD_455 j) := by + intro j + fin_cases j + · exact finite_row_works_8.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_16 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 4 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_453.mono (by decide +kernel) + +theorem finite_row_works_455 : FiniteTemplate HasSnaky 8 required_455 envelope_455 := by + refine finite_compose HasSnaky 7 childrenC_455 childrenD_455 finite_children_work_455 (1, 1) + required_455 envelope_455 pivot_mem_455 child_required_sub_455 child_envelope_sub_455 ?_ + intro b hb + exact common_sub_455 (mem_commonEnvelope childrenD_455 b hb) + +theorem finite_children_work_456 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_456 j) (childrenD_456 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_453 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_456 : FiniteTemplate HasSnaky 8 required_456 envelope_456 := by + refine finite_compose HasSnaky 7 childrenC_456 childrenD_456 finite_children_work_456 (2, 4) + required_456 envelope_456 pivot_mem_456 child_required_sub_456 child_envelope_sub_456 ?_ + intro b hb + exact common_sub_456 (mem_commonEnvelope childrenD_456 b hb) + +theorem finite_children_work_473 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_473 j) (childrenD_473 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_472.mono (by decide +kernel) + +theorem finite_row_works_473 : FiniteTemplate HasSnaky 8 required_473 envelope_473 := by + refine finite_compose HasSnaky 7 childrenC_473 childrenD_473 finite_children_work_473 (1, 1) + required_473 envelope_473 pivot_mem_473 child_required_sub_473 child_envelope_sub_473 ?_ + intro b hb + exact common_sub_473 (mem_commonEnvelope childrenD_473 b hb) + +theorem finite_children_work_478 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_478 j) (childrenD_478 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_472.mono (by decide +kernel) + +theorem finite_row_works_478 : FiniteTemplate HasSnaky 8 required_478 envelope_478 := by + refine finite_compose HasSnaky 7 childrenC_478 childrenD_478 finite_children_work_478 (2, 2) + required_478 envelope_478 pivot_mem_478 child_required_sub_478 child_envelope_sub_478 ?_ + intro b hb + exact common_sub_478 (mem_commonEnvelope childrenD_478 b hb) + +theorem finite_children_work_482 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_482 j) (childrenD_482 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_124 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_472.mono (by decide +kernel) + +theorem finite_row_works_482 : FiniteTemplate HasSnaky 8 required_482 envelope_482 := by + refine finite_compose HasSnaky 7 childrenC_482 childrenD_482 finite_children_work_482 (2, 2) + required_482 envelope_482 pivot_mem_482 child_required_sub_482 child_envelope_sub_482 ?_ + intro b hb + exact common_sub_482 (mem_commonEnvelope childrenD_482 b hb) + +theorem finite_children_work_484_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_484_i1 j) (childrenD_484_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_96 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_484_i1 : FiniteTemplate HasSnaky 3 required_484_i1 envelope_484_i1 := by + refine finite_compose HasSnaky 2 childrenC_484_i1 childrenD_484_i1 finite_children_work_484_i1 (2, 2) + required_484_i1 envelope_484_i1 pivot_mem_484_i1 child_required_sub_484_i1 child_envelope_sub_484_i1 ?_ + intro b hb + exact common_sub_484_i1 (mem_commonEnvelope childrenD_484_i1 b hb) + +theorem finite_children_work_484_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_484_i2 j) (childrenD_484_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_33 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_130 6 (4, 5)).mono (by decide +kernel) + +theorem finite_row_works_484_i2 : FiniteTemplate HasSnaky 5 required_484_i2 envelope_484_i2 := by + refine finite_compose HasSnaky 4 childrenC_484_i2 childrenD_484_i2 finite_children_work_484_i2 (4, 4) + required_484_i2 envelope_484_i2 pivot_mem_484_i2 child_required_sub_484_i2 child_envelope_sub_484_i2 ?_ + intro b hb + exact common_sub_484_i2 (mem_commonEnvelope childrenD_484_i2 b hb) + +theorem finite_children_work_484_i4 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_484_i4 j) (childrenD_484_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_223 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_484_i4 : FiniteTemplate HasSnaky 4 required_484_i4 envelope_484_i4 := by + refine finite_compose HasSnaky 3 childrenC_484_i4 childrenD_484_i4 finite_children_work_484_i4 (2, 2) + required_484_i4 envelope_484_i4 pivot_mem_484_i4 child_required_sub_484_i4 child_envelope_sub_484_i4 ?_ + intro b hb + exact common_sub_484_i4 (mem_commonEnvelope childrenD_484_i4 b hb) + +theorem finite_children_work_484_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_484_i3 j) (childrenD_484_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_39 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_268 2 (5, 0)).mono (by decide +kernel) + · exact finite_row_works_484_i4.mono (by decide +kernel) + +theorem finite_row_works_484_i3 : FiniteTemplate HasSnaky 5 required_484_i3 envelope_484_i3 := by + refine finite_compose HasSnaky 4 childrenC_484_i3 childrenD_484_i3 finite_children_work_484_i3 (4, 2) + required_484_i3 envelope_484_i3 pivot_mem_484_i3 child_required_sub_484_i3 child_envelope_sub_484_i3 ?_ + intro b hb + exact common_sub_484_i3 (mem_commonEnvelope childrenD_484_i3 b hb) + +theorem finite_children_work_484_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_484_i0 j) (childrenD_484_i0 j) := by + intro j + fin_cases j + · exact finite_row_works_484_i1.mono (by decide +kernel) + · exact finite_row_works_484_i2.mono (by decide +kernel) + · exact finite_row_works_484_i3.mono (by decide +kernel) + +theorem finite_row_works_484_i0 : FiniteTemplate HasSnaky 6 required_484_i0 envelope_484_i0 := by + refine finite_compose HasSnaky 5 childrenC_484_i0 childrenD_484_i0 finite_children_work_484_i0 (3, 2) + required_484_i0 envelope_484_i0 pivot_mem_484_i0 child_required_sub_484_i0 child_envelope_sub_484_i0 ?_ + intro b hb + exact common_sub_484_i0 (mem_commonEnvelope childrenD_484_i0 b hb) + +theorem finite_children_work_484_i6 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_484_i6 j) (childrenD_484_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_58 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_168 6 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_357 6 (4, 5)).mono (by decide +kernel) + +theorem finite_row_works_484_i6 : FiniteTemplate HasSnaky 6 required_484_i6 envelope_484_i6 := by + refine finite_compose HasSnaky 5 childrenC_484_i6 childrenD_484_i6 finite_children_work_484_i6 (4, 4) + required_484_i6 envelope_484_i6 pivot_mem_484_i6 child_required_sub_484_i6 child_envelope_sub_484_i6 ?_ + intro b hb + exact common_sub_484_i6 (mem_commonEnvelope childrenD_484_i6 b hb) + +theorem finite_children_work_484_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_484_i5 j) (childrenD_484_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_314 5 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_484_i6.mono (by decide +kernel) + +theorem finite_row_works_484_i5 : FiniteTemplate HasSnaky 7 required_484_i5 envelope_484_i5 := by + refine finite_compose HasSnaky 6 childrenC_484_i5 childrenD_484_i5 finite_children_work_484_i5 (2, 4) + required_484_i5 envelope_484_i5 pivot_mem_484_i5 child_required_sub_484_i5 child_envelope_sub_484_i5 ?_ + intro b hb + exact common_sub_484_i5 (mem_commonEnvelope childrenD_484_i5 b hb) + +theorem finite_children_work_484 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_484 j) (childrenD_484 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_81 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_204 4 (0, 8)).mono (by decide +kernel) + · exact finite_row_works_484_i0.mono (by decide +kernel) + · exact finite_row_works_484_i5.mono (by decide +kernel) + +theorem finite_row_works_484 : FiniteTemplate HasSnaky 8 required_484 envelope_484 := by + refine finite_compose HasSnaky 7 childrenC_484 childrenD_484 finite_children_work_484 (4, 5) + required_484 envelope_484 pivot_mem_484 child_required_sub_484 child_envelope_sub_484 ?_ + intro b hb + exact common_sub_484 (mem_commonEnvelope childrenD_484 b hb) + +theorem finite_children_work_494 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_494 j) (childrenD_494 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_87.mono (by decide +kernel) + · exact finite_row_works_286.mono (by decide +kernel) + · exact finite_row_works_492.mono (by decide +kernel) + +theorem finite_row_works_494 : FiniteTemplate HasSnaky 8 required_494 envelope_494 := by + refine finite_compose HasSnaky 7 childrenC_494 childrenD_494 finite_children_work_494 (3, 3) + required_494 envelope_494 pivot_mem_494 child_required_sub_494 child_envelope_sub_494 ?_ + intro b hb + exact common_sub_494 (mem_commonEnvelope childrenD_494 b hb) + +theorem finite_children_work_510_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_510_i0 j) (childrenD_510_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_138 5 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_510_i0 : FiniteTemplate HasSnaky 3 required_510_i0 envelope_510_i0 := by + refine finite_compose HasSnaky 2 childrenC_510_i0 childrenD_510_i0 finite_children_work_510_i0 (1, 4) + required_510_i0 envelope_510_i0 pivot_mem_510_i0 child_required_sub_510_i0 child_envelope_sub_510_i0 ?_ + intro b hb + exact common_sub_510_i0 (mem_commonEnvelope childrenD_510_i0 b hb) + +theorem finite_children_work_510 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_510 j) (childrenD_510 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_510_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_507 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_510 : FiniteTemplate HasSnaky 8 required_510 envelope_510 := by + refine finite_compose HasSnaky 7 childrenC_510 childrenD_510 finite_children_work_510 (4, 3) + required_510 envelope_510 pivot_mem_510 child_required_sub_510 child_envelope_sub_510 ?_ + intro b hb + exact common_sub_510 (mem_commonEnvelope childrenD_510 b hb) + +theorem finite_children_work_513_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_513_i0 j) (childrenD_513_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_439 5 (5, 1)).mono (by decide +kernel) + +theorem finite_row_works_513_i0 : FiniteTemplate HasSnaky 7 required_513_i0 envelope_513_i0 := by + refine finite_compose HasSnaky 6 childrenC_513_i0 childrenD_513_i0 finite_children_work_513_i0 (0, 4) + required_513_i0 envelope_513_i0 pivot_mem_513_i0 child_required_sub_513_i0 child_envelope_sub_513_i0 ?_ + intro b hb + exact common_sub_513_i0 (mem_commonEnvelope childrenD_513_i0 b hb) + +theorem finite_children_work_513 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_513 j) (childrenD_513 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_9.mono (by decide +kernel) + · exact finite_row_works_513_i0.mono (by decide +kernel) + +theorem finite_row_works_513 : FiniteTemplate HasSnaky 8 required_513 envelope_513 := by + refine finite_compose HasSnaky 7 childrenC_513 childrenD_513 finite_children_work_513 (1, 4) + required_513 envelope_513 pivot_mem_513 child_required_sub_513 child_envelope_sub_513 ?_ + intro b hb + exact common_sub_513 (mem_commonEnvelope childrenD_513 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height08Part03.lean b/lean/snaky/FiniteCards/Height08Part03.lean new file mode 100644 index 0000000..2873481 --- /dev/null +++ b/lean/snaky/FiniteCards/Height08Part03.lean @@ -0,0 +1,316 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part05 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part03 +import FiniteCards.Height07Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_518_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_518_i1 j) (childrenD_518_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 2 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_213 5 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_278 1 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_518_i1 : FiniteTemplate HasSnaky 6 required_518_i1 envelope_518_i1 := by + refine finite_compose HasSnaky 5 childrenC_518_i1 childrenD_518_i1 finite_children_work_518_i1 (3, 7) + required_518_i1 envelope_518_i1 pivot_mem_518_i1 child_required_sub_518_i1 child_envelope_sub_518_i1 ?_ + intro b hb + exact common_sub_518_i1 (mem_commonEnvelope childrenD_518_i1 b hb) + +theorem finite_children_work_518_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_518_i0 j) (childrenD_518_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 3)).mono (by decide +kernel) + · exact finite_row_works_518_i1.mono (by decide +kernel) + +theorem finite_row_works_518_i0 : FiniteTemplate HasSnaky 7 required_518_i0 envelope_518_i0 := by + refine finite_compose HasSnaky 6 childrenC_518_i0 childrenD_518_i0 finite_children_work_518_i0 (3, 6) + required_518_i0 envelope_518_i0 pivot_mem_518_i0 child_required_sub_518_i0 child_envelope_sub_518_i0 ?_ + intro b hb + exact common_sub_518_i0 (mem_commonEnvelope childrenD_518_i0 b hb) + +theorem finite_children_work_518 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_518 j) (childrenD_518 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_61 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_89 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_183 1 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_518_i0.mono (by decide +kernel) + +theorem finite_row_works_518 : FiniteTemplate HasSnaky 8 required_518 envelope_518 := by + refine finite_compose HasSnaky 7 childrenC_518 childrenD_518 finite_children_work_518 (4, 6) + required_518 envelope_518 pivot_mem_518 child_required_sub_518 child_envelope_sub_518 ?_ + intro b hb + exact common_sub_518 (mem_commonEnvelope childrenD_518 b hb) + +theorem finite_children_work_523 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_523 j) (childrenD_523 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_122 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_136 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_367 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_522 7 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_523 : FiniteTemplate HasSnaky 8 required_523 envelope_523 := by + refine finite_compose HasSnaky 7 childrenC_523 childrenD_523 finite_children_work_523 (3, 5) + required_523 envelope_523 pivot_mem_523 child_required_sub_523 child_envelope_sub_523 ?_ + intro b hb + exact common_sub_523 (mem_commonEnvelope childrenD_523 b hb) + +theorem finite_children_work_524 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_524 j) (childrenD_524 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_88 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_213 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_254 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_522 7 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_524 : FiniteTemplate HasSnaky 8 required_524 envelope_524 := by + refine finite_compose HasSnaky 7 childrenC_524 childrenD_524 finite_children_work_524 (3, 5) + required_524 envelope_524 pivot_mem_524 child_required_sub_524 child_envelope_sub_524 ?_ + intro b hb + exact common_sub_524 (mem_commonEnvelope childrenD_524 b hb) + +theorem finite_children_work_530_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_530_i2 j) (childrenD_530_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_20 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_530_i2 : FiniteTemplate HasSnaky 4 required_530_i2 envelope_530_i2 := by + refine finite_compose HasSnaky 3 childrenC_530_i2 childrenD_530_i2 finite_children_work_530_i2 (2, 5) + required_530_i2 envelope_530_i2 pivot_mem_530_i2 child_required_sub_530_i2 child_envelope_sub_530_i2 ?_ + intro b hb + exact common_sub_530_i2 (mem_commonEnvelope childrenD_530_i2 b hb) + +theorem finite_children_work_530_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_530_i1 j) (childrenD_530_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_51 3 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_530_i2.mono (by decide +kernel) + +theorem finite_row_works_530_i1 : FiniteTemplate HasSnaky 5 required_530_i1 envelope_530_i1 := by + refine finite_compose HasSnaky 4 childrenC_530_i1 childrenD_530_i1 finite_children_work_530_i1 (3, 2) + required_530_i1 envelope_530_i1 pivot_mem_530_i1 child_required_sub_530_i1 child_envelope_sub_530_i1 ?_ + intro b hb + exact common_sub_530_i1 (mem_commonEnvelope childrenD_530_i1 b hb) + +theorem finite_children_work_530_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_530_i0 j) (childrenD_530_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_23 6 (2, 5)).mono (by decide +kernel) + · exact finite_row_works_530_i1.mono (by decide +kernel) + +theorem finite_row_works_530_i0 : FiniteTemplate HasSnaky 6 required_530_i0 envelope_530_i0 := by + refine finite_compose HasSnaky 5 childrenC_530_i0 childrenD_530_i0 finite_children_work_530_i0 (2, 2) + required_530_i0 envelope_530_i0 pivot_mem_530_i0 child_required_sub_530_i0 child_envelope_sub_530_i0 ?_ + intro b hb + exact common_sub_530_i0 (mem_commonEnvelope childrenD_530_i0 b hb) + +theorem finite_children_work_530 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_530 j) (childrenD_530 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_72 4 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_360 4 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_499 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_530_i0.mono (by decide +kernel) + +theorem finite_row_works_530 : FiniteTemplate HasSnaky 8 required_530 envelope_530 := by + refine finite_compose HasSnaky 7 childrenC_530 childrenD_530 finite_children_work_530 (2, 4) + required_530 envelope_530 pivot_mem_530 child_required_sub_530 child_envelope_sub_530 ?_ + intro b hb + exact common_sub_530 (mem_commonEnvelope childrenD_530 b hb) + +theorem finite_children_work_532_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_532_i0 j) (childrenD_532_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 2 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_84 2 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 5 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_521 4 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_532_i0 : FiniteTemplate HasSnaky 7 required_532_i0 envelope_532_i0 := by + refine finite_compose HasSnaky 6 childrenC_532_i0 childrenD_532_i0 finite_children_work_532_i0 (2, 6) + required_532_i0 envelope_532_i0 pivot_mem_532_i0 child_required_sub_532_i0 child_envelope_sub_532_i0 ?_ + intro b hb + exact common_sub_532_i0 (mem_commonEnvelope childrenD_532_i0 b hb) + +theorem finite_children_work_532 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_532 j) (childrenD_532 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_134 3 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_532_i0.mono (by decide +kernel) + +theorem finite_row_works_532 : FiniteTemplate HasSnaky 8 required_532 envelope_532 := by + refine finite_compose HasSnaky 7 childrenC_532 childrenD_532 finite_children_work_532 (2, 3) + required_532 envelope_532 pivot_mem_532 child_required_sub_532 child_envelope_sub_532 ?_ + intro b hb + exact common_sub_532 (mem_commonEnvelope childrenD_532 b hb) + +theorem finite_children_work_533_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_533_i0 j) (childrenD_533_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 0 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_55 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_392 7 (5, 4)).mono (by decide +kernel) + +theorem finite_row_works_533_i0 : FiniteTemplate HasSnaky 7 required_533_i0 envelope_533_i0 := by + refine finite_compose HasSnaky 6 childrenC_533_i0 childrenD_533_i0 finite_children_work_533_i0 (3, 4) + required_533_i0 envelope_533_i0 pivot_mem_533_i0 child_required_sub_533_i0 child_envelope_sub_533_i0 ?_ + intro b hb + exact common_sub_533_i0 (mem_commonEnvelope childrenD_533_i0 b hb) + +theorem finite_children_work_533 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_533 j) (childrenD_533 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_279 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_533_i0.mono (by decide +kernel) + +theorem finite_row_works_533 : FiniteTemplate HasSnaky 8 required_533 envelope_533 := by + refine finite_compose HasSnaky 7 childrenC_533 childrenD_533 finite_children_work_533 (4, 3) + required_533 envelope_533 pivot_mem_533 child_required_sub_533 child_envelope_sub_533 ?_ + intro b hb + exact common_sub_533 (mem_commonEnvelope childrenD_533 b hb) + +theorem finite_children_work_534_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_534_i1 j) (childrenD_534_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_177 1 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_534_i1 : FiniteTemplate HasSnaky 4 required_534_i1 envelope_534_i1 := by + refine finite_compose HasSnaky 3 childrenC_534_i1 childrenD_534_i1 finite_children_work_534_i1 (2, 6) + required_534_i1 envelope_534_i1 pivot_mem_534_i1 child_required_sub_534_i1 child_envelope_sub_534_i1 ?_ + intro b hb + exact common_sub_534_i1 (mem_commonEnvelope childrenD_534_i1 b hb) + +theorem finite_children_work_534_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_534_i2 j) (childrenD_534_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_239 7 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_534_i2 : FiniteTemplate HasSnaky 4 required_534_i2 envelope_534_i2 := by + refine finite_compose HasSnaky 3 childrenC_534_i2 childrenD_534_i2 finite_children_work_534_i2 (3, 5) + required_534_i2 envelope_534_i2 pivot_mem_534_i2 child_required_sub_534_i2 child_envelope_sub_534_i2 ?_ + intro b hb + exact common_sub_534_i2 (mem_commonEnvelope childrenD_534_i2 b hb) + +theorem finite_children_work_534_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_534_i0 j) (childrenD_534_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_139 0 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_534_i1.mono (by decide +kernel) + · exact finite_row_works_534_i2.mono (by decide +kernel) + +theorem finite_row_works_534_i0 : FiniteTemplate HasSnaky 5 required_534_i0 envelope_534_i0 := by + refine finite_compose HasSnaky 4 childrenC_534_i0 childrenD_534_i0 finite_children_work_534_i0 (3, 6) + required_534_i0 envelope_534_i0 pivot_mem_534_i0 child_required_sub_534_i0 child_envelope_sub_534_i0 ?_ + intro b hb + exact common_sub_534_i0 (mem_commonEnvelope childrenD_534_i0 b hb) + +theorem finite_children_work_534 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_534 j) (childrenD_534 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 4 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 4 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_388 3 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_534_i0.mono (by decide +kernel) + +theorem finite_row_works_534 : FiniteTemplate HasSnaky 8 required_534 envelope_534 := by + refine finite_compose HasSnaky 7 childrenC_534 childrenD_534 finite_children_work_534 (2, 5) + required_534 envelope_534 pivot_mem_534 child_required_sub_534 child_envelope_sub_534 ?_ + intro b hb + exact common_sub_534 (mem_commonEnvelope childrenD_534 b hb) + +theorem finite_children_work_547_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_547_i0 j) (childrenD_547_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 2 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_547_i0 : FiniteTemplate HasSnaky 5 required_547_i0 envelope_547_i0 := by + refine finite_compose HasSnaky 4 childrenC_547_i0 childrenD_547_i0 finite_children_work_547_i0 (1, 5) + required_547_i0 envelope_547_i0 pivot_mem_547_i0 child_required_sub_547_i0 child_envelope_sub_547_i0 ?_ + intro b hb + exact common_sub_547_i0 (mem_commonEnvelope childrenD_547_i0 b hb) + +theorem finite_children_work_547_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_547_i1 j) (childrenD_547_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_525 3 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_547_i1 : FiniteTemplate HasSnaky 7 required_547_i1 envelope_547_i1 := by + refine finite_compose HasSnaky 6 childrenC_547_i1 childrenD_547_i1 finite_children_work_547_i1 (2, 4) + required_547_i1 envelope_547_i1 pivot_mem_547_i1 child_required_sub_547_i1 child_envelope_sub_547_i1 ?_ + intro b hb + exact common_sub_547_i1 (mem_commonEnvelope childrenD_547_i1 b hb) + +theorem finite_children_work_547 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_547 j) (childrenD_547 j) := by + intro j + fin_cases j + · exact finite_row_works_19.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 5 (2, 1)).mono (by decide +kernel) + · exact finite_row_works_547_i0.mono (by decide +kernel) + · exact finite_row_works_547_i1.mono (by decide +kernel) + +theorem finite_row_works_547 : FiniteTemplate HasSnaky 8 required_547 envelope_547 := by + refine finite_compose HasSnaky 7 childrenC_547 childrenD_547 finite_children_work_547 (1, 4) + required_547 envelope_547 pivot_mem_547 child_required_sub_547 child_envelope_sub_547 ?_ + intro b hb + exact common_sub_547 (mem_commonEnvelope childrenD_547 b hb) + +theorem finite_children_work_558_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_558_i0 j) (childrenD_558_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_471.mono (by decide +kernel) + +theorem finite_row_works_558_i0 : FiniteTemplate HasSnaky 7 required_558_i0 envelope_558_i0 := by + refine finite_compose HasSnaky 6 childrenC_558_i0 childrenD_558_i0 finite_children_work_558_i0 (3, 1) + required_558_i0 envelope_558_i0 pivot_mem_558_i0 child_required_sub_558_i0 child_envelope_sub_558_i0 ?_ + intro b hb + exact common_sub_558_i0 (mem_commonEnvelope childrenD_558_i0 b hb) + +theorem finite_children_work_558 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_558 j) (childrenD_558 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_16 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_24 4 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_558_i0.mono (by decide +kernel) + +theorem finite_row_works_558 : FiniteTemplate HasSnaky 8 required_558 envelope_558 := by + refine finite_compose HasSnaky 7 childrenC_558 childrenD_558 finite_children_work_558 (3, 2) + required_558 envelope_558 pivot_mem_558 child_required_sub_558 child_envelope_sub_558 ?_ + intro b hb + exact common_sub_558 (mem_commonEnvelope childrenD_558 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height08Part04.lean b/lean/snaky/FiniteCards/Height08Part04.lean new file mode 100644 index 0000000..68b0e9f --- /dev/null +++ b/lean/snaky/FiniteCards/Height08Part04.lean @@ -0,0 +1,319 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_559_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_559_i0 j) (childrenD_559_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 1 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_559_i0 : FiniteTemplate HasSnaky 5 required_559_i0 envelope_559_i0 := by + refine finite_compose HasSnaky 4 childrenC_559_i0 childrenD_559_i0 finite_children_work_559_i0 (4, 0) + required_559_i0 envelope_559_i0 pivot_mem_559_i0 child_required_sub_559_i0 child_envelope_sub_559_i0 ?_ + intro b hb + exact common_sub_559_i0 (mem_commonEnvelope childrenD_559_i0 b hb) + +theorem finite_children_work_559_i6 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_559_i6 j) (childrenD_559_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_0 0 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_559_i6 : FiniteTemplate HasSnaky 2 required_559_i6 envelope_559_i6 := by + refine finite_compose HasSnaky 1 childrenC_559_i6 childrenD_559_i6 finite_children_work_559_i6 (1, 3) + required_559_i6 envelope_559_i6 pivot_mem_559_i6 child_required_sub_559_i6 child_envelope_sub_559_i6 ?_ + intro b hb + exact common_sub_559_i6 (mem_commonEnvelope childrenD_559_i6 b hb) + +theorem finite_children_work_559_i5 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_559_i5 j) (childrenD_559_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 6 (6, 4)).mono (by decide +kernel) + · exact finite_row_works_559_i6.mono (by decide +kernel) + +theorem finite_row_works_559_i5 : FiniteTemplate HasSnaky 3 required_559_i5 envelope_559_i5 := by + refine finite_compose HasSnaky 2 childrenC_559_i5 childrenD_559_i5 finite_children_work_559_i5 (2, 3) + required_559_i5 envelope_559_i5 pivot_mem_559_i5 child_required_sub_559_i5 child_envelope_sub_559_i5 ?_ + intro b hb + exact common_sub_559_i5 (mem_commonEnvelope childrenD_559_i5 b hb) + +theorem finite_children_work_559_i4 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_559_i4 j) (childrenD_559_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_559_i5.mono (by decide +kernel) + +theorem finite_row_works_559_i4 : FiniteTemplate HasSnaky 4 required_559_i4 envelope_559_i4 := by + refine finite_compose HasSnaky 3 childrenC_559_i4 childrenD_559_i4 finite_children_work_559_i4 (4, 4) + required_559_i4 envelope_559_i4 pivot_mem_559_i4 child_required_sub_559_i4 child_envelope_sub_559_i4 ?_ + intro b hb + exact common_sub_559_i4 (mem_commonEnvelope childrenD_559_i4 b hb) + +theorem finite_children_work_559_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_559_i3 j) (childrenD_559_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_35 0 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_559_i4.mono (by decide +kernel) + +theorem finite_row_works_559_i3 : FiniteTemplate HasSnaky 5 required_559_i3 envelope_559_i3 := by + refine finite_compose HasSnaky 4 childrenC_559_i3 childrenD_559_i3 finite_children_work_559_i3 (6, 4) + required_559_i3 envelope_559_i3 pivot_mem_559_i3 child_required_sub_559_i3 child_envelope_sub_559_i3 ?_ + intro b hb + exact common_sub_559_i3 (mem_commonEnvelope childrenD_559_i3 b hb) + +theorem finite_children_work_559_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_559_i2 j) (childrenD_559_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_244 5 (6, 0)).mono (by decide +kernel) + · exact finite_row_works_559_i3.mono (by decide +kernel) + +theorem finite_row_works_559_i2 : FiniteTemplate HasSnaky 6 required_559_i2 envelope_559_i2 := by + refine finite_compose HasSnaky 5 childrenC_559_i2 childrenD_559_i2 finite_children_work_559_i2 (5, 0) + required_559_i2 envelope_559_i2 pivot_mem_559_i2 child_required_sub_559_i2 child_envelope_sub_559_i2 ?_ + intro b hb + exact common_sub_559_i2 (mem_commonEnvelope childrenD_559_i2 b hb) + +theorem finite_children_work_559_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_559_i1 j) (childrenD_559_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_559_i2.mono (by decide +kernel) + +theorem finite_row_works_559_i1 : FiniteTemplate HasSnaky 7 required_559_i1 envelope_559_i1 := by + refine finite_compose HasSnaky 6 childrenC_559_i1 childrenD_559_i1 finite_children_work_559_i1 (3, 4) + required_559_i1 envelope_559_i1 pivot_mem_559_i1 child_required_sub_559_i1 child_envelope_sub_559_i1 ?_ + intro b hb + exact common_sub_559_i1 (mem_commonEnvelope childrenD_559_i1 b hb) + +theorem finite_children_work_559 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_559 j) (childrenD_559 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 4 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_236 5 (7, 0)).mono (by decide +kernel) + · exact finite_row_works_559_i0.mono (by decide +kernel) + · exact finite_row_works_559_i1.mono (by decide +kernel) + +theorem finite_row_works_559 : FiniteTemplate HasSnaky 8 required_559 envelope_559 := by + refine finite_compose HasSnaky 7 childrenC_559 childrenD_559 finite_children_work_559 (6, 1) + required_559 envelope_559 pivot_mem_559 child_required_sub_559 child_envelope_sub_559 ?_ + intro b hb + exact common_sub_559 (mem_commonEnvelope childrenD_559 b hb) + +theorem finite_children_work_566 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_566 j) (childrenD_566 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_116 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_116 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_172 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_172 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_182 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_565 5 (6, 1)).mono (by decide +kernel) + +theorem finite_row_works_566 : FiniteTemplate HasSnaky 8 required_566 envelope_566 := by + refine finite_compose HasSnaky 7 childrenC_566 childrenD_566 finite_children_work_566 (3, 5) + required_566 envelope_566 pivot_mem_566 child_required_sub_566 child_envelope_sub_566 ?_ + intro b hb + exact common_sub_566 (mem_commonEnvelope childrenD_566 b hb) + +theorem finite_children_work_604_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_604_i0 j) (childrenD_604_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_267 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_604_i0 : FiniteTemplate HasSnaky 7 required_604_i0 envelope_604_i0 := by + refine finite_compose HasSnaky 6 childrenC_604_i0 childrenD_604_i0 finite_children_work_604_i0 (3, 4) + required_604_i0 envelope_604_i0 pivot_mem_604_i0 child_required_sub_604_i0 child_envelope_sub_604_i0 ?_ + intro b hb + exact common_sub_604_i0 (mem_commonEnvelope childrenD_604_i0 b hb) + +theorem finite_children_work_604 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_604 j) (childrenD_604 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_604_i0.mono (by decide +kernel) + +theorem finite_row_works_604 : FiniteTemplate HasSnaky 8 required_604 envelope_604 := by + refine finite_compose HasSnaky 7 childrenC_604 childrenD_604 finite_children_work_604 (3, 2) + required_604 envelope_604 pivot_mem_604 child_required_sub_604 child_envelope_sub_604 ?_ + intro b hb + exact common_sub_604 (mem_commonEnvelope childrenD_604 b hb) + +theorem finite_children_work_607_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_607_i0 j) (childrenD_607_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 3 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_383 5 (6, 2)).mono (by decide +kernel) + +theorem finite_row_works_607_i0 : FiniteTemplate HasSnaky 6 required_607_i0 envelope_607_i0 := by + refine finite_compose HasSnaky 5 childrenC_607_i0 childrenD_607_i0 finite_children_work_607_i0 (4, 2) + required_607_i0 envelope_607_i0 pivot_mem_607_i0 child_required_sub_607_i0 child_envelope_sub_607_i0 ?_ + intro b hb + exact common_sub_607_i0 (mem_commonEnvelope childrenD_607_i0 b hb) + +theorem finite_children_work_607_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_607_i3 j) (childrenD_607_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_25 5 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_42 6 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_607_i3 : FiniteTemplate HasSnaky 5 required_607_i3 envelope_607_i3 := by + refine finite_compose HasSnaky 4 childrenC_607_i3 childrenD_607_i3 finite_children_work_607_i3 (2, 5) + required_607_i3 envelope_607_i3 pivot_mem_607_i3 child_required_sub_607_i3 child_envelope_sub_607_i3 ?_ + intro b hb + exact common_sub_607_i3 (mem_commonEnvelope childrenD_607_i3 b hb) + +theorem finite_children_work_607_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_607_i2 j) (childrenD_607_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_352 7 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_607_i3.mono (by decide +kernel) + +theorem finite_row_works_607_i2 : FiniteTemplate HasSnaky 6 required_607_i2 envelope_607_i2 := by + refine finite_compose HasSnaky 5 childrenC_607_i2 childrenD_607_i2 finite_children_work_607_i2 (1, 2) + required_607_i2 envelope_607_i2 pivot_mem_607_i2 child_required_sub_607_i2 child_envelope_sub_607_i2 ?_ + intro b hb + exact common_sub_607_i2 (mem_commonEnvelope childrenD_607_i2 b hb) + +theorem finite_children_work_607_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_607_i1 j) (childrenD_607_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 5 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_607_i2.mono (by decide +kernel) + +theorem finite_row_works_607_i1 : FiniteTemplate HasSnaky 7 required_607_i1 envelope_607_i1 := by + refine finite_compose HasSnaky 6 childrenC_607_i1 childrenD_607_i1 finite_children_work_607_i1 (4, 6) + required_607_i1 envelope_607_i1 pivot_mem_607_i1 child_required_sub_607_i1 child_envelope_sub_607_i1 ?_ + intro b hb + exact common_sub_607_i1 (mem_commonEnvelope childrenD_607_i1 b hb) + +theorem finite_children_work_607_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_607_i4 j) (childrenD_607_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_197 5 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_363 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_371 5 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_606 2 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_607_i4 : FiniteTemplate HasSnaky 7 required_607_i4 envelope_607_i4 := by + refine finite_compose HasSnaky 6 childrenC_607_i4 childrenD_607_i4 finite_children_work_607_i4 (4, 6) + required_607_i4 envelope_607_i4 pivot_mem_607_i4 child_required_sub_607_i4 child_envelope_sub_607_i4 ?_ + intro b hb + exact common_sub_607_i4 (mem_commonEnvelope childrenD_607_i4 b hb) + +theorem finite_children_work_607 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_607 j) (childrenD_607 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_211 4 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_607_i0.mono (by decide +kernel) + · exact finite_row_works_607_i1.mono (by decide +kernel) + · exact finite_row_works_607_i4.mono (by decide +kernel) + +theorem finite_row_works_607 : FiniteTemplate HasSnaky 8 required_607 envelope_607 := by + refine finite_compose HasSnaky 7 childrenC_607 childrenD_607 finite_children_work_607 (4, 3) + required_607 envelope_607 pivot_mem_607 child_required_sub_607 child_envelope_sub_607 ?_ + intro b hb + exact common_sub_607 (mem_commonEnvelope childrenD_607 b hb) + +theorem finite_children_work_619_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_619_i0 j) (childrenD_619_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_56 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_253 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_619_i0 : FiniteTemplate HasSnaky 7 required_619_i0 envelope_619_i0 := by + refine finite_compose HasSnaky 6 childrenC_619_i0 childrenD_619_i0 finite_children_work_619_i0 (2, 2) + required_619_i0 envelope_619_i0 pivot_mem_619_i0 child_required_sub_619_i0 child_envelope_sub_619_i0 ?_ + intro b hb + exact common_sub_619_i0 (mem_commonEnvelope childrenD_619_i0 b hb) + +theorem finite_children_work_619 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_619 j) (childrenD_619 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_49 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_115 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_292 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_619_i0.mono (by decide +kernel) + +theorem finite_row_works_619 : FiniteTemplate HasSnaky 8 required_619 envelope_619 := by + refine finite_compose HasSnaky 7 childrenC_619 childrenD_619 finite_children_work_619 (4, 3) + required_619 envelope_619 pivot_mem_619 child_required_sub_619 child_envelope_sub_619 ?_ + intro b hb + exact common_sub_619 (mem_commonEnvelope childrenD_619 b hb) + +theorem finite_children_work_651_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_651_i0 j) (childrenD_651_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_55 5 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_56 7 (6, 6)).mono (by decide +kernel) + +theorem finite_row_works_651_i0 : FiniteTemplate HasSnaky 5 required_651_i0 envelope_651_i0 := by + refine finite_compose HasSnaky 4 childrenC_651_i0 childrenD_651_i0 finite_children_work_651_i0 (3, 5) + required_651_i0 envelope_651_i0 pivot_mem_651_i0 child_required_sub_651_i0 child_envelope_sub_651_i0 ?_ + intro b hb + exact common_sub_651_i0 (mem_commonEnvelope childrenD_651_i0 b hb) + +theorem finite_children_work_651_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_651_i1 j) (childrenD_651_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_20 2 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_29 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_46 5 (5, 3)).mono (by decide +kernel) + +theorem finite_row_works_651_i1 : FiniteTemplate HasSnaky 5 required_651_i1 envelope_651_i1 := by + refine finite_compose HasSnaky 4 childrenC_651_i1 childrenD_651_i1 finite_children_work_651_i1 (3, 5) + required_651_i1 envelope_651_i1 pivot_mem_651_i1 child_required_sub_651_i1 child_envelope_sub_651_i1 ?_ + intro b hb + exact common_sub_651_i1 (mem_commonEnvelope childrenD_651_i1 b hb) + +theorem finite_children_work_651_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_651_i2 j) (childrenD_651_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_85 7 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_94 2 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_651_i2 : FiniteTemplate HasSnaky 7 required_651_i2 envelope_651_i2 := by + refine finite_compose HasSnaky 6 childrenC_651_i2 childrenD_651_i2 finite_children_work_651_i2 (4, 3) + required_651_i2 envelope_651_i2 pivot_mem_651_i2 child_required_sub_651_i2 child_envelope_sub_651_i2 ?_ + intro b hb + exact common_sub_651_i2 (mem_commonEnvelope childrenD_651_i2 b hb) + +theorem finite_children_work_651 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_651 j) (childrenD_651 j) := by + intro j + fin_cases j + · exact finite_row_works_651_i0.mono (by decide +kernel) + · exact finite_row_works_651_i1.mono (by decide +kernel) + · exact finite_row_works_651_i2.mono (by decide +kernel) + +theorem finite_row_works_651 : FiniteTemplate HasSnaky 8 required_651 envelope_651 := by + refine finite_compose HasSnaky 7 childrenC_651 childrenD_651 finite_children_work_651 (3, 6) + required_651 envelope_651 pivot_mem_651 child_required_sub_651 child_envelope_sub_651 ?_ + intro b hb + exact common_sub_651 (mem_commonEnvelope childrenD_651 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height08Part05.lean b/lean/snaky/FiniteCards/Height08Part05.lean new file mode 100644 index 0000000..4033da6 --- /dev/null +++ b/lean/snaky/FiniteCards/Height08Part05.lean @@ -0,0 +1,295 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part05 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part05 +import FiniteCards.Height07Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_658_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_658_i0 j) (childrenD_658_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_314 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_378 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_658_i0 : FiniteTemplate HasSnaky 7 required_658_i0 envelope_658_i0 := by + refine finite_compose HasSnaky 6 childrenC_658_i0 childrenD_658_i0 finite_children_work_658_i0 (2, 6) + required_658_i0 envelope_658_i0 pivot_mem_658_i0 child_required_sub_658_i0 child_envelope_sub_658_i0 ?_ + intro b hb + exact common_sub_658_i0 (mem_commonEnvelope childrenD_658_i0 b hb) + +theorem finite_children_work_658 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_658 j) (childrenD_658 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_27 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_284 4 (1, 9)).mono (by decide +kernel) + · exact finite_row_works_658_i0.mono (by decide +kernel) + +theorem finite_row_works_658 : FiniteTemplate HasSnaky 8 required_658 envelope_658 := by + refine finite_compose HasSnaky 7 childrenC_658 childrenD_658 finite_children_work_658 (2, 3) + required_658 envelope_658 pivot_mem_658 child_required_sub_658 child_envelope_sub_658 ?_ + intro b hb + exact common_sub_658 (mem_commonEnvelope childrenD_658 b hb) + +theorem finite_children_work_661_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_661_i0 j) (childrenD_661_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_115 7 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_302 7 (7, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_303 7 (7, 7)).mono (by decide +kernel) + +theorem finite_row_works_661_i0 : FiniteTemplate HasSnaky 7 required_661_i0 envelope_661_i0 := by + refine finite_compose HasSnaky 6 childrenC_661_i0 childrenD_661_i0 finite_children_work_661_i0 (4, 3) + required_661_i0 envelope_661_i0 pivot_mem_661_i0 child_required_sub_661_i0 child_envelope_sub_661_i0 ?_ + intro b hb + exact common_sub_661_i0 (mem_commonEnvelope childrenD_661_i0 b hb) + +theorem finite_children_work_661 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_661 j) (childrenD_661 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 2 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_33 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_116 1 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_661_i0.mono (by decide +kernel) + +theorem finite_row_works_661 : FiniteTemplate HasSnaky 8 required_661 envelope_661 := by + refine finite_compose HasSnaky 7 childrenC_661 childrenD_661 finite_children_work_661 (4, 6) + required_661 envelope_661 pivot_mem_661 child_required_sub_661 child_envelope_sub_661 ?_ + intro b hb + exact common_sub_661 (mem_commonEnvelope childrenD_661 b hb) + +theorem finite_children_work_666_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_666_i1 j) (childrenD_666_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 6 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_666_i1 : FiniteTemplate HasSnaky 6 required_666_i1 envelope_666_i1 := by + refine finite_compose HasSnaky 5 childrenC_666_i1 childrenD_666_i1 finite_children_work_666_i1 (1, 3) + required_666_i1 envelope_666_i1 pivot_mem_666_i1 child_required_sub_666_i1 child_envelope_sub_666_i1 ?_ + intro b hb + exact common_sub_666_i1 (mem_commonEnvelope childrenD_666_i1 b hb) + +theorem finite_children_work_666_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_666_i0 j) (childrenD_666_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_666_i1.mono (by decide +kernel) + +theorem finite_row_works_666_i0 : FiniteTemplate HasSnaky 7 required_666_i0 envelope_666_i0 := by + refine finite_compose HasSnaky 6 childrenC_666_i0 childrenD_666_i0 finite_children_work_666_i0 (4, 3) + required_666_i0 envelope_666_i0 pivot_mem_666_i0 child_required_sub_666_i0 child_envelope_sub_666_i0 ?_ + intro b hb + exact common_sub_666_i0 (mem_commonEnvelope childrenD_666_i0 b hb) + +theorem finite_children_work_666 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_666 j) (childrenD_666 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_666_i0.mono (by decide +kernel) + +theorem finite_row_works_666 : FiniteTemplate HasSnaky 8 required_666 envelope_666 := by + refine finite_compose HasSnaky 7 childrenC_666 childrenD_666 finite_children_work_666 (2, 3) + required_666 envelope_666 pivot_mem_666 child_required_sub_666 child_envelope_sub_666 ?_ + intro b hb + exact common_sub_666 (mem_commonEnvelope childrenD_666 b hb) + +theorem finite_children_work_678_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_678_i1 j) (childrenD_678_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 7 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_382 2 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_678_i1 : FiniteTemplate HasSnaky 6 required_678_i1 envelope_678_i1 := by + refine finite_compose HasSnaky 5 childrenC_678_i1 childrenD_678_i1 finite_children_work_678_i1 (4, 3) + required_678_i1 envelope_678_i1 pivot_mem_678_i1 child_required_sub_678_i1 child_envelope_sub_678_i1 ?_ + intro b hb + exact common_sub_678_i1 (mem_commonEnvelope childrenD_678_i1 b hb) + +theorem finite_children_work_678_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_678_i0 j) (childrenD_678_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 6 (2, 6)).mono (by decide +kernel) + · exact finite_row_works_678_i1.mono (by decide +kernel) + +theorem finite_row_works_678_i0 : FiniteTemplate HasSnaky 7 required_678_i0 envelope_678_i0 := by + refine finite_compose HasSnaky 6 childrenC_678_i0 childrenD_678_i0 finite_children_work_678_i0 (2, 6) + required_678_i0 envelope_678_i0 pivot_mem_678_i0 child_required_sub_678_i0 child_envelope_sub_678_i0 ?_ + intro b hb + exact common_sub_678_i0 (mem_commonEnvelope childrenD_678_i0 b hb) + +theorem finite_children_work_678 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_678 j) (childrenD_678 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_31 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_160 3 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_678_i0.mono (by decide +kernel) + +theorem finite_row_works_678 : FiniteTemplate HasSnaky 8 required_678 envelope_678 := by + refine finite_compose HasSnaky 7 childrenC_678 childrenD_678 finite_children_work_678 (1, 5) + required_678 envelope_678 pivot_mem_678 child_required_sub_678 child_envelope_sub_678 ?_ + intro b hb + exact common_sub_678 (mem_commonEnvelope childrenD_678 b hb) + +theorem finite_children_work_703_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_703_i1 j) (childrenD_703_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 2 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_27 0 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_703_i1 : FiniteTemplate HasSnaky 5 required_703_i1 envelope_703_i1 := by + refine finite_compose HasSnaky 4 childrenC_703_i1 childrenD_703_i1 finite_children_work_703_i1 (5, 3) + required_703_i1 envelope_703_i1 pivot_mem_703_i1 child_required_sub_703_i1 child_envelope_sub_703_i1 ?_ + intro b hb + exact common_sub_703_i1 (mem_commonEnvelope childrenD_703_i1 b hb) + +theorem finite_children_work_703_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_703_i2 j) (childrenD_703_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 4 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_703_i2 : FiniteTemplate HasSnaky 4 required_703_i2 envelope_703_i2 := by + refine finite_compose HasSnaky 3 childrenC_703_i2 childrenD_703_i2 finite_children_work_703_i2 (2, 3) + required_703_i2 envelope_703_i2 pivot_mem_703_i2 child_required_sub_703_i2 child_envelope_sub_703_i2 ?_ + intro b hb + exact common_sub_703_i2 (mem_commonEnvelope childrenD_703_i2 b hb) + +theorem finite_children_work_703_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_703_i3 j) (childrenD_703_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_101 4 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_703_i3 : FiniteTemplate HasSnaky 4 required_703_i3 envelope_703_i3 := by + refine finite_compose HasSnaky 3 childrenC_703_i3 childrenD_703_i3 finite_children_work_703_i3 (3, 2) + required_703_i3 envelope_703_i3 pivot_mem_703_i3 child_required_sub_703_i3 child_envelope_sub_703_i3 ?_ + intro b hb + exact common_sub_703_i3 (mem_commonEnvelope childrenD_703_i3 b hb) + +theorem finite_children_work_703_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_703_i0 j) (childrenD_703_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_195 0 (3, 2)).mono (by decide +kernel) + · exact finite_row_works_703_i1.mono (by decide +kernel) + · exact finite_row_works_703_i2.mono (by decide +kernel) + · exact finite_row_works_703_i3.mono (by decide +kernel) + +theorem finite_row_works_703_i0 : FiniteTemplate HasSnaky 6 required_703_i0 envelope_703_i0 := by + refine finite_compose HasSnaky 5 childrenC_703_i0 childrenD_703_i0 finite_children_work_703_i0 (3, 3) + required_703_i0 envelope_703_i0 pivot_mem_703_i0 child_required_sub_703_i0 child_envelope_sub_703_i0 ?_ + intro b hb + exact common_sub_703_i0 (mem_commonEnvelope childrenD_703_i0 b hb) + +theorem finite_children_work_703_i7 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_703_i7 j) (childrenD_703_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 5 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_103 1 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_157 2 (5, 1)).mono (by decide +kernel) + +theorem finite_row_works_703_i7 : FiniteTemplate HasSnaky 4 required_703_i7 envelope_703_i7 := by + refine finite_compose HasSnaky 3 childrenC_703_i7 childrenD_703_i7 finite_children_work_703_i7 (2, 2) + required_703_i7 envelope_703_i7 pivot_mem_703_i7 child_required_sub_703_i7 child_envelope_sub_703_i7 ?_ + intro b hb + exact common_sub_703_i7 (mem_commonEnvelope childrenD_703_i7 b hb) + +theorem finite_children_work_703_i6 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_703_i6 j) (childrenD_703_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (4, 5)).mono (by decide +kernel) + · exact finite_row_works_703_i7.mono (by decide +kernel) + +theorem finite_row_works_703_i6 : FiniteTemplate HasSnaky 5 required_703_i6 envelope_703_i6 := by + refine finite_compose HasSnaky 4 childrenC_703_i6 childrenD_703_i6 finite_children_work_703_i6 (5, 2) + required_703_i6 envelope_703_i6 pivot_mem_703_i6 child_required_sub_703_i6 child_envelope_sub_703_i6 ?_ + intro b hb + exact common_sub_703_i6 (mem_commonEnvelope childrenD_703_i6 b hb) + +theorem finite_children_work_703_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_703_i5 j) (childrenD_703_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (4, 5)).mono (by decide +kernel) + · exact finite_row_works_703_i6.mono (by decide +kernel) + +theorem finite_row_works_703_i5 : FiniteTemplate HasSnaky 6 required_703_i5 envelope_703_i5 := by + refine finite_compose HasSnaky 5 childrenC_703_i5 childrenD_703_i5 finite_children_work_703_i5 (3, 2) + required_703_i5 envelope_703_i5 pivot_mem_703_i5 child_required_sub_703_i5 child_envelope_sub_703_i5 ?_ + intro b hb + exact common_sub_703_i5 (mem_commonEnvelope childrenD_703_i5 b hb) + +theorem finite_children_work_703_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_703_i4 j) (childrenD_703_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 6 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_703_i5.mono (by decide +kernel) + +theorem finite_row_works_703_i4 : FiniteTemplate HasSnaky 7 required_703_i4 envelope_703_i4 := by + refine finite_compose HasSnaky 6 childrenC_703_i4 childrenD_703_i4 finite_children_work_703_i4 (4, 2) + required_703_i4 envelope_703_i4 pivot_mem_703_i4 child_required_sub_703_i4 child_envelope_sub_703_i4 ?_ + intro b hb + exact common_sub_703_i4 (mem_commonEnvelope childrenD_703_i4 b hb) + +theorem finite_children_work_703_i9 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_703_i9 j) (childrenD_703_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 2 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_77 2 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_703_i9 : FiniteTemplate HasSnaky 5 required_703_i9 envelope_703_i9 := by + refine finite_compose HasSnaky 4 childrenC_703_i9 childrenD_703_i9 finite_children_work_703_i9 (5, 3) + required_703_i9 envelope_703_i9 pivot_mem_703_i9 child_required_sub_703_i9 child_envelope_sub_703_i9 ?_ + intro b hb + exact common_sub_703_i9 (mem_commonEnvelope childrenD_703_i9 b hb) + +theorem finite_children_work_703_i8 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_703_i8 j) (childrenD_703_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_49 5 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_186 0 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_703_i9.mono (by decide +kernel) + +theorem finite_row_works_703_i8 : FiniteTemplate HasSnaky 6 required_703_i8 envelope_703_i8 := by + refine finite_compose HasSnaky 5 childrenC_703_i8 childrenD_703_i8 finite_children_work_703_i8 (4, 6) + required_703_i8 envelope_703_i8 pivot_mem_703_i8 child_required_sub_703_i8 child_envelope_sub_703_i8 ?_ + intro b hb + exact common_sub_703_i8 (mem_commonEnvelope childrenD_703_i8 b hb) + +theorem finite_children_work_703 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_703 j) (childrenD_703 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_369 2 (5, 0)).mono (by decide +kernel) + · exact finite_row_works_703_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_516 4 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_703_i4.mono (by decide +kernel) + · exact finite_row_works_703_i8.mono (by decide +kernel) + +theorem finite_row_works_703 : FiniteTemplate HasSnaky 8 required_703 envelope_703 := by + refine finite_compose HasSnaky 7 childrenC_703 childrenD_703 finite_children_work_703 (4, 3) + required_703 envelope_703 pivot_mem_703 child_required_sub_703 child_envelope_sub_703 ?_ + intro b hb + exact common_sub_703 (mem_commonEnvelope childrenD_703 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height09Part01.lean b/lean/snaky/FiniteCards/Height09Part01.lean new file mode 100644 index 0000000..4b05dd0 --- /dev/null +++ b/lean/snaky/FiniteCards/Height09Part01.lean @@ -0,0 +1,312 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height08Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_322 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_322 j) (childrenD_322 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_321 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_322 : FiniteTemplate HasSnaky 9 required_322 envelope_322 := by + refine finite_compose HasSnaky 8 childrenC_322 childrenD_322 finite_children_work_322 (4, 4) + required_322 envelope_322 pivot_mem_322 child_required_sub_322 child_envelope_sub_322 ?_ + intro b hb + exact common_sub_322 (mem_commonEnvelope childrenD_322 b hb) + +theorem finite_children_work_325 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_325 j) (childrenD_325 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_321 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_325 : FiniteTemplate HasSnaky 9 required_325 envelope_325 := by + refine finite_compose HasSnaky 8 childrenC_325 childrenD_325 finite_children_work_325 (3, 4) + required_325 envelope_325 pivot_mem_325 child_required_sub_325 child_envelope_sub_325 ?_ + intro b hb + exact common_sub_325 (mem_commonEnvelope childrenD_325 b hb) + +theorem finite_children_work_326 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_326 j) (childrenD_326 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 6 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_321 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_326 : FiniteTemplate HasSnaky 9 required_326 envelope_326 := by + refine finite_compose HasSnaky 8 childrenC_326 childrenD_326 finite_children_work_326 (2, 4) + required_326 envelope_326 pivot_mem_326 child_required_sub_326 child_envelope_sub_326 ?_ + intro b hb + exact common_sub_326 (mem_commonEnvelope childrenD_326 b hb) + +theorem finite_children_work_327 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_327 j) (childrenD_327 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_32 0 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_321 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_327 : FiniteTemplate HasSnaky 9 required_327 envelope_327 := by + refine finite_compose HasSnaky 8 childrenC_327 childrenD_327 finite_children_work_327 (4, 4) + required_327 envelope_327 pivot_mem_327 child_required_sub_327 child_envelope_sub_327 ?_ + intro b hb + exact common_sub_327 (mem_commonEnvelope childrenD_327 b hb) + +theorem finite_children_work_328 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_328 j) (childrenD_328 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_321 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_328 : FiniteTemplate HasSnaky 9 required_328 envelope_328 := by + refine finite_compose HasSnaky 8 childrenC_328 childrenD_328 finite_children_work_328 (3, 4) + required_328 envelope_328 pivot_mem_328 child_required_sub_328 child_envelope_sub_328 ?_ + intro b hb + exact common_sub_328 (mem_commonEnvelope childrenD_328 b hb) + +theorem finite_children_work_330 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_330 j) (childrenD_330 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_321 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_330 : FiniteTemplate HasSnaky 9 required_330 envelope_330 := by + refine finite_compose HasSnaky 8 childrenC_330 childrenD_330 finite_children_work_330 (3, 4) + required_330 envelope_330 pivot_mem_330 child_required_sub_330 child_envelope_sub_330 ?_ + intro b hb + exact common_sub_330 (mem_commonEnvelope childrenD_330 b hb) + +theorem finite_children_work_368 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_368 j) (childrenD_368 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_31 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 5 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_189 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_257 5 (7, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_355 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_367 6 (5, 7)).mono (by decide +kernel) + +theorem finite_row_works_368 : FiniteTemplate HasSnaky 9 required_368 envelope_368 := by + refine finite_compose HasSnaky 8 childrenC_368 childrenD_368 finite_children_work_368 (4, 5) + required_368 envelope_368 pivot_mem_368 child_required_sub_368 child_envelope_sub_368 ?_ + intro b hb + exact common_sub_368 (mem_commonEnvelope childrenD_368 b hb) + +theorem finite_children_work_380_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_380_i0 j) (childrenD_380_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_379 1 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_380_i0 : FiniteTemplate HasSnaky 8 required_380_i0 envelope_380_i0 := by + refine finite_compose HasSnaky 7 childrenC_380_i0 childrenD_380_i0 finite_children_work_380_i0 (3, 0) + required_380_i0 envelope_380_i0 pivot_mem_380_i0 child_required_sub_380_i0 child_envelope_sub_380_i0 ?_ + intro b hb + exact common_sub_380_i0 (mem_commonEnvelope childrenD_380_i0 b hb) + +theorem finite_children_work_380 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_380 j) (childrenD_380 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_380_i0.mono (by decide +kernel) + +theorem finite_row_works_380 : FiniteTemplate HasSnaky 9 required_380 envelope_380 := by + refine finite_compose HasSnaky 8 childrenC_380 childrenD_380 finite_children_work_380 (3, 2) + required_380 envelope_380 pivot_mem_380 child_required_sub_380 child_envelope_sub_380 ?_ + intro b hb + exact common_sub_380 (mem_commonEnvelope childrenD_380 b hb) + +theorem finite_children_work_396 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_396 j) (childrenD_396 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_395 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_396 : FiniteTemplate HasSnaky 9 required_396 envelope_396 := by + refine finite_compose HasSnaky 8 childrenC_396 childrenD_396 finite_children_work_396 (2, 6) + required_396 envelope_396 pivot_mem_396 child_required_sub_396 child_envelope_sub_396 ?_ + intro b hb + exact common_sub_396 (mem_commonEnvelope childrenD_396 b hb) + +theorem finite_children_work_397 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_397 j) (childrenD_397 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_161.mono (by decide +kernel) + · exact finite_row_works_162.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_395 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_397 : FiniteTemplate HasSnaky 9 required_397 envelope_397 := by + refine finite_compose HasSnaky 8 childrenC_397 childrenD_397 finite_children_work_397 (3, 3) + required_397 envelope_397 pivot_mem_397 child_required_sub_397 child_envelope_sub_397 ?_ + intro b hb + exact common_sub_397 (mem_commonEnvelope childrenD_397 b hb) + +theorem finite_children_work_398 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_398 j) (childrenD_398 j) := by + intro j + fin_cases j + · exact finite_row_works_171.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 4 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_285.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_395 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_398 : FiniteTemplate HasSnaky 9 required_398 envelope_398 := by + refine finite_compose HasSnaky 8 childrenC_398 childrenD_398 finite_children_work_398 (3, 3) + required_398 envelope_398 pivot_mem_398 child_required_sub_398 child_envelope_sub_398 ?_ + intro b hb + exact common_sub_398 (mem_commonEnvelope childrenD_398 b hb) + +theorem finite_children_work_400 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_400 j) (childrenD_400 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_395 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_400 : FiniteTemplate HasSnaky 9 required_400 envelope_400 := by + refine finite_compose HasSnaky 8 childrenC_400 childrenD_400 finite_children_work_400 (3, 2) + required_400 envelope_400 pivot_mem_400 child_required_sub_400 child_envelope_sub_400 ?_ + intro b hb + exact common_sub_400 (mem_commonEnvelope childrenD_400 b hb) + +theorem finite_children_work_406 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_406 j) (childrenD_406 j) := by + intro j + fin_cases j + · exact finite_row_works_199.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_199 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_405 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_405 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_406 : FiniteTemplate HasSnaky 9 required_406 envelope_406 := by + refine finite_compose HasSnaky 8 childrenC_406 childrenD_406 finite_children_work_406 (1, 4) + required_406 envelope_406 pivot_mem_406 child_required_sub_406 child_envelope_sub_406 ?_ + intro b hb + exact common_sub_406 (mem_commonEnvelope childrenD_406 b hb) + +theorem finite_children_work_407_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_407_i0 j) (childrenD_407_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_404 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_407_i0 : FiniteTemplate HasSnaky 8 required_407_i0 envelope_407_i0 := by + refine finite_compose HasSnaky 7 childrenC_407_i0 childrenD_407_i0 finite_children_work_407_i0 (0, 4) + required_407_i0 envelope_407_i0 pivot_mem_407_i0 child_required_sub_407_i0 child_envelope_sub_407_i0 ?_ + intro b hb + exact common_sub_407_i0 (mem_commonEnvelope childrenD_407_i0 b hb) + +theorem finite_children_work_407 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_407 j) (childrenD_407 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_407_i0.mono (by decide +kernel) + +theorem finite_row_works_407 : FiniteTemplate HasSnaky 9 required_407 envelope_407 := by + refine finite_compose HasSnaky 8 childrenC_407 childrenD_407 finite_children_work_407 (1, 4) + required_407 envelope_407 pivot_mem_407 child_required_sub_407 child_envelope_sub_407 ?_ + intro b hb + exact common_sub_407 (mem_commonEnvelope childrenD_407 b hb) + +theorem finite_children_work_421 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_421 j) (childrenD_421 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_419.mono (by decide +kernel) + +theorem finite_row_works_421 : FiniteTemplate HasSnaky 9 required_421 envelope_421 := by + refine finite_compose HasSnaky 8 childrenC_421 childrenD_421 finite_children_work_421 (1, 4) + required_421 envelope_421 pivot_mem_421 child_required_sub_421 child_envelope_sub_421 ?_ + intro b hb + exact common_sub_421 (mem_commonEnvelope childrenD_421 b hb) + +theorem finite_children_work_434_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_434_i0 j) (childrenD_434_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 4 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_10 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_434_i0 : FiniteTemplate HasSnaky 5 required_434_i0 envelope_434_i0 := by + refine finite_compose HasSnaky 4 childrenC_434_i0 childrenD_434_i0 finite_children_work_434_i0 (5, 1) + required_434_i0 envelope_434_i0 pivot_mem_434_i0 child_required_sub_434_i0 child_envelope_sub_434_i0 ?_ + intro b hb + exact common_sub_434_i0 (mem_commonEnvelope childrenD_434_i0 b hb) + +theorem finite_children_work_434_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_434_i1 j) (childrenD_434_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 5 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_41 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_253 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_256 5 (7, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_336 0 (3, 1)).mono (by decide +kernel) + +theorem finite_row_works_434_i1 : FiniteTemplate HasSnaky 8 required_434_i1 envelope_434_i1 := by + refine finite_compose HasSnaky 7 childrenC_434_i1 childrenD_434_i1 finite_children_work_434_i1 (4, 4) + required_434_i1 envelope_434_i1 pivot_mem_434_i1 child_required_sub_434_i1 child_envelope_sub_434_i1 ?_ + intro b hb + exact common_sub_434_i1 (mem_commonEnvelope childrenD_434_i1 b hb) + +theorem finite_children_work_434 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_434 j) (childrenD_434 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_80 5 (5, 1)).mono (by decide +kernel) + · exact finite_row_works_434_i0.mono (by decide +kernel) + · exact finite_row_works_434_i1.mono (by decide +kernel) + +theorem finite_row_works_434 : FiniteTemplate HasSnaky 9 required_434 envelope_434 := by + refine finite_compose HasSnaky 8 childrenC_434 childrenD_434 finite_children_work_434 (3, 2) + required_434 envelope_434 pivot_mem_434 child_required_sub_434 child_envelope_sub_434 ?_ + intro b hb + exact common_sub_434 (mem_commonEnvelope childrenD_434 b hb) + +theorem finite_children_work_441 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_441 j) (childrenD_441 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_28 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_58 2 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_440.mono (by decide +kernel) + +theorem finite_row_works_441 : FiniteTemplate HasSnaky 9 required_441 envelope_441 := by + refine finite_compose HasSnaky 8 childrenC_441 childrenD_441 finite_children_work_441 (3, 3) + required_441 envelope_441 pivot_mem_441 child_required_sub_441 child_envelope_sub_441 ?_ + intro b hb + exact common_sub_441 (mem_commonEnvelope childrenD_441 b hb) + +theorem finite_children_work_442 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_442 j) (childrenD_442 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_40 7 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_149 7 (5, 4)).mono (by decide +kernel) + · exact finite_row_works_440.mono (by decide +kernel) + +theorem finite_row_works_442 : FiniteTemplate HasSnaky 9 required_442 envelope_442 := by + refine finite_compose HasSnaky 8 childrenC_442 childrenD_442 finite_children_work_442 (3, 3) + required_442 envelope_442 pivot_mem_442 child_required_sub_442 child_envelope_sub_442 ?_ + intro b hb + exact common_sub_442 (mem_commonEnvelope childrenD_442 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height09Part02.lean b/lean/snaky/FiniteCards/Height09Part02.lean new file mode 100644 index 0000000..c1c9c27 --- /dev/null +++ b/lean/snaky/FiniteCards/Height09Part02.lean @@ -0,0 +1,245 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_443_i6 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_443_i6 j) (childrenD_443_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 2 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 1 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_443_i6 : FiniteTemplate HasSnaky 2 required_443_i6 envelope_443_i6 := by + refine finite_compose HasSnaky 1 childrenC_443_i6 childrenD_443_i6 finite_children_work_443_i6 (5, 3) + required_443_i6 envelope_443_i6 pivot_mem_443_i6 child_required_sub_443_i6 child_envelope_sub_443_i6 ?_ + intro b hb + exact common_sub_443_i6 (mem_commonEnvelope childrenD_443_i6 b hb) + +theorem finite_children_work_443_i5 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_443_i5 j) (childrenD_443_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (4, 0)).mono (by decide +kernel) + · exact finite_row_works_443_i6.mono (by decide +kernel) + +theorem finite_row_works_443_i5 : FiniteTemplate HasSnaky 3 required_443_i5 envelope_443_i5 := by + refine finite_compose HasSnaky 2 childrenC_443_i5 childrenD_443_i5 finite_children_work_443_i5 (3, 3) + required_443_i5 envelope_443_i5 pivot_mem_443_i5 child_required_sub_443_i5 child_envelope_sub_443_i5 ?_ + intro b hb + exact common_sub_443_i5 (mem_commonEnvelope childrenD_443_i5 b hb) + +theorem finite_children_work_443_i4 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_443_i4 j) (childrenD_443_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_443_i5.mono (by decide +kernel) + +theorem finite_row_works_443_i4 : FiniteTemplate HasSnaky 4 required_443_i4 envelope_443_i4 := by + refine finite_compose HasSnaky 3 childrenC_443_i4 childrenD_443_i4 finite_children_work_443_i4 (4, 1) + required_443_i4 envelope_443_i4 pivot_mem_443_i4 child_required_sub_443_i4 child_envelope_sub_443_i4 ?_ + intro b hb + exact common_sub_443_i4 (mem_commonEnvelope childrenD_443_i4 b hb) + +theorem finite_children_work_443_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_443_i3 j) (childrenD_443_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_443_i4.mono (by decide +kernel) + +theorem finite_row_works_443_i3 : FiniteTemplate HasSnaky 5 required_443_i3 envelope_443_i3 := by + refine finite_compose HasSnaky 4 childrenC_443_i3 childrenD_443_i3 finite_children_work_443_i3 (2, 4) + required_443_i3 envelope_443_i3 pivot_mem_443_i3 child_required_sub_443_i3 child_envelope_sub_443_i3 ?_ + intro b hb + exact common_sub_443_i3 (mem_commonEnvelope childrenD_443_i3 b hb) + +theorem finite_children_work_443_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_443_i2 j) (childrenD_443_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_443_i3.mono (by decide +kernel) + +theorem finite_row_works_443_i2 : FiniteTemplate HasSnaky 6 required_443_i2 envelope_443_i2 := by + refine finite_compose HasSnaky 5 childrenC_443_i2 childrenD_443_i2 finite_children_work_443_i2 (4, 0) + required_443_i2 envelope_443_i2 pivot_mem_443_i2 child_required_sub_443_i2 child_envelope_sub_443_i2 ?_ + intro b hb + exact common_sub_443_i2 (mem_commonEnvelope childrenD_443_i2 b hb) + +theorem finite_children_work_443_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_443_i1 j) (childrenD_443_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_443_i2.mono (by decide +kernel) + +theorem finite_row_works_443_i1 : FiniteTemplate HasSnaky 7 required_443_i1 envelope_443_i1 := by + refine finite_compose HasSnaky 6 childrenC_443_i1 childrenD_443_i1 finite_children_work_443_i1 (3, 1) + required_443_i1 envelope_443_i1 pivot_mem_443_i1 child_required_sub_443_i1 child_envelope_sub_443_i1 ?_ + intro b hb + exact common_sub_443_i1 (mem_commonEnvelope childrenD_443_i1 b hb) + +theorem finite_children_work_443_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_443_i0 j) (childrenD_443_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_443_i1.mono (by decide +kernel) + +theorem finite_row_works_443_i0 : FiniteTemplate HasSnaky 8 required_443_i0 envelope_443_i0 := by + refine finite_compose HasSnaky 7 childrenC_443_i0 childrenD_443_i0 finite_children_work_443_i0 (0, 1) + required_443_i0 envelope_443_i0 pivot_mem_443_i0 child_required_sub_443_i0 child_envelope_sub_443_i0 ?_ + intro b hb + exact common_sub_443_i0 (mem_commonEnvelope childrenD_443_i0 b hb) + +theorem finite_children_work_443 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_443 j) (childrenD_443 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_443_i0.mono (by decide +kernel) + +theorem finite_row_works_443 : FiniteTemplate HasSnaky 9 required_443 envelope_443 := by + refine finite_compose HasSnaky 8 childrenC_443 childrenD_443 finite_children_work_443 (2, 1) + required_443 envelope_443 pivot_mem_443 child_required_sub_443 child_envelope_sub_443 ?_ + intro b hb + exact common_sub_443 (mem_commonEnvelope childrenD_443 b hb) + +theorem finite_children_work_449 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_449 j) (childrenD_449 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_27 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_48 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_63 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_448.mono (by decide +kernel) + +theorem finite_row_works_449 : FiniteTemplate HasSnaky 9 required_449 envelope_449 := by + refine finite_compose HasSnaky 8 childrenC_449 childrenD_449 finite_children_work_449 (4, 3) + required_449 envelope_449 pivot_mem_449 child_required_sub_449 child_envelope_sub_449 ?_ + intro b hb + exact common_sub_449 (mem_commonEnvelope childrenD_449 b hb) + +theorem finite_children_work_450 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_450 j) (childrenD_450 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_448 4 (0, 7)).mono (by decide +kernel) + +theorem finite_row_works_450 : FiniteTemplate HasSnaky 9 required_450 envelope_450 := by + refine finite_compose HasSnaky 8 childrenC_450 childrenD_450 finite_children_work_450 (3, 4) + required_450 envelope_450 pivot_mem_450 child_required_sub_450 child_envelope_sub_450 ?_ + intro b hb + exact common_sub_450 (mem_commonEnvelope childrenD_450 b hb) + +theorem finite_children_work_457 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_457 j) (childrenD_457 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_456 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_457 : FiniteTemplate HasSnaky 9 required_457 envelope_457 := by + refine finite_compose HasSnaky 8 childrenC_457 childrenD_457 finite_children_work_457 (1, 4) + required_457 envelope_457 pivot_mem_457 child_required_sub_457 child_envelope_sub_457 ?_ + intro b hb + exact common_sub_457 (mem_commonEnvelope childrenD_457 b hb) + +theorem finite_children_work_458 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_458 j) (childrenD_458 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_9.mono (by decide +kernel) + · exact finite_row_works_62.mono (by decide +kernel) + · exact finite_row_works_456.mono (by decide +kernel) + +theorem finite_row_works_458 : FiniteTemplate HasSnaky 9 required_458 envelope_458 := by + refine finite_compose HasSnaky 8 childrenC_458 childrenD_458 finite_children_work_458 (1, 4) + required_458 envelope_458 pivot_mem_458 child_required_sub_458 child_envelope_sub_458 ?_ + intro b hb + exact common_sub_458 (mem_commonEnvelope childrenD_458 b hb) + +theorem finite_children_work_470_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_470_i0 j) (childrenD_470_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 6 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 6 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_470_i0 : FiniteTemplate HasSnaky 4 required_470_i0 envelope_470_i0 := by + refine finite_compose HasSnaky 3 childrenC_470_i0 childrenD_470_i0 finite_children_work_470_i0 (2, 3) + required_470_i0 envelope_470_i0 pivot_mem_470_i0 child_required_sub_470_i0 child_envelope_sub_470_i0 ?_ + intro b hb + exact common_sub_470_i0 (mem_commonEnvelope childrenD_470_i0 b hb) + +theorem finite_children_work_470_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_470_i2 j) (childrenD_470_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 7 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 6 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_470_i2 : FiniteTemplate HasSnaky 4 required_470_i2 envelope_470_i2 := by + refine finite_compose HasSnaky 3 childrenC_470_i2 childrenD_470_i2 finite_children_work_470_i2 (2, 3) + required_470_i2 envelope_470_i2 pivot_mem_470_i2 child_required_sub_470_i2 child_envelope_sub_470_i2 ?_ + intro b hb + exact common_sub_470_i2 (mem_commonEnvelope childrenD_470_i2 b hb) + +theorem finite_children_work_470_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_470_i1 j) (childrenD_470_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_56 4 (1, 8)).mono (by decide +kernel) + · exact finite_row_works_470_i2.mono (by decide +kernel) + +theorem finite_row_works_470_i1 : FiniteTemplate HasSnaky 5 required_470_i1 envelope_470_i1 := by + refine finite_compose HasSnaky 4 childrenC_470_i1 childrenD_470_i1 finite_children_work_470_i1 (3, 6) + required_470_i1 envelope_470_i1 pivot_mem_470_i1 child_required_sub_470_i1 child_envelope_sub_470_i1 ?_ + intro b hb + exact common_sub_470_i1 (mem_commonEnvelope childrenD_470_i1 b hb) + +theorem finite_children_work_470 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_470 j) (childrenD_470 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_319 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_335 4 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_470_i0.mono (by decide +kernel) + · exact finite_row_works_470_i1.mono (by decide +kernel) + +theorem finite_row_works_470 : FiniteTemplate HasSnaky 9 required_470 envelope_470 := by + refine finite_compose HasSnaky 8 childrenC_470 childrenD_470 finite_children_work_470 (3, 3) + required_470 envelope_470 pivot_mem_470 child_required_sub_470 child_envelope_sub_470 ?_ + intro b hb + exact common_sub_470 (mem_commonEnvelope childrenD_470 b hb) + +theorem finite_children_work_474 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_474 j) (childrenD_474 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_473 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_474 : FiniteTemplate HasSnaky 9 required_474 envelope_474 := by + refine finite_compose HasSnaky 8 childrenC_474 childrenD_474 finite_children_work_474 (4, 2) + required_474 envelope_474 pivot_mem_474 child_required_sub_474 child_envelope_sub_474 ?_ + intro b hb + exact common_sub_474 (mem_commonEnvelope childrenD_474 b hb) + +theorem finite_children_work_477 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_477 j) (childrenD_477 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_62 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_473.mono (by decide +kernel) + +theorem finite_row_works_477 : FiniteTemplate HasSnaky 9 required_477 envelope_477 := by + refine finite_compose HasSnaky 8 childrenC_477 childrenD_477 finite_children_work_477 (4, 2) + required_477 envelope_477 pivot_mem_477 child_required_sub_477 child_envelope_sub_477 ?_ + intro b hb + exact common_sub_477 (mem_commonEnvelope childrenD_477 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height09Part03.lean b/lean/snaky/FiniteCards/Height09Part03.lean new file mode 100644 index 0000000..4226f7f --- /dev/null +++ b/lean/snaky/FiniteCards/Height09Part03.lean @@ -0,0 +1,293 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height06Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part02 +import FiniteCards.Height08Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_512_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_512_i0 j) (childrenD_512_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_69 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_416 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_512_i0 : FiniteTemplate HasSnaky 6 required_512_i0 envelope_512_i0 := by + refine finite_compose HasSnaky 5 childrenC_512_i0 childrenD_512_i0 finite_children_work_512_i0 (3, 3) + required_512_i0 envelope_512_i0 pivot_mem_512_i0 child_required_sub_512_i0 child_envelope_sub_512_i0 ?_ + intro b hb + exact common_sub_512_i0 (mem_commonEnvelope childrenD_512_i0 b hb) + +theorem finite_children_work_512_i3 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_512_i3 j) (childrenD_512_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 0 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_512_i3 : FiniteTemplate HasSnaky 2 required_512_i3 envelope_512_i3 := by + refine finite_compose HasSnaky 1 childrenC_512_i3 childrenD_512_i3 finite_children_work_512_i3 (3, 4) + required_512_i3 envelope_512_i3 pivot_mem_512_i3 child_required_sub_512_i3 child_envelope_sub_512_i3 ?_ + intro b hb + exact common_sub_512_i3 (mem_commonEnvelope childrenD_512_i3 b hb) + +theorem finite_children_work_512_i4 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_512_i4 j) (childrenD_512_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_382 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_512_i4 : FiniteTemplate HasSnaky 6 required_512_i4 envelope_512_i4 := by + refine finite_compose HasSnaky 5 childrenC_512_i4 childrenD_512_i4 finite_children_work_512_i4 (3, 6) + required_512_i4 envelope_512_i4 pivot_mem_512_i4 child_required_sub_512_i4 child_envelope_sub_512_i4 ?_ + intro b hb + exact common_sub_512_i4 (mem_commonEnvelope childrenD_512_i4 b hb) + +theorem finite_children_work_512_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_512_i2 j) (childrenD_512_i2 j) := by + intro j + fin_cases j + · exact finite_row_works_512_i3.mono (by decide +kernel) + · exact finite_row_works_512_i4.mono (by decide +kernel) + +theorem finite_row_works_512_i2 : FiniteTemplate HasSnaky 7 required_512_i2 envelope_512_i2 := by + refine finite_compose HasSnaky 6 childrenC_512_i2 childrenD_512_i2 finite_children_work_512_i2 (4, 5) + required_512_i2 envelope_512_i2 pivot_mem_512_i2 child_required_sub_512_i2 child_envelope_sub_512_i2 ?_ + intro b hb + exact common_sub_512_i2 (mem_commonEnvelope childrenD_512_i2 b hb) + +theorem finite_children_work_512_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_512_i1 j) (childrenD_512_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_30 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_59 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_511 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_512_i2.mono (by decide +kernel) + +theorem finite_row_works_512_i1 : FiniteTemplate HasSnaky 8 required_512_i1 envelope_512_i1 := by + refine finite_compose HasSnaky 7 childrenC_512_i1 childrenD_512_i1 finite_children_work_512_i1 (4, 4) + required_512_i1 envelope_512_i1 pivot_mem_512_i1 child_required_sub_512_i1 child_envelope_sub_512_i1 ?_ + intro b hb + exact common_sub_512_i1 (mem_commonEnvelope childrenD_512_i1 b hb) + +theorem finite_children_work_512 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_512 j) (childrenD_512 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_74 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_108 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_512_i0.mono (by decide +kernel) + · exact finite_row_works_512_i1.mono (by decide +kernel) + +theorem finite_row_works_512 : FiniteTemplate HasSnaky 9 required_512 envelope_512 := by + refine finite_compose HasSnaky 8 childrenC_512 childrenD_512 finite_children_work_512 (4, 3) + required_512 envelope_512 pivot_mem_512 child_required_sub_512 child_envelope_sub_512 ?_ + intro b hb + exact common_sub_512 (mem_commonEnvelope childrenD_512 b hb) + +theorem finite_children_work_514 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_514 j) (childrenD_514 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_34 7 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_149 5 (5, 1)).mono (by decide +kernel) + · exact finite_row_works_513.mono (by decide +kernel) + +theorem finite_row_works_514 : FiniteTemplate HasSnaky 9 required_514 envelope_514 := by + refine finite_compose HasSnaky 8 childrenC_514 childrenD_514 finite_children_work_514 (3, 2) + required_514 envelope_514 pivot_mem_514 child_required_sub_514 child_envelope_sub_514 ?_ + intro b hb + exact common_sub_514 (mem_commonEnvelope childrenD_514 b hb) + +theorem finite_children_work_519 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_519 j) (childrenD_519 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_47 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_518 2 (6, 0)).mono (by decide +kernel) + +theorem finite_row_works_519 : FiniteTemplate HasSnaky 9 required_519 envelope_519 := by + refine finite_compose HasSnaky 8 childrenC_519 childrenD_519 finite_children_work_519 (3, 5) + required_519 envelope_519 pivot_mem_519 child_required_sub_519 child_envelope_sub_519 ?_ + intro b hb + exact common_sub_519 (mem_commonEnvelope childrenD_519 b hb) + +theorem finite_children_work_528_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_528_i0 j) (childrenD_528_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 5 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_49 7 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_528_i0 : FiniteTemplate HasSnaky 5 required_528_i0 envelope_528_i0 := by + refine finite_compose HasSnaky 4 childrenC_528_i0 childrenD_528_i0 finite_children_work_528_i0 (1, 3) + required_528_i0 envelope_528_i0 pivot_mem_528_i0 child_required_sub_528_i0 child_envelope_sub_528_i0 ?_ + intro b hb + exact common_sub_528_i0 (mem_commonEnvelope childrenD_528_i0 b hb) + +theorem finite_children_work_528_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_528_i1 j) (childrenD_528_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_446 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_528_i1 : FiniteTemplate HasSnaky 8 required_528_i1 envelope_528_i1 := by + refine finite_compose HasSnaky 7 childrenC_528_i1 childrenD_528_i1 finite_children_work_528_i1 (1, 7) + required_528_i1 envelope_528_i1 pivot_mem_528_i1 child_required_sub_528_i1 child_envelope_sub_528_i1 ?_ + intro b hb + exact common_sub_528_i1 (mem_commonEnvelope childrenD_528_i1 b hb) + +theorem finite_children_work_528 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_528 j) (childrenD_528 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_61 2 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_528_i0.mono (by decide +kernel) + · exact finite_row_works_528_i1.mono (by decide +kernel) + +theorem finite_row_works_528 : FiniteTemplate HasSnaky 9 required_528 envelope_528 := by + refine finite_compose HasSnaky 8 childrenC_528 childrenD_528 finite_children_work_528 (0, 7) + required_528 envelope_528 pivot_mem_528 child_required_sub_528 child_envelope_sub_528 ?_ + intro b hb + exact common_sub_528 (mem_commonEnvelope childrenD_528 b hb) + +theorem finite_children_work_531 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_531 j) (childrenD_531 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact finite_row_works_530.mono (by decide +kernel) + +theorem finite_row_works_531 : FiniteTemplate HasSnaky 9 required_531 envelope_531 := by + refine finite_compose HasSnaky 8 childrenC_531 childrenD_531 finite_children_work_531 (1, 4) + required_531 envelope_531 pivot_mem_531 child_required_sub_531 child_envelope_sub_531 ?_ + intro b hb + exact common_sub_531 (mem_commonEnvelope childrenD_531 b hb) + +theorem finite_children_work_536 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_536 j) (childrenD_536 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_88 7 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_213 5 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_534 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_536 : FiniteTemplate HasSnaky 9 required_536 envelope_536 := by + refine finite_compose HasSnaky 8 childrenC_536 childrenD_536 finite_children_work_536 (3, 5) + required_536 envelope_536 pivot_mem_536 child_required_sub_536 child_envelope_sub_536 ?_ + intro b hb + exact common_sub_536 (mem_commonEnvelope childrenD_536 b hb) + +theorem finite_children_work_537_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_537_i0 j) (childrenD_537_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_45 6 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_418 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_537_i0 : FiniteTemplate HasSnaky 8 required_537_i0 envelope_537_i0 := by + refine finite_compose HasSnaky 7 childrenC_537_i0 childrenD_537_i0 finite_children_work_537_i0 (3, 3) + required_537_i0 envelope_537_i0 pivot_mem_537_i0 child_required_sub_537_i0 child_envelope_sub_537_i0 ?_ + intro b hb + exact common_sub_537_i0 (mem_commonEnvelope childrenD_537_i0 b hb) + +theorem finite_children_work_537_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_537_i2 j) (childrenD_537_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_425 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_537_i2 : FiniteTemplate HasSnaky 6 required_537_i2 envelope_537_i2 := by + refine finite_compose HasSnaky 5 childrenC_537_i2 childrenD_537_i2 finite_children_work_537_i2 (2, 5) + required_537_i2 envelope_537_i2 pivot_mem_537_i2 child_required_sub_537_i2 child_envelope_sub_537_i2 ?_ + intro b hb + exact common_sub_537_i2 (mem_commonEnvelope childrenD_537_i2 b hb) + +theorem finite_children_work_537_i6 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_537_i6 j) (childrenD_537_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_23 2 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_537_i6 : FiniteTemplate HasSnaky 3 required_537_i6 envelope_537_i6 := by + refine finite_compose HasSnaky 2 childrenC_537_i6 childrenD_537_i6 finite_children_work_537_i6 (2, 5) + required_537_i6 envelope_537_i6 pivot_mem_537_i6 child_required_sub_537_i6 child_envelope_sub_537_i6 ?_ + intro b hb + exact common_sub_537_i6 (mem_commonEnvelope childrenD_537_i6 b hb) + +theorem finite_children_work_537_i5 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_537_i5 j) (childrenD_537_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 5 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_537_i6.mono (by decide +kernel) + +theorem finite_row_works_537_i5 : FiniteTemplate HasSnaky 4 required_537_i5 envelope_537_i5 := by + refine finite_compose HasSnaky 3 childrenC_537_i5 childrenD_537_i5 finite_children_work_537_i5 (3, 5) + required_537_i5 envelope_537_i5 pivot_mem_537_i5 child_required_sub_537_i5 child_envelope_sub_537_i5 ?_ + intro b hb + exact common_sub_537_i5 (mem_commonEnvelope childrenD_537_i5 b hb) + +theorem finite_children_work_537_i4 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_537_i4 j) (childrenD_537_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_139 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_382 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_537_i5.mono (by decide +kernel) + +theorem finite_row_works_537_i4 : FiniteTemplate HasSnaky 6 required_537_i4 envelope_537_i4 := by + refine finite_compose HasSnaky 5 childrenC_537_i4 childrenD_537_i4 finite_children_work_537_i4 (3, 6) + required_537_i4 envelope_537_i4 pivot_mem_537_i4 child_required_sub_537_i4 child_envelope_sub_537_i4 ?_ + intro b hb + exact common_sub_537_i4 (mem_commonEnvelope childrenD_537_i4 b hb) + +theorem finite_children_work_537_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_537_i3 j) (childrenD_537_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 2 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_30 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_537_i4.mono (by decide +kernel) + +theorem finite_row_works_537_i3 : FiniteTemplate HasSnaky 7 required_537_i3 envelope_537_i3 := by + refine finite_compose HasSnaky 6 childrenC_537_i3 childrenD_537_i3 finite_children_work_537_i3 (4, 4) + required_537_i3 envelope_537_i3 pivot_mem_537_i3 child_required_sub_537_i3 child_envelope_sub_537_i3 ?_ + intro b hb + exact common_sub_537_i3 (mem_commonEnvelope childrenD_537_i3 b hb) + +theorem finite_children_work_537_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_537_i1 j) (childrenD_537_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_166 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_464 4 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_537_i2.mono (by decide +kernel) + · exact finite_row_works_537_i3.mono (by decide +kernel) + +theorem finite_row_works_537_i1 : FiniteTemplate HasSnaky 8 required_537_i1 envelope_537_i1 := by + refine finite_compose HasSnaky 7 childrenC_537_i1 childrenD_537_i1 finite_children_work_537_i1 (4, 5) + required_537_i1 envelope_537_i1 pivot_mem_537_i1 child_required_sub_537_i1 child_envelope_sub_537_i1 ?_ + intro b hb + exact common_sub_537_i1 (mem_commonEnvelope childrenD_537_i1 b hb) + +theorem finite_children_work_537 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_537 j) (childrenD_537 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_74 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_108 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_537_i0.mono (by decide +kernel) + · exact finite_row_works_537_i1.mono (by decide +kernel) + +theorem finite_row_works_537 : FiniteTemplate HasSnaky 9 required_537 envelope_537 := by + refine finite_compose HasSnaky 8 childrenC_537 childrenD_537 finite_children_work_537 (4, 3) + required_537 envelope_537 pivot_mem_537 child_required_sub_537 child_envelope_sub_537 ?_ + intro b hb + exact common_sub_537 (mem_commonEnvelope childrenD_537 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height09Part04.lean b/lean/snaky/FiniteCards/Height09Part04.lean new file mode 100644 index 0000000..5df68f2 --- /dev/null +++ b/lean/snaky/FiniteCards/Height09Part04.lean @@ -0,0 +1,303 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height07Part02 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_539_i4 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_539_i4 j) (childrenD_539_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 4 (3, 5)).mono (by decide +kernel) + +theorem finite_row_works_539_i4 : FiniteTemplate HasSnaky 3 required_539_i4 envelope_539_i4 := by + refine finite_compose HasSnaky 2 childrenC_539_i4 childrenD_539_i4 finite_children_work_539_i4 (3, 5) + required_539_i4 envelope_539_i4 pivot_mem_539_i4 child_required_sub_539_i4 child_envelope_sub_539_i4 ?_ + intro b hb + exact common_sub_539_i4 (mem_commonEnvelope childrenD_539_i4 b hb) + +theorem finite_children_work_539_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_539_i3 j) (childrenD_539_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_539_i4.mono (by decide +kernel) + +theorem finite_row_works_539_i3 : FiniteTemplate HasSnaky 4 required_539_i3 envelope_539_i3 := by + refine finite_compose HasSnaky 3 childrenC_539_i3 childrenD_539_i3 finite_children_work_539_i3 (3, 4) + required_539_i3 envelope_539_i3 pivot_mem_539_i3 child_required_sub_539_i3 child_envelope_sub_539_i3 ?_ + intro b hb + exact common_sub_539_i3 (mem_commonEnvelope childrenD_539_i3 b hb) + +theorem finite_children_work_539_i7 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_539_i7 j) (childrenD_539_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_153 2 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_539_i7 : FiniteTemplate HasSnaky 3 required_539_i7 envelope_539_i7 := by + refine finite_compose HasSnaky 2 childrenC_539_i7 childrenD_539_i7 finite_children_work_539_i7 (4, 2) + required_539_i7 envelope_539_i7 pivot_mem_539_i7 child_required_sub_539_i7 child_envelope_sub_539_i7 ?_ + intro b hb + exact common_sub_539_i7 (mem_commonEnvelope childrenD_539_i7 b hb) + +theorem finite_children_work_539_i6 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_539_i6 j) (childrenD_539_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_539_i7.mono (by decide +kernel) + +theorem finite_row_works_539_i6 : FiniteTemplate HasSnaky 4 required_539_i6 envelope_539_i6 := by + refine finite_compose HasSnaky 3 childrenC_539_i6 childrenD_539_i6 finite_children_work_539_i6 (3, 5) + required_539_i6 envelope_539_i6 pivot_mem_539_i6 child_required_sub_539_i6 child_envelope_sub_539_i6 ?_ + intro b hb + exact common_sub_539_i6 (mem_commonEnvelope childrenD_539_i6 b hb) + +theorem finite_children_work_539_i5 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_539_i5 j) (childrenD_539_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_539_i6.mono (by decide +kernel) + +theorem finite_row_works_539_i5 : FiniteTemplate HasSnaky 5 required_539_i5 envelope_539_i5 := by + refine finite_compose HasSnaky 4 childrenC_539_i5 childrenD_539_i5 finite_children_work_539_i5 (3, 4) + required_539_i5 envelope_539_i5 pivot_mem_539_i5 child_required_sub_539_i5 child_envelope_sub_539_i5 ?_ + intro b hb + exact common_sub_539_i5 (mem_commonEnvelope childrenD_539_i5 b hb) + +theorem finite_children_work_539_i9 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_539_i9 j) (childrenD_539_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_2 7 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_539_i9 : FiniteTemplate HasSnaky 2 required_539_i9 envelope_539_i9 := by + refine finite_compose HasSnaky 1 childrenC_539_i9 childrenD_539_i9 finite_children_work_539_i9 (1, 2) + required_539_i9 envelope_539_i9 pivot_mem_539_i9 child_required_sub_539_i9 child_envelope_sub_539_i9 ?_ + intro b hb + exact common_sub_539_i9 (mem_commonEnvelope childrenD_539_i9 b hb) + +theorem finite_children_work_539_i8 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_539_i8 j) (childrenD_539_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_539_i9.mono (by decide +kernel) + +theorem finite_row_works_539_i8 : FiniteTemplate HasSnaky 3 required_539_i8 envelope_539_i8 := by + refine finite_compose HasSnaky 2 childrenC_539_i8 childrenD_539_i8 finite_children_work_539_i8 (1, 1) + required_539_i8 envelope_539_i8 pivot_mem_539_i8 child_required_sub_539_i8 child_envelope_sub_539_i8 ?_ + intro b hb + exact common_sub_539_i8 (mem_commonEnvelope childrenD_539_i8 b hb) + +theorem finite_children_work_539_i10 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_539_i10 j) (childrenD_539_i10 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_83 0 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_281 5 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_539_i10 : FiniteTemplate HasSnaky 3 required_539_i10 envelope_539_i10 := by + refine finite_compose HasSnaky 2 childrenC_539_i10 childrenD_539_i10 finite_children_work_539_i10 (4, 1) + required_539_i10 envelope_539_i10 pivot_mem_539_i10 child_required_sub_539_i10 child_envelope_sub_539_i10 ?_ + intro b hb + exact common_sub_539_i10 (mem_commonEnvelope childrenD_539_i10 b hb) + +theorem finite_children_work_539_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_539_i2 j) (childrenD_539_i2 j) := by + intro j + fin_cases j + · exact finite_row_works_539_i3.mono (by decide +kernel) + · exact finite_row_works_539_i5.mono (by decide +kernel) + · exact finite_row_works_539_i8.mono (by decide +kernel) + · exact finite_row_works_539_i10.mono (by decide +kernel) + +theorem finite_row_works_539_i2 : FiniteTemplate HasSnaky 6 required_539_i2 envelope_539_i2 := by + refine finite_compose HasSnaky 5 childrenC_539_i2 childrenD_539_i2 finite_children_work_539_i2 (2, 1) + required_539_i2 envelope_539_i2 pivot_mem_539_i2 child_required_sub_539_i2 child_envelope_sub_539_i2 ?_ + intro b hb + exact common_sub_539_i2 (mem_commonEnvelope childrenD_539_i2 b hb) + +theorem finite_children_work_539_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_539_i1 j) (childrenD_539_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 3 (1, 9)).mono (by decide +kernel) + · exact finite_row_works_539_i2.mono (by decide +kernel) + +theorem finite_row_works_539_i1 : FiniteTemplate HasSnaky 7 required_539_i1 envelope_539_i1 := by + refine finite_compose HasSnaky 6 childrenC_539_i1 childrenD_539_i1 finite_children_work_539_i1 (2, 5) + required_539_i1 envelope_539_i1 pivot_mem_539_i1 child_required_sub_539_i1 child_envelope_sub_539_i1 ?_ + intro b hb + exact common_sub_539_i1 (mem_commonEnvelope childrenD_539_i1 b hb) + +theorem finite_children_work_539_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_539_i0 j) (childrenD_539_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 8)).mono (by decide +kernel) + · exact finite_row_works_539_i1.mono (by decide +kernel) + +theorem finite_row_works_539_i0 : FiniteTemplate HasSnaky 8 required_539_i0 envelope_539_i0 := by + refine finite_compose HasSnaky 7 childrenC_539_i0 childrenD_539_i0 finite_children_work_539_i0 (0, 5) + required_539_i0 envelope_539_i0 pivot_mem_539_i0 child_required_sub_539_i0 child_envelope_sub_539_i0 ?_ + intro b hb + exact common_sub_539_i0 (mem_commonEnvelope childrenD_539_i0 b hb) + +theorem finite_children_work_539 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_539 j) (childrenD_539 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_539_i0.mono (by decide +kernel) + +theorem finite_row_works_539 : FiniteTemplate HasSnaky 9 required_539 envelope_539 := by + refine finite_compose HasSnaky 8 childrenC_539 childrenD_539 finite_children_work_539 (1, 9) + required_539 envelope_539 pivot_mem_539 child_required_sub_539 child_envelope_sub_539 ?_ + intro b hb + exact common_sub_539 (mem_commonEnvelope childrenD_539 b hb) + +theorem finite_children_work_548 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_548 j) (childrenD_548 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 2 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 4 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_189 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_547 4 (0, 8)).mono (by decide +kernel) + +theorem finite_row_works_548 : FiniteTemplate HasSnaky 9 required_548 envelope_548 := by + refine finite_compose HasSnaky 8 childrenC_548 childrenD_548 finite_children_work_548 (1, 7) + required_548 envelope_548 pivot_mem_548 child_required_sub_548 child_envelope_sub_548 ?_ + intro b hb + exact common_sub_548 (mem_commonEnvelope childrenD_548 b hb) + +theorem finite_children_work_549 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_549 j) (childrenD_549 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_63 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_547 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_549 : FiniteTemplate HasSnaky 9 required_549 envelope_549 := by + refine finite_compose HasSnaky 8 childrenC_549 childrenD_549 finite_children_work_549 (1, 3) + required_549 envelope_549 pivot_mem_549 child_required_sub_549 child_envelope_sub_549 ?_ + intro b hb + exact common_sub_549 (mem_commonEnvelope childrenD_549 b hb) + +theorem finite_children_work_561_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_561_i0 j) (childrenD_561_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 7 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_57 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_561_i0 : FiniteTemplate HasSnaky 5 required_561_i0 envelope_561_i0 := by + refine finite_compose HasSnaky 4 childrenC_561_i0 childrenD_561_i0 finite_children_work_561_i0 (2, 4) + required_561_i0 envelope_561_i0 pivot_mem_561_i0 child_required_sub_561_i0 child_envelope_sub_561_i0 ?_ + intro b hb + exact common_sub_561_i0 (mem_commonEnvelope childrenD_561_i0 b hb) + +theorem finite_children_work_561 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_561 j) (childrenD_561 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_154 0 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_319 4 (0, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_335 0 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_561_i0.mono (by decide +kernel) + +theorem finite_row_works_561 : FiniteTemplate HasSnaky 9 required_561 envelope_561 := by + refine finite_compose HasSnaky 8 childrenC_561 childrenD_561 finite_children_work_561 (2, 7) + required_561 envelope_561 pivot_mem_561 child_required_sub_561 child_envelope_sub_561 ?_ + intro b hb + exact common_sub_561 (mem_commonEnvelope childrenD_561 b hb) + +theorem finite_children_work_562_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_562_i0 j) (childrenD_562_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_33 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_122 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_388 4 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_562_i0 : FiniteTemplate HasSnaky 8 required_562_i0 envelope_562_i0 := by + refine finite_compose HasSnaky 7 childrenC_562_i0 childrenD_562_i0 finite_children_work_562_i0 (3, 5) + required_562_i0 envelope_562_i0 pivot_mem_562_i0 child_required_sub_562_i0 child_envelope_sub_562_i0 ?_ + intro b hb + exact common_sub_562_i0 (mem_commonEnvelope childrenD_562_i0 b hb) + +theorem finite_children_work_562 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_562 j) (childrenD_562 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_506 6 (4, 7)).mono (by decide +kernel) + · exact finite_row_works_562_i0.mono (by decide +kernel) + +theorem finite_row_works_562 : FiniteTemplate HasSnaky 9 required_562 envelope_562 := by + refine finite_compose HasSnaky 8 childrenC_562 childrenD_562 finite_children_work_562 (3, 3) + required_562 envelope_562 pivot_mem_562 child_required_sub_562 child_envelope_sub_562 ?_ + intro b hb + exact common_sub_562 (mem_commonEnvelope childrenD_562 b hb) + +theorem finite_children_work_570_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_570_i0 j) (childrenD_570_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_446 4 (3, 9)).mono (by decide +kernel) + +theorem finite_row_works_570_i0 : FiniteTemplate HasSnaky 8 required_570_i0 envelope_570_i0 := by + refine finite_compose HasSnaky 7 childrenC_570_i0 childrenD_570_i0 finite_children_work_570_i0 (4, 5) + required_570_i0 envelope_570_i0 pivot_mem_570_i0 child_required_sub_570_i0 child_envelope_sub_570_i0 ?_ + intro b hb + exact common_sub_570_i0 (mem_commonEnvelope childrenD_570_i0 b hb) + +theorem finite_children_work_570_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_570_i2 j) (childrenD_570_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_20 3 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_29 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_331 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_570_i2 : FiniteTemplate HasSnaky 7 required_570_i2 envelope_570_i2 := by + refine finite_compose HasSnaky 6 childrenC_570_i2 childrenD_570_i2 finite_children_work_570_i2 (5, 3) + required_570_i2 envelope_570_i2 pivot_mem_570_i2 child_required_sub_570_i2 child_envelope_sub_570_i2 ?_ + intro b hb + exact common_sub_570_i2 (mem_commonEnvelope childrenD_570_i2 b hb) + +theorem finite_children_work_570_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_570_i1 j) (childrenD_570_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_570_i2.mono (by decide +kernel) + +theorem finite_row_works_570_i1 : FiniteTemplate HasSnaky 8 required_570_i1 envelope_570_i1 := by + refine finite_compose HasSnaky 7 childrenC_570_i1 childrenD_570_i1 finite_children_work_570_i1 (2, 3) + required_570_i1 envelope_570_i1 pivot_mem_570_i1 child_required_sub_570_i1 child_envelope_sub_570_i1 ?_ + intro b hb + exact common_sub_570_i1 (mem_commonEnvelope childrenD_570_i1 b hb) + +theorem finite_children_work_570 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_570 j) (childrenD_570 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_150 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_283 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_570_i0.mono (by decide +kernel) + · exact finite_row_works_570_i1.mono (by decide +kernel) + +theorem finite_row_works_570 : FiniteTemplate HasSnaky 9 required_570 envelope_570 := by + refine finite_compose HasSnaky 8 childrenC_570 childrenD_570 finite_children_work_570 (4, 3) + required_570 envelope_570 pivot_mem_570 child_required_sub_570 child_envelope_sub_570 ?_ + intro b hb + exact common_sub_570 (mem_commonEnvelope childrenD_570 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height09Part05.lean b/lean/snaky/FiniteCards/Height09Part05.lean new file mode 100644 index 0000000..091f3b9 --- /dev/null +++ b/lean/snaky/FiniteCards/Height09Part05.lean @@ -0,0 +1,199 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part05 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part05 +import FiniteCards.Height07Part02 +import FiniteCards.Height08Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_574_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_574_i1 j) (childrenD_574_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_43 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_64 6 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_574_i1 : FiniteTemplate HasSnaky 4 required_574_i1 envelope_574_i1 := by + refine finite_compose HasSnaky 3 childrenC_574_i1 childrenD_574_i1 finite_children_work_574_i1 (3, 3) + required_574_i1 envelope_574_i1 pivot_mem_574_i1 child_required_sub_574_i1 child_envelope_sub_574_i1 ?_ + intro b hb + exact common_sub_574_i1 (mem_commonEnvelope childrenD_574_i1 b hb) + +theorem finite_children_work_574_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_574_i3 j) (childrenD_574_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_223 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_574_i3 : FiniteTemplate HasSnaky 4 required_574_i3 envelope_574_i3 := by + refine finite_compose HasSnaky 3 childrenC_574_i3 childrenD_574_i3 finite_children_work_574_i3 (4, 4) + required_574_i3 envelope_574_i3 pivot_mem_574_i3 child_required_sub_574_i3 child_envelope_sub_574_i3 ?_ + intro b hb + exact common_sub_574_i3 (mem_commonEnvelope childrenD_574_i3 b hb) + +theorem finite_children_work_574_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_574_i2 j) (childrenD_574_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_574_i3.mono (by decide +kernel) + +theorem finite_row_works_574_i2 : FiniteTemplate HasSnaky 5 required_574_i2 envelope_574_i2 := by + refine finite_compose HasSnaky 4 childrenC_574_i2 childrenD_574_i2 finite_children_work_574_i2 (4, 2) + required_574_i2 envelope_574_i2 pivot_mem_574_i2 child_required_sub_574_i2 child_envelope_sub_574_i2 ?_ + intro b hb + exact common_sub_574_i2 (mem_commonEnvelope childrenD_574_i2 b hb) + +theorem finite_children_work_574_i5 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_574_i5 j) (childrenD_574_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_236 6 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_574_i5 : FiniteTemplate HasSnaky 4 required_574_i5 envelope_574_i5 := by + refine finite_compose HasSnaky 3 childrenC_574_i5 childrenD_574_i5 finite_children_work_574_i5 (4, 2) + required_574_i5 envelope_574_i5 pivot_mem_574_i5 child_required_sub_574_i5 child_envelope_sub_574_i5 ?_ + intro b hb + exact common_sub_574_i5 (mem_commonEnvelope childrenD_574_i5 b hb) + +theorem finite_children_work_574_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_574_i4 j) (childrenD_574_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_61 6 (4, 6)).mono (by decide +kernel) + · exact finite_row_works_574_i5.mono (by decide +kernel) + +theorem finite_row_works_574_i4 : FiniteTemplate HasSnaky 5 required_574_i4 envelope_574_i4 := by + refine finite_compose HasSnaky 4 childrenC_574_i4 childrenD_574_i4 finite_children_work_574_i4 (4, 4) + required_574_i4 envelope_574_i4 pivot_mem_574_i4 child_required_sub_574_i4 child_envelope_sub_574_i4 ?_ + intro b hb + exact common_sub_574_i4 (mem_commonEnvelope childrenD_574_i4 b hb) + +theorem finite_children_work_574_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_574_i0 j) (childrenD_574_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_130 1 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_574_i1.mono (by decide +kernel) + · exact finite_row_works_574_i2.mono (by decide +kernel) + · exact finite_row_works_574_i4.mono (by decide +kernel) + +theorem finite_row_works_574_i0 : FiniteTemplate HasSnaky 6 required_574_i0 envelope_574_i0 := by + refine finite_compose HasSnaky 5 childrenC_574_i0 childrenD_574_i0 finite_children_work_574_i0 (3, 2) + required_574_i0 envelope_574_i0 pivot_mem_574_i0 child_required_sub_574_i0 child_envelope_sub_574_i0 ?_ + intro b hb + exact common_sub_574_i0 (mem_commonEnvelope childrenD_574_i0 b hb) + +theorem finite_children_work_574 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_574 j) (childrenD_574 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_184 2 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_384 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_385 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_493 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_494 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_574_i0.mono (by decide +kernel) + +theorem finite_row_works_574 : FiniteTemplate HasSnaky 9 required_574 envelope_574 := by + refine finite_compose HasSnaky 8 childrenC_574 childrenD_574 finite_children_work_574 (4, 5) + required_574 envelope_574 pivot_mem_574 child_required_sub_574 child_envelope_sub_574 ?_ + intro b hb + exact common_sub_574 (mem_commonEnvelope childrenD_574 b hb) + +theorem finite_children_work_577_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_577_i1 j) (childrenD_577_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_393 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_577_i1 : FiniteTemplate HasSnaky 7 required_577_i1 envelope_577_i1 := by + refine finite_compose HasSnaky 6 childrenC_577_i1 childrenD_577_i1 finite_children_work_577_i1 (3, 1) + required_577_i1 envelope_577_i1 pivot_mem_577_i1 child_required_sub_577_i1 child_envelope_sub_577_i1 ?_ + intro b hb + exact common_sub_577_i1 (mem_commonEnvelope childrenD_577_i1 b hb) + +theorem finite_children_work_577_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_577_i0 j) (childrenD_577_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_577_i1.mono (by decide +kernel) + +theorem finite_row_works_577_i0 : FiniteTemplate HasSnaky 8 required_577_i0 envelope_577_i0 := by + refine finite_compose HasSnaky 7 childrenC_577_i0 childrenD_577_i0 finite_children_work_577_i0 (3, 3) + required_577_i0 envelope_577_i0 pivot_mem_577_i0 child_required_sub_577_i0 child_envelope_sub_577_i0 ?_ + intro b hb + exact common_sub_577_i0 (mem_commonEnvelope childrenD_577_i0 b hb) + +theorem finite_children_work_577 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_577 j) (childrenD_577 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_577_i0.mono (by decide +kernel) + +theorem finite_row_works_577 : FiniteTemplate HasSnaky 9 required_577 envelope_577 := by + refine finite_compose HasSnaky 8 childrenC_577 childrenD_577 finite_children_work_577 (4, 3) + required_577 envelope_577 pivot_mem_577 child_required_sub_577 child_envelope_sub_577 ?_ + intro b hb + exact common_sub_577 (mem_commonEnvelope childrenD_577 b hb) + +theorem finite_children_work_584_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_584_i1 j) (childrenD_584_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_121 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_584_i1 : FiniteTemplate HasSnaky 3 required_584_i1 envelope_584_i1 := by + refine finite_compose HasSnaky 2 childrenC_584_i1 childrenD_584_i1 finite_children_work_584_i1 (4, 1) + required_584_i1 envelope_584_i1 pivot_mem_584_i1 child_required_sub_584_i1 child_envelope_sub_584_i1 ?_ + intro b hb + exact common_sub_584_i1 (mem_commonEnvelope childrenD_584_i1 b hb) + +theorem finite_children_work_584_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_584_i2 j) (childrenD_584_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_203.mono (by decide +kernel) + +theorem finite_row_works_584_i2 : FiniteTemplate HasSnaky 7 required_584_i2 envelope_584_i2 := by + refine finite_compose HasSnaky 6 childrenC_584_i2 childrenD_584_i2 finite_children_work_584_i2 (1, 2) + required_584_i2 envelope_584_i2 pivot_mem_584_i2 child_required_sub_584_i2 child_envelope_sub_584_i2 ?_ + intro b hb + exact common_sub_584_i2 (mem_commonEnvelope childrenD_584_i2 b hb) + +theorem finite_children_work_584_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_584_i0 j) (childrenD_584_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_39 0 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_584_i1.mono (by decide +kernel) + · exact finite_row_works_584_i2.mono (by decide +kernel) + +theorem finite_row_works_584_i0 : FiniteTemplate HasSnaky 8 required_584_i0 envelope_584_i0 := by + refine finite_compose HasSnaky 7 childrenC_584_i0 childrenD_584_i0 finite_children_work_584_i0 (3, 4) + required_584_i0 envelope_584_i0 pivot_mem_584_i0 child_required_sub_584_i0 child_envelope_sub_584_i0 ?_ + intro b hb + exact common_sub_584_i0 (mem_commonEnvelope childrenD_584_i0 b hb) + +theorem finite_children_work_584 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_584 j) (childrenD_584 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_584_i0.mono (by decide +kernel) + +theorem finite_row_works_584 : FiniteTemplate HasSnaky 9 required_584 envelope_584 := by + refine finite_compose HasSnaky 8 childrenC_584 childrenD_584 finite_children_work_584 (2, 1) + required_584 envelope_584 pivot_mem_584 child_required_sub_584 child_envelope_sub_584 ?_ + intro b hb + exact common_sub_584 (mem_commonEnvelope childrenD_584 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height09Part06.lean b/lean/snaky/FiniteCards/Height09Part06.lean new file mode 100644 index 0000000..10a9345 --- /dev/null +++ b/lean/snaky/FiniteCards/Height09Part06.lean @@ -0,0 +1,257 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part06 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part05 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height08Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_595_i6 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_595_i6 j) (childrenD_595_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 4 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_595_i6 : FiniteTemplate HasSnaky 2 required_595_i6 envelope_595_i6 := by + refine finite_compose HasSnaky 1 childrenC_595_i6 childrenD_595_i6 finite_children_work_595_i6 (4, 1) + required_595_i6 envelope_595_i6 pivot_mem_595_i6 child_required_sub_595_i6 child_envelope_sub_595_i6 ?_ + intro b hb + exact common_sub_595_i6 (mem_commonEnvelope childrenD_595_i6 b hb) + +theorem finite_children_work_595_i5 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_595_i5 j) (childrenD_595_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 7 (6, 4)).mono (by decide +kernel) + · exact finite_row_works_595_i6.mono (by decide +kernel) + +theorem finite_row_works_595_i5 : FiniteTemplate HasSnaky 3 required_595_i5 envelope_595_i5 := by + refine finite_compose HasSnaky 2 childrenC_595_i5 childrenD_595_i5 finite_children_work_595_i5 (5, 0) + required_595_i5 envelope_595_i5 pivot_mem_595_i5 child_required_sub_595_i5 child_envelope_sub_595_i5 ?_ + intro b hb + exact common_sub_595_i5 (mem_commonEnvelope childrenD_595_i5 b hb) + +theorem finite_children_work_595_i4 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_595_i4 j) (childrenD_595_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (6, 5)).mono (by decide +kernel) + · exact finite_row_works_595_i5.mono (by decide +kernel) + +theorem finite_row_works_595_i4 : FiniteTemplate HasSnaky 4 required_595_i4 envelope_595_i4 := by + refine finite_compose HasSnaky 3 childrenC_595_i4 childrenD_595_i4 finite_children_work_595_i4 (5, 1) + required_595_i4 envelope_595_i4 pivot_mem_595_i4 child_required_sub_595_i4 child_envelope_sub_595_i4 ?_ + intro b hb + exact common_sub_595_i4 (mem_commonEnvelope childrenD_595_i4 b hb) + +theorem finite_children_work_595_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_595_i3 j) (childrenD_595_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_595_i4.mono (by decide +kernel) + +theorem finite_row_works_595_i3 : FiniteTemplate HasSnaky 5 required_595_i3 envelope_595_i3 := by + refine finite_compose HasSnaky 4 childrenC_595_i3 childrenD_595_i3 finite_children_work_595_i3 (2, 1) + required_595_i3 envelope_595_i3 pivot_mem_595_i3 child_required_sub_595_i3 child_envelope_sub_595_i3 ?_ + intro b hb + exact common_sub_595_i3 (mem_commonEnvelope childrenD_595_i3 b hb) + +theorem finite_children_work_595_i7 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_595_i7 j) (childrenD_595_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_208 7 (7, 5)).mono (by decide +kernel) + +theorem finite_row_works_595_i7 : FiniteTemplate HasSnaky 5 required_595_i7 envelope_595_i7 := by + refine finite_compose HasSnaky 4 childrenC_595_i7 childrenD_595_i7 finite_children_work_595_i7 (4, 2) + required_595_i7 envelope_595_i7 pivot_mem_595_i7 child_required_sub_595_i7 child_envelope_sub_595_i7 ?_ + intro b hb + exact common_sub_595_i7 (mem_commonEnvelope childrenD_595_i7 b hb) + +theorem finite_children_work_595_i9 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_595_i9 j) (childrenD_595_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_153 1 (3, 1)).mono (by decide +kernel) + +theorem finite_row_works_595_i9 : FiniteTemplate HasSnaky 3 required_595_i9 envelope_595_i9 := by + refine finite_compose HasSnaky 2 childrenC_595_i9 childrenD_595_i9 finite_children_work_595_i9 (4, 2) + required_595_i9 envelope_595_i9 pivot_mem_595_i9 child_required_sub_595_i9 child_envelope_sub_595_i9 ?_ + intro b hb + exact common_sub_595_i9 (mem_commonEnvelope childrenD_595_i9 b hb) + +theorem finite_children_work_595_i8 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_595_i8 j) (childrenD_595_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (6, 5)).mono (by decide +kernel) + · exact finite_row_works_595_i9.mono (by decide +kernel) + +theorem finite_row_works_595_i8 : FiniteTemplate HasSnaky 4 required_595_i8 envelope_595_i8 := by + refine finite_compose HasSnaky 3 childrenC_595_i8 childrenD_595_i8 finite_children_work_595_i8 (5, 2) + required_595_i8 envelope_595_i8 pivot_mem_595_i8 child_required_sub_595_i8 child_envelope_sub_595_i8 ?_ + intro b hb + exact common_sub_595_i8 (mem_commonEnvelope childrenD_595_i8 b hb) + +theorem finite_children_work_595_i10 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_595_i10 j) (childrenD_595_i10 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_157 7 (7, 5)).mono (by decide +kernel) + +theorem finite_row_works_595_i10 : FiniteTemplate HasSnaky 4 required_595_i10 envelope_595_i10 := by + refine finite_compose HasSnaky 3 childrenC_595_i10 childrenD_595_i10 finite_children_work_595_i10 (4, 2) + required_595_i10 envelope_595_i10 pivot_mem_595_i10 child_required_sub_595_i10 child_envelope_sub_595_i10 ?_ + intro b hb + exact common_sub_595_i10 (mem_commonEnvelope childrenD_595_i10 b hb) + +theorem finite_children_work_595_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_595_i2 j) (childrenD_595_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 7 (7, 5)).mono (by decide +kernel) + · exact finite_row_works_595_i3.mono (by decide +kernel) + · exact finite_row_works_595_i7.mono (by decide +kernel) + · exact finite_row_works_595_i8.mono (by decide +kernel) + · exact finite_row_works_595_i10.mono (by decide +kernel) + +theorem finite_row_works_595_i2 : FiniteTemplate HasSnaky 6 required_595_i2 envelope_595_i2 := by + refine finite_compose HasSnaky 5 childrenC_595_i2 childrenD_595_i2 finite_children_work_595_i2 (6, 2) + required_595_i2 envelope_595_i2 pivot_mem_595_i2 child_required_sub_595_i2 child_envelope_sub_595_i2 ?_ + intro b hb + exact common_sub_595_i2 (mem_commonEnvelope childrenD_595_i2 b hb) + +theorem finite_children_work_595_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_595_i1 j) (childrenD_595_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_595_i2.mono (by decide +kernel) + +theorem finite_row_works_595_i1 : FiniteTemplate HasSnaky 7 required_595_i1 envelope_595_i1 := by + refine finite_compose HasSnaky 6 childrenC_595_i1 childrenD_595_i1 finite_children_work_595_i1 (6, 3) + required_595_i1 envelope_595_i1 pivot_mem_595_i1 child_required_sub_595_i1 child_envelope_sub_595_i1 ?_ + intro b hb + exact common_sub_595_i1 (mem_commonEnvelope childrenD_595_i1 b hb) + +theorem finite_children_work_595_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_595_i0 j) (childrenD_595_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_595_i1.mono (by decide +kernel) + +theorem finite_row_works_595_i0 : FiniteTemplate HasSnaky 8 required_595_i0 envelope_595_i0 := by + refine finite_compose HasSnaky 7 childrenC_595_i0 childrenD_595_i0 finite_children_work_595_i0 (6, 4) + required_595_i0 envelope_595_i0 pivot_mem_595_i0 child_required_sub_595_i0 child_envelope_sub_595_i0 ?_ + intro b hb + exact common_sub_595_i0 (mem_commonEnvelope childrenD_595_i0 b hb) + +theorem finite_children_work_595 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_595 j) (childrenD_595 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 0 (2, 4)).mono (by decide +kernel) + · exact finite_row_works_595_i0.mono (by decide +kernel) + +theorem finite_row_works_595 : FiniteTemplate HasSnaky 9 required_595 envelope_595 := by + refine finite_compose HasSnaky 8 childrenC_595 childrenD_595 finite_children_work_595 (6, 5) + required_595 envelope_595 pivot_mem_595 child_required_sub_595 child_envelope_sub_595 ?_ + intro b hb + exact common_sub_595 (mem_commonEnvelope childrenD_595 b hb) + +theorem finite_children_work_614_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_614_i1 j) (childrenD_614_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_425 4 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_614_i1 : FiniteTemplate HasSnaky 6 required_614_i1 envelope_614_i1 := by + refine finite_compose HasSnaky 5 childrenC_614_i1 childrenD_614_i1 finite_children_work_614_i1 (2, 4) + required_614_i1 envelope_614_i1 pivot_mem_614_i1 child_required_sub_614_i1 child_envelope_sub_614_i1 ?_ + intro b hb + exact common_sub_614_i1 (mem_commonEnvelope childrenD_614_i1 b hb) + +theorem finite_children_work_614_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_614_i2 j) (childrenD_614_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_68 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_495 4 (3, 8)).mono (by decide +kernel) + +theorem finite_row_works_614_i2 : FiniteTemplate HasSnaky 6 required_614_i2 envelope_614_i2 := by + refine finite_compose HasSnaky 5 childrenC_614_i2 childrenD_614_i2 finite_children_work_614_i2 (4, 3) + required_614_i2 envelope_614_i2 pivot_mem_614_i2 child_required_sub_614_i2 child_envelope_sub_614_i2 ?_ + intro b hb + exact common_sub_614_i2 (mem_commonEnvelope childrenD_614_i2 b hb) + +theorem finite_children_work_614_i4 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_614_i4 j) (childrenD_614_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_66 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_66 0 (3, 2)).mono (by decide +kernel) + +theorem finite_row_works_614_i4 : FiniteTemplate HasSnaky 3 required_614_i4 envelope_614_i4 := by + refine finite_compose HasSnaky 2 childrenC_614_i4 childrenD_614_i4 finite_children_work_614_i4 (4, 4) + required_614_i4 envelope_614_i4 pivot_mem_614_i4 child_required_sub_614_i4 child_envelope_sub_614_i4 ?_ + intro b hb + exact common_sub_614_i4 (mem_commonEnvelope childrenD_614_i4 b hb) + +theorem finite_children_work_614_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_614_i3 j) (childrenD_614_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_68 3 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_614_i4.mono (by decide +kernel) + +theorem finite_row_works_614_i3 : FiniteTemplate HasSnaky 4 required_614_i3 envelope_614_i3 := by + refine finite_compose HasSnaky 3 childrenC_614_i3 childrenD_614_i3 finite_children_work_614_i3 (4, 3) + required_614_i3 envelope_614_i3 pivot_mem_614_i3 child_required_sub_614_i3 child_envelope_sub_614_i3 ?_ + intro b hb + exact common_sub_614_i3 (mem_commonEnvelope childrenD_614_i3 b hb) + +theorem finite_children_work_614_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_614_i5 j) (childrenD_614_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_68 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_612 4 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_614_i5 : FiniteTemplate HasSnaky 6 required_614_i5 envelope_614_i5 := by + refine finite_compose HasSnaky 5 childrenC_614_i5 childrenD_614_i5 finite_children_work_614_i5 (4, 3) + required_614_i5 envelope_614_i5 pivot_mem_614_i5 child_required_sub_614_i5 child_envelope_sub_614_i5 ?_ + intro b hb + exact common_sub_614_i5 (mem_commonEnvelope childrenD_614_i5 b hb) + +theorem finite_children_work_614_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_614_i0 j) (childrenD_614_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_276 4 (3, 8)).mono (by decide +kernel) + · exact finite_row_works_614_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_611 4 (3, 9)).mono (by decide +kernel) + · exact finite_row_works_614_i2.mono (by decide +kernel) + · exact finite_row_works_614_i3.mono (by decide +kernel) + · exact finite_row_works_614_i5.mono (by decide +kernel) + +theorem finite_row_works_614_i0 : FiniteTemplate HasSnaky 8 required_614_i0 envelope_614_i0 := by + refine finite_compose HasSnaky 7 childrenC_614_i0 childrenD_614_i0 finite_children_work_614_i0 (5, 3) + required_614_i0 envelope_614_i0 pivot_mem_614_i0 child_required_sub_614_i0 child_envelope_sub_614_i0 ?_ + intro b hb + exact common_sub_614_i0 (mem_commonEnvelope childrenD_614_i0 b hb) + +theorem finite_children_work_614 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_614 j) (childrenD_614 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_68 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_558 4 (3, 7)).mono (by decide +kernel) + · exact finite_row_works_614_i0.mono (by decide +kernel) + +theorem finite_row_works_614 : FiniteTemplate HasSnaky 9 required_614 envelope_614 := by + refine finite_compose HasSnaky 8 childrenC_614 childrenD_614 finite_children_work_614 (5, 5) + required_614 envelope_614 pivot_mem_614 child_required_sub_614 child_envelope_sub_614 ?_ + intro b hb + exact common_sub_614 (mem_commonEnvelope childrenD_614 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height09Part07.lean b/lean/snaky/FiniteCards/Height09Part07.lean new file mode 100644 index 0000000..a774053 --- /dev/null +++ b/lean/snaky/FiniteCards/Height09Part07.lean @@ -0,0 +1,299 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part05 +import FiniteCards.Height08Part03 +import FiniteCards.Height08Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_622_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_622_i0 j) (childrenD_622_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_41 2 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_56 7 (6, 6)).mono (by decide +kernel) + +theorem finite_row_works_622_i0 : FiniteTemplate HasSnaky 5 required_622_i0 envelope_622_i0 := by + refine finite_compose HasSnaky 4 childrenC_622_i0 childrenD_622_i0 finite_children_work_622_i0 (3, 6) + required_622_i0 envelope_622_i0 pivot_mem_622_i0 child_required_sub_622_i0 child_envelope_sub_622_i0 ?_ + intro b hb + exact common_sub_622_i0 (mem_commonEnvelope childrenD_622_i0 b hb) + +theorem finite_children_work_622_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_622_i2 j) (childrenD_622_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_41 2 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_622_i2 : FiniteTemplate HasSnaky 5 required_622_i2 envelope_622_i2 := by + refine finite_compose HasSnaky 4 childrenC_622_i2 childrenD_622_i2 finite_children_work_622_i2 (3, 6) + required_622_i2 envelope_622_i2 pivot_mem_622_i2 child_required_sub_622_i2 child_envelope_sub_622_i2 ?_ + intro b hb + exact common_sub_622_i2 (mem_commonEnvelope childrenD_622_i2 b hb) + +theorem finite_children_work_622_i3 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_622_i3 j) (childrenD_622_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 4 (3, 6)).mono (by decide +kernel) + +theorem finite_row_works_622_i3 : FiniteTemplate HasSnaky 3 required_622_i3 envelope_622_i3 := by + refine finite_compose HasSnaky 2 childrenC_622_i3 childrenD_622_i3 finite_children_work_622_i3 (3, 2) + required_622_i3 envelope_622_i3 pivot_mem_622_i3 child_required_sub_622_i3 child_envelope_sub_622_i3 ?_ + intro b hb + exact common_sub_622_i3 (mem_commonEnvelope childrenD_622_i3 b hb) + +theorem finite_children_work_622_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_622_i1 j) (childrenD_622_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_61 6 (3, 6)).mono (by decide +kernel) + · exact finite_row_works_622_i2.mono (by decide +kernel) + · exact finite_row_works_622_i3.mono (by decide +kernel) + +theorem finite_row_works_622_i1 : FiniteTemplate HasSnaky 6 required_622_i1 envelope_622_i1 := by + refine finite_compose HasSnaky 5 childrenC_622_i1 childrenD_622_i1 finite_children_work_622_i1 (2, 2) + required_622_i1 envelope_622_i1 pivot_mem_622_i1 child_required_sub_622_i1 child_envelope_sub_622_i1 ?_ + intro b hb + exact common_sub_622_i1 (mem_commonEnvelope childrenD_622_i1 b hb) + +theorem finite_children_work_622_i4 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_622_i4 j) (childrenD_622_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_23 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_621 2 (7, 1)).mono (by decide +kernel) + +theorem finite_row_works_622_i4 : FiniteTemplate HasSnaky 8 required_622_i4 envelope_622_i4 := by + refine finite_compose HasSnaky 7 childrenC_622_i4 childrenD_622_i4 finite_children_work_622_i4 (4, 5) + required_622_i4 envelope_622_i4 pivot_mem_622_i4 child_required_sub_622_i4 child_envelope_sub_622_i4 ?_ + intro b hb + exact common_sub_622_i4 (mem_commonEnvelope childrenD_622_i4 b hb) + +theorem finite_children_work_622 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_622 j) (childrenD_622 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_57 7 (6, 6)).mono (by decide +kernel) + · exact finite_row_works_622_i0.mono (by decide +kernel) + · exact finite_row_works_622_i1.mono (by decide +kernel) + · exact finite_row_works_622_i4.mono (by decide +kernel) + +theorem finite_row_works_622 : FiniteTemplate HasSnaky 9 required_622 envelope_622 := by + refine finite_compose HasSnaky 8 childrenC_622 childrenD_622 finite_children_work_622 (4, 4) + required_622 envelope_622 pivot_mem_622 child_required_sub_622 child_envelope_sub_622 ?_ + intro b hb + exact common_sub_622 (mem_commonEnvelope childrenD_622 b hb) + +theorem finite_children_work_629 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_629 j) (childrenD_629 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_190 2 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_295 2 (7, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_364 2 (6, 1)).mono (by decide +kernel) + · exact finite_row_works_518.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_628 4 (2, 7)).mono (by decide +kernel) + +theorem finite_row_works_629 : FiniteTemplate HasSnaky 9 required_629 envelope_629 := by + refine finite_compose HasSnaky 8 childrenC_629 childrenD_629 finite_children_work_629 (3, 5) + required_629 envelope_629 pivot_mem_629 child_required_sub_629 child_envelope_sub_629 ?_ + intro b hb + exact common_sub_629 (mem_commonEnvelope childrenD_629 b hb) + +theorem finite_children_work_638_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_638_i0 j) (childrenD_638_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_85 4 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_638_i0 : FiniteTemplate HasSnaky 7 required_638_i0 envelope_638_i0 := by + refine finite_compose HasSnaky 6 childrenC_638_i0 childrenD_638_i0 finite_children_work_638_i0 (3, 4) + required_638_i0 envelope_638_i0 pivot_mem_638_i0 child_required_sub_638_i0 child_envelope_sub_638_i0 ?_ + intro b hb + exact common_sub_638_i0 (mem_commonEnvelope childrenD_638_i0 b hb) + +theorem finite_children_work_638 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_638 j) (childrenD_638 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_57 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_136 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_217 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_530 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_638_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_637 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_638 : FiniteTemplate HasSnaky 9 required_638 envelope_638 := by + refine finite_compose HasSnaky 8 childrenC_638 childrenD_638 finite_children_work_638 (3, 3) + required_638 envelope_638 pivot_mem_638 child_required_sub_638 child_envelope_sub_638 ?_ + intro b hb + exact common_sub_638 (mem_commonEnvelope childrenD_638 b hb) + +theorem finite_children_work_640_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_640_i3 j) (childrenD_640_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_90 0 (2, 5)).mono (by decide +kernel) + +theorem finite_row_works_640_i3 : FiniteTemplate HasSnaky 5 required_640_i3 envelope_640_i3 := by + refine finite_compose HasSnaky 4 childrenC_640_i3 childrenD_640_i3 finite_children_work_640_i3 (5, 6) + required_640_i3 envelope_640_i3 pivot_mem_640_i3 child_required_sub_640_i3 child_envelope_sub_640_i3 ?_ + intro b hb + exact common_sub_640_i3 (mem_commonEnvelope childrenD_640_i3 b hb) + +theorem finite_children_work_640_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_640_i2 j) (childrenD_640_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_260 5 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_640_i3.mono (by decide +kernel) + +theorem finite_row_works_640_i2 : FiniteTemplate HasSnaky 6 required_640_i2 envelope_640_i2 := by + refine finite_compose HasSnaky 5 childrenC_640_i2 childrenD_640_i2 finite_children_work_640_i2 (2, 6) + required_640_i2 envelope_640_i2 pivot_mem_640_i2 child_required_sub_640_i2 child_envelope_sub_640_i2 ?_ + intro b hb + exact common_sub_640_i2 (mem_commonEnvelope childrenD_640_i2 b hb) + +theorem finite_children_work_640_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_640_i1 j) (childrenD_640_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_640_i2.mono (by decide +kernel) + +theorem finite_row_works_640_i1 : FiniteTemplate HasSnaky 7 required_640_i1 envelope_640_i1 := by + refine finite_compose HasSnaky 6 childrenC_640_i1 childrenD_640_i1 finite_children_work_640_i1 (4, 6) + required_640_i1 envelope_640_i1 pivot_mem_640_i1 child_required_sub_640_i1 child_envelope_sub_640_i1 ?_ + intro b hb + exact common_sub_640_i1 (mem_commonEnvelope childrenD_640_i1 b hb) + +theorem finite_children_work_640_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_640_i0 j) (childrenD_640_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_61 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_89 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_183 5 (6, 2)).mono (by decide +kernel) + · exact finite_row_works_640_i1.mono (by decide +kernel) + +theorem finite_row_works_640_i0 : FiniteTemplate HasSnaky 8 required_640_i0 envelope_640_i0 := by + refine finite_compose HasSnaky 7 childrenC_640_i0 childrenD_640_i0 finite_children_work_640_i0 (3, 6) + required_640_i0 envelope_640_i0 pivot_mem_640_i0 child_required_sub_640_i0 child_envelope_sub_640_i0 ?_ + intro b hb + exact common_sub_640_i0 (mem_commonEnvelope childrenD_640_i0 b hb) + +theorem finite_children_work_640 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_640 j) (childrenD_640 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_47 3 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (4, 6)).mono (by decide +kernel) + · exact finite_row_works_640_i0.mono (by decide +kernel) + +theorem finite_row_works_640 : FiniteTemplate HasSnaky 9 required_640 envelope_640 := by + refine finite_compose HasSnaky 8 childrenC_640 childrenD_640 finite_children_work_640 (4, 5) + required_640 envelope_640 pivot_mem_640 child_required_sub_640 child_envelope_sub_640 ?_ + intro b hb + exact common_sub_640 (mem_commonEnvelope childrenD_640 b hb) + +theorem finite_children_work_655_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_655_i0 j) (childrenD_655_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_179 5 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_344 7 (5, 7)).mono (by decide +kernel) + +theorem finite_row_works_655_i0 : FiniteTemplate HasSnaky 8 required_655_i0 envelope_655_i0 := by + refine finite_compose HasSnaky 7 childrenC_655_i0 childrenD_655_i0 finite_children_work_655_i0 (3, 6) + required_655_i0 envelope_655_i0 pivot_mem_655_i0 child_required_sub_655_i0 child_envelope_sub_655_i0 ?_ + intro b hb + exact common_sub_655_i0 (mem_commonEnvelope childrenD_655_i0 b hb) + +theorem finite_children_work_655 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_655 j) (childrenD_655 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 4 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 7 (6, 6)).mono (by decide +kernel) + · exact finite_row_works_655_i0.mono (by decide +kernel) + +theorem finite_row_works_655 : FiniteTemplate HasSnaky 9 required_655 envelope_655 := by + refine finite_compose HasSnaky 8 childrenC_655 childrenD_655 finite_children_work_655 (3, 3) + required_655 envelope_655 pivot_mem_655 child_required_sub_655 child_envelope_sub_655 ?_ + intro b hb + exact common_sub_655 (mem_commonEnvelope childrenD_655 b hb) + +theorem finite_children_work_659 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_659 j) (childrenD_659 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_658 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_659 : FiniteTemplate HasSnaky 9 required_659 envelope_659 := by + refine finite_compose HasSnaky 8 childrenC_659 childrenD_659 finite_children_work_659 (3, 4) + required_659 envelope_659 pivot_mem_659 child_required_sub_659 child_envelope_sub_659 ?_ + intro b hb + exact common_sub_659 (mem_commonEnvelope childrenD_659 b hb) + +theorem finite_children_work_662_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_662_i0 j) (childrenD_662_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_141 2 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_662_i0 : FiniteTemplate HasSnaky 5 required_662_i0 envelope_662_i0 := by + refine finite_compose HasSnaky 4 childrenC_662_i0 childrenD_662_i0 finite_children_work_662_i0 (1, 5) + required_662_i0 envelope_662_i0 pivot_mem_662_i0 child_required_sub_662_i0 child_envelope_sub_662_i0 ?_ + intro b hb + exact common_sub_662_i0 (mem_commonEnvelope childrenD_662_i0 b hb) + +theorem finite_children_work_662 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_662 j) (childrenD_662 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_658 0 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_662_i0.mono (by decide +kernel) + +theorem finite_row_works_662 : FiniteTemplate HasSnaky 9 required_662 envelope_662 := by + refine finite_compose HasSnaky 8 childrenC_662 childrenD_662 finite_children_work_662 (4, 4) + required_662 envelope_662 pivot_mem_662 child_required_sub_662 child_envelope_sub_662 ?_ + intro b hb + exact common_sub_662 (mem_commonEnvelope childrenD_662 b hb) + +theorem finite_children_work_667 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_667 j) (childrenD_667 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_666 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_667 : FiniteTemplate HasSnaky 9 required_667 envelope_667 := by + refine finite_compose HasSnaky 8 childrenC_667 childrenD_667 finite_children_work_667 (3, 4) + required_667 envelope_667 pivot_mem_667 child_required_sub_667 child_envelope_sub_667 ?_ + intro b hb + exact common_sub_667 (mem_commonEnvelope childrenD_667 b hb) + +theorem finite_children_work_668 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_668 j) (childrenD_668 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 0 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_666 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_668 : FiniteTemplate HasSnaky 9 required_668 envelope_668 := by + refine finite_compose HasSnaky 8 childrenC_668 childrenD_668 finite_children_work_668 (3, 4) + required_668 envelope_668 pivot_mem_668 child_required_sub_668 child_envelope_sub_668 ?_ + intro b hb + exact common_sub_668 (mem_commonEnvelope childrenD_668 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height09Part08.lean b/lean/snaky/FiniteCards/Height09Part08.lean new file mode 100644 index 0000000..2e98f31 --- /dev/null +++ b/lean/snaky/FiniteCards/Height09Part08.lean @@ -0,0 +1,250 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part08 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height04Part05 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height08Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_673_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_673_i0 j) (childrenD_673_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_30 0 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_74 3 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_673_i0 : FiniteTemplate HasSnaky 4 required_673_i0 envelope_673_i0 := by + refine finite_compose HasSnaky 3 childrenC_673_i0 childrenD_673_i0 finite_children_work_673_i0 (1, 4) + required_673_i0 envelope_673_i0 pivot_mem_673_i0 child_required_sub_673_i0 child_envelope_sub_673_i0 ?_ + intro b hb + exact common_sub_673_i0 (mem_commonEnvelope childrenD_673_i0 b hb) + +theorem finite_children_work_673_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_673_i3 j) (childrenD_673_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_260 0 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_673_i3 : FiniteTemplate HasSnaky 6 required_673_i3 envelope_673_i3 := by + refine finite_compose HasSnaky 5 childrenC_673_i3 childrenD_673_i3 finite_children_work_673_i3 (4, 5) + required_673_i3 envelope_673_i3 pivot_mem_673_i3 child_required_sub_673_i3 child_envelope_sub_673_i3 ?_ + intro b hb + exact common_sub_673_i3 (mem_commonEnvelope childrenD_673_i3 b hb) + +theorem finite_children_work_673_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_673_i2 j) (childrenD_673_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_38 2 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_673_i3.mono (by decide +kernel) + +theorem finite_row_works_673_i2 : FiniteTemplate HasSnaky 7 required_673_i2 envelope_673_i2 := by + refine finite_compose HasSnaky 6 childrenC_673_i2 childrenD_673_i2 finite_children_work_673_i2 (1, 4) + required_673_i2 envelope_673_i2 pivot_mem_673_i2 child_required_sub_673_i2 child_envelope_sub_673_i2 ?_ + intro b hb + exact common_sub_673_i2 (mem_commonEnvelope childrenD_673_i2 b hb) + +theorem finite_children_work_673_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_673_i1 j) (childrenD_673_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact finite_row_works_673_i2.mono (by decide +kernel) + +theorem finite_row_works_673_i1 : FiniteTemplate HasSnaky 8 required_673_i1 envelope_673_i1 := by + refine finite_compose HasSnaky 7 childrenC_673_i1 childrenD_673_i1 finite_children_work_673_i1 (3, 4) + required_673_i1 envelope_673_i1 pivot_mem_673_i1 child_required_sub_673_i1 child_envelope_sub_673_i1 ?_ + intro b hb + exact common_sub_673_i1 (mem_commonEnvelope childrenD_673_i1 b hb) + +theorem finite_children_work_673_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_673_i4 j) (childrenD_673_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_188 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_190 6 (6, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_230 7 (6, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_263 0 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_306 4 (1, 8)).mono (by decide +kernel) + +theorem finite_row_works_673_i4 : FiniteTemplate HasSnaky 7 required_673_i4 envelope_673_i4 := by + refine finite_compose HasSnaky 6 childrenC_673_i4 childrenD_673_i4 finite_children_work_673_i4 (4, 5) + required_673_i4 envelope_673_i4 pivot_mem_673_i4 child_required_sub_673_i4 child_envelope_sub_673_i4 ?_ + intro b hb + exact common_sub_673_i4 (mem_commonEnvelope childrenD_673_i4 b hb) + +theorem finite_children_work_673_i6 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_673_i6 j) (childrenD_673_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_38 2 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_145 0 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_673_i6 : FiniteTemplate HasSnaky 6 required_673_i6 envelope_673_i6 := by + refine finite_compose HasSnaky 5 childrenC_673_i6 childrenD_673_i6 finite_children_work_673_i6 (1, 4) + required_673_i6 envelope_673_i6 pivot_mem_673_i6 child_required_sub_673_i6 child_envelope_sub_673_i6 ?_ + intro b hb + exact common_sub_673_i6 (mem_commonEnvelope childrenD_673_i6 b hb) + +theorem finite_children_work_673_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_673_i5 j) (childrenD_673_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact finite_row_works_673_i6.mono (by decide +kernel) + +theorem finite_row_works_673_i5 : FiniteTemplate HasSnaky 7 required_673_i5 envelope_673_i5 := by + refine finite_compose HasSnaky 6 childrenC_673_i5 childrenD_673_i5 finite_children_work_673_i5 (3, 4) + required_673_i5 envelope_673_i5 pivot_mem_673_i5 child_required_sub_673_i5 child_envelope_sub_673_i5 ?_ + intro b hb + exact common_sub_673_i5 (mem_commonEnvelope childrenD_673_i5 b hb) + +theorem finite_children_work_673_i9 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_673_i9 j) (childrenD_673_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 3 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_19 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_25 7 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_673_i9 : FiniteTemplate HasSnaky 6 required_673_i9 envelope_673_i9 := by + refine finite_compose HasSnaky 5 childrenC_673_i9 childrenD_673_i9 finite_children_work_673_i9 (4, 3) + required_673_i9 envelope_673_i9 pivot_mem_673_i9 child_required_sub_673_i9 child_envelope_sub_673_i9 ?_ + intro b hb + exact common_sub_673_i9 (mem_commonEnvelope childrenD_673_i9 b hb) + +theorem finite_children_work_673_i10 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_673_i10 j) (childrenD_673_i10 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_10 0 (3, 3)).mono (by decide +kernel) + +theorem finite_row_works_673_i10 : FiniteTemplate HasSnaky 5 required_673_i10 envelope_673_i10 := by + refine finite_compose HasSnaky 4 childrenC_673_i10 childrenD_673_i10 finite_children_work_673_i10 (3, 4) + required_673_i10 envelope_673_i10 pivot_mem_673_i10 child_required_sub_673_i10 child_envelope_sub_673_i10 ?_ + intro b hb + exact common_sub_673_i10 (mem_commonEnvelope childrenD_673_i10 b hb) + +theorem finite_children_work_673_i8 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_673_i8 j) (childrenD_673_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_263 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_271 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_424 4 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_673_i9.mono (by decide +kernel) + · exact finite_row_works_673_i10.mono (by decide +kernel) + +theorem finite_row_works_673_i8 : FiniteTemplate HasSnaky 7 required_673_i8 envelope_673_i8 := by + refine finite_compose HasSnaky 6 childrenC_673_i8 childrenD_673_i8 finite_children_work_673_i8 (4, 5) + required_673_i8 envelope_673_i8 pivot_mem_673_i8 child_required_sub_673_i8 child_envelope_sub_673_i8 ?_ + intro b hb + exact common_sub_673_i8 (mem_commonEnvelope childrenD_673_i8 b hb) + +theorem finite_children_work_673_i7 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_673_i7 j) (childrenD_673_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_30 0 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_673_i8.mono (by decide +kernel) + +theorem finite_row_works_673_i7 : FiniteTemplate HasSnaky 8 required_673_i7 envelope_673_i7 := by + refine finite_compose HasSnaky 7 childrenC_673_i7 childrenD_673_i7 finite_children_work_673_i7 (1, 4) + required_673_i7 envelope_673_i7 pivot_mem_673_i7 child_required_sub_673_i7 child_envelope_sub_673_i7 ?_ + intro b hb + exact common_sub_673_i7 (mem_commonEnvelope childrenD_673_i7 b hb) + +theorem finite_children_work_673 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_673 j) (childrenD_673 j) := by + intro j + fin_cases j + · exact finite_row_works_673_i0.mono (by decide +kernel) + · exact finite_row_works_673_i1.mono (by decide +kernel) + · exact finite_row_works_673_i4.mono (by decide +kernel) + · exact finite_row_works_673_i5.mono (by decide +kernel) + · exact finite_row_works_673_i7.mono (by decide +kernel) + +theorem finite_row_works_673 : FiniteTemplate HasSnaky 9 required_673 envelope_673 := by + refine finite_compose HasSnaky 8 childrenC_673 childrenD_673 finite_children_work_673 (4, 4) + required_673 envelope_673 pivot_mem_673 child_required_sub_673 child_envelope_sub_673 ?_ + intro b hb + exact common_sub_673 (mem_commonEnvelope childrenD_673 b hb) + +theorem finite_children_work_686_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_686_i0 j) (childrenD_686_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_43 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_57 5 (7, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_340 0 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_686_i0 : FiniteTemplate HasSnaky 7 required_686_i0 envelope_686_i0 := by + refine finite_compose HasSnaky 6 childrenC_686_i0 childrenD_686_i0 finite_children_work_686_i0 (5, 4) + required_686_i0 envelope_686_i0 pivot_mem_686_i0 child_required_sub_686_i0 child_envelope_sub_686_i0 ?_ + intro b hb + exact common_sub_686_i0 (mem_commonEnvelope childrenD_686_i0 b hb) + +theorem finite_children_work_686_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_686_i1 j) (childrenD_686_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_256 5 (7, 2)).mono (by decide +kernel) + +theorem finite_row_works_686_i1 : FiniteTemplate HasSnaky 8 required_686_i1 envelope_686_i1 := by + refine finite_compose HasSnaky 7 childrenC_686_i1 childrenD_686_i1 finite_children_work_686_i1 (4, 2) + required_686_i1 envelope_686_i1 pivot_mem_686_i1 child_required_sub_686_i1 child_envelope_sub_686_i1 ?_ + intro b hb + exact common_sub_686_i1 (mem_commonEnvelope childrenD_686_i1 b hb) + +theorem finite_children_work_686 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_686 j) (childrenD_686 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_134 5 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 5 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_337 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (7, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_558 5 (6, 3)).mono (by decide +kernel) + · exact finite_row_works_686_i0.mono (by decide +kernel) + · exact finite_row_works_686_i1.mono (by decide +kernel) + +theorem finite_row_works_686 : FiniteTemplate HasSnaky 9 required_686 envelope_686 := by + refine finite_compose HasSnaky 8 childrenC_686 childrenD_686 finite_children_work_686 (4, 5) + required_686 envelope_686 pivot_mem_686 child_required_sub_686 child_envelope_sub_686 ?_ + intro b hb + exact common_sub_686 (mem_commonEnvelope childrenD_686 b hb) + +theorem finite_children_work_688_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_688_i0 j) (childrenD_688_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 4 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_41 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_253 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_256 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_336 3 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_688_i0 : FiniteTemplate HasSnaky 8 required_688_i0 envelope_688_i0 := by + refine finite_compose HasSnaky 7 childrenC_688_i0 childrenD_688_i0 finite_children_work_688_i0 (3, 4) + required_688_i0 envelope_688_i0 pivot_mem_688_i0 child_required_sub_688_i0 child_envelope_sub_688_i0 ?_ + intro b hb + exact common_sub_688_i0 (mem_commonEnvelope childrenD_688_i0 b hb) + +theorem finite_children_work_688 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_688 j) (childrenD_688 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_688_i0.mono (by decide +kernel) + +theorem finite_row_works_688 : FiniteTemplate HasSnaky 9 required_688 envelope_688 := by + refine finite_compose HasSnaky 8 childrenC_688 childrenD_688 finite_children_work_688 (1, 5) + required_688 envelope_688 pivot_mem_688 child_required_sub_688 child_envelope_sub_688 ?_ + intro b hb + exact common_sub_688 (mem_commonEnvelope childrenD_688 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height10Part01.lean b/lean/snaky/FiniteCards/Height10Part01.lean new file mode 100644 index 0000000..4d88aaa --- /dev/null +++ b/lean/snaky/FiniteCards/Height10Part01.lean @@ -0,0 +1,361 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part04 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part03 +import FiniteCards.Height08Part01 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_399 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_399 j) (childrenD_399 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_135 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_396.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_396 4 (0, 8)).mono (by decide +kernel) + +theorem finite_row_works_399 : FiniteTemplate HasSnaky 10 required_399 envelope_399 := by + refine finite_compose HasSnaky 9 childrenC_399 childrenD_399 finite_children_work_399 (2, 5) + required_399 envelope_399 pivot_mem_399 child_required_sub_399 child_envelope_sub_399 ?_ + intro b hb + exact common_sub_399 (mem_commonEnvelope childrenD_399 b hb) + +theorem finite_children_work_401 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_401 j) (childrenD_401 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 6 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_397 4 (2, 7)).mono (by decide +kernel) + +theorem finite_row_works_401 : FiniteTemplate HasSnaky 10 required_401 envelope_401 := by + refine finite_compose HasSnaky 9 childrenC_401 childrenD_401 finite_children_work_401 (2, 4) + required_401 envelope_401 pivot_mem_401 child_required_sub_401 child_envelope_sub_401 ?_ + intro b hb + exact common_sub_401 (mem_commonEnvelope childrenD_401 b hb) + +theorem finite_children_work_408 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_408 j) (childrenD_408 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_127 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_407 4 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_408 : FiniteTemplate HasSnaky 10 required_408 envelope_408 := by + refine finite_compose HasSnaky 9 childrenC_408 childrenD_408 finite_children_work_408 (1, 5) + required_408 envelope_408 pivot_mem_408 child_required_sub_408 child_envelope_sub_408 ?_ + intro b hb + exact common_sub_408 (mem_commonEnvelope childrenD_408 b hb) + +theorem finite_children_work_409 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_409 j) (childrenD_409 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_127 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_407 4 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_409 : FiniteTemplate HasSnaky 10 required_409 envelope_409 := by + refine finite_compose HasSnaky 9 childrenC_409 childrenD_409 finite_children_work_409 (1, 4) + required_409 envelope_409 pivot_mem_409 child_required_sub_409 child_envelope_sub_409 ?_ + intro b hb + exact common_sub_409 (mem_commonEnvelope childrenD_409 b hb) + +theorem finite_children_work_410 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_410 j) (childrenD_410 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 2 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_407 4 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_410 : FiniteTemplate HasSnaky 10 required_410 envelope_410 := by + refine finite_compose HasSnaky 9 childrenC_410 childrenD_410 finite_children_work_410 (1, 5) + required_410 envelope_410 pivot_mem_410 child_required_sub_410 child_envelope_sub_410 ?_ + intro b hb + exact common_sub_410 (mem_commonEnvelope childrenD_410 b hb) + +theorem finite_children_work_411 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_411 j) (childrenD_411 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 6 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_65 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_407 4 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_411 : FiniteTemplate HasSnaky 10 required_411 envelope_411 := by + refine finite_compose HasSnaky 9 childrenC_411 childrenD_411 finite_children_work_411 (1, 5) + required_411 envelope_411 pivot_mem_411 child_required_sub_411 child_envelope_sub_411 ?_ + intro b hb + exact common_sub_411 (mem_commonEnvelope childrenD_411 b hb) + +theorem finite_children_work_444 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_444 j) (childrenD_444 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_443 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_444 : FiniteTemplate HasSnaky 10 required_444 envelope_444 := by + refine finite_compose HasSnaky 9 childrenC_444 childrenD_444 finite_children_work_444 (1, 4) + required_444 envelope_444 pivot_mem_444 child_required_sub_444 child_envelope_sub_444 ?_ + intro b hb + exact common_sub_444 (mem_commonEnvelope childrenD_444 b hb) + +theorem finite_children_work_459 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_459 j) (childrenD_459 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_13 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_33 6 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_189 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_192 4 (0, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_369 2 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_457 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_458 4 (0, 7)).mono (by decide +kernel) + +theorem finite_row_works_459 : FiniteTemplate HasSnaky 10 required_459 envelope_459 := by + refine finite_compose HasSnaky 9 childrenC_459 childrenD_459 finite_children_work_459 (1, 6) + required_459 envelope_459 pivot_mem_459 child_required_sub_459 child_envelope_sub_459 ?_ + intro b hb + exact common_sub_459 (mem_commonEnvelope childrenD_459 b hb) + +theorem finite_children_work_460 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_460 j) (childrenD_460 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 2 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_33 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_457 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_458 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_460 : FiniteTemplate HasSnaky 10 required_460 envelope_460 := by + refine finite_compose HasSnaky 9 childrenC_460 childrenD_460 finite_children_work_460 (1, 4) + required_460 envelope_460 pivot_mem_460 child_required_sub_460 child_envelope_sub_460 ?_ + intro b hb + exact common_sub_460 (mem_commonEnvelope childrenD_460 b hb) + +theorem finite_children_work_461 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_461 j) (childrenD_461 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_28 5 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_100.mono (by decide +kernel) + · exact finite_row_works_429.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_457 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_461 : FiniteTemplate HasSnaky 10 required_461 envelope_461 := by + refine finite_compose HasSnaky 9 childrenC_461 childrenD_461 finite_children_work_461 (3, 3) + required_461 envelope_461 pivot_mem_461 child_required_sub_461 child_envelope_sub_461 ?_ + intro b hb + exact common_sub_461 (mem_commonEnvelope childrenD_461 b hb) + +theorem finite_children_work_475 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_475 j) (childrenD_475 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 6 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_31 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_396 4 (0, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_475 : FiniteTemplate HasSnaky 10 required_475 envelope_475 := by + refine finite_compose HasSnaky 9 childrenC_475 childrenD_475 finite_children_work_475 (2, 5) + required_475 envelope_475 pivot_mem_475 child_required_sub_475 child_envelope_sub_475 ?_ + intro b hb + exact common_sub_475 (mem_commonEnvelope childrenD_475 b hb) + +theorem finite_children_work_476 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_476 j) (childrenD_476 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_264 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 3 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_476 : FiniteTemplate HasSnaky 10 required_476 envelope_476 := by + refine finite_compose HasSnaky 9 childrenC_476 childrenD_476 finite_children_work_476 (3, 5) + required_476 envelope_476 pivot_mem_476 child_required_sub_476 child_envelope_sub_476 ?_ + intro b hb + exact common_sub_476 (mem_commonEnvelope childrenD_476 b hb) + +theorem finite_children_work_479_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_479_i0 j) (childrenD_479_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 7 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_386 5 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_479_i0 : FiniteTemplate HasSnaky 6 required_479_i0 envelope_479_i0 := by + refine finite_compose HasSnaky 5 childrenC_479_i0 childrenD_479_i0 finite_children_work_479_i0 (3, 2) + required_479_i0 envelope_479_i0 pivot_mem_479_i0 child_required_sub_479_i0 child_envelope_sub_479_i0 ?_ + intro b hb + exact common_sub_479_i0 (mem_commonEnvelope childrenD_479_i0 b hb) + +theorem finite_children_work_479 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_479 j) (childrenD_479 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_31 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_367 4 (2, 7)).mono (by decide +kernel) + · exact finite_row_works_479_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 1 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_479 : FiniteTemplate HasSnaky 10 required_479 envelope_479 := by + refine finite_compose HasSnaky 9 childrenC_479 childrenD_479 finite_children_work_479 (3, 5) + required_479 envelope_479 pivot_mem_479 child_required_sub_479 child_envelope_sub_479 ?_ + intro b hb + exact common_sub_479 (mem_commonEnvelope childrenD_479 b hb) + +theorem finite_children_work_480 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_480 j) (childrenD_480 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_192 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_298 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 7 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 7 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_477 5 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_480 : FiniteTemplate HasSnaky 10 required_480 envelope_480 := by + refine finite_compose HasSnaky 9 childrenC_480 childrenD_480 finite_children_work_480 (3, 3) + required_480 envelope_480 pivot_mem_480 child_required_sub_480 child_envelope_sub_480 ?_ + intro b hb + exact common_sub_480 (mem_commonEnvelope childrenD_480 b hb) + +theorem finite_children_work_481 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_481 j) (childrenD_481 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 2 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_33 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_457 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_477 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_481 : FiniteTemplate HasSnaky 10 required_481 envelope_481 := by + refine finite_compose HasSnaky 9 childrenC_481 childrenD_481 finite_children_work_481 (2, 4) + required_481 envelope_481 pivot_mem_481 child_required_sub_481 child_envelope_sub_481 ?_ + intro b hb + exact common_sub_481 (mem_commonEnvelope childrenD_481 b hb) + +theorem finite_children_work_483 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_483 j) (childrenD_483 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 2 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_33 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_458 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_483 : FiniteTemplate HasSnaky 10 required_483 envelope_483 := by + refine finite_compose HasSnaky 9 childrenC_483 childrenD_483 finite_children_work_483 (2, 5) + required_483 envelope_483 pivot_mem_483 child_required_sub_483 child_envelope_sub_483 ?_ + intro b hb + exact common_sub_483 (mem_commonEnvelope childrenD_483 b hb) + +theorem finite_children_work_491_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_491_i0 j) (childrenD_491_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_60 3 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_60 7 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_83 4 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_106 1 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_491_i0 : FiniteTemplate HasSnaky 5 required_491_i0 envelope_491_i0 := by + refine finite_compose HasSnaky 4 childrenC_491_i0 childrenD_491_i0 finite_children_work_491_i0 (5, 3) + required_491_i0 envelope_491_i0 pivot_mem_491_i0 child_required_sub_491_i0 child_envelope_sub_491_i0 ?_ + intro b hb + exact common_sub_491_i0 (mem_commonEnvelope childrenD_491_i0 b hb) + +theorem finite_children_work_491_i1 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_491_i1 j) (childrenD_491_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_60 3 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_70 7 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_345 4 (2, 5)).mono (by decide +kernel) + +theorem finite_row_works_491_i1 : FiniteTemplate HasSnaky 9 required_491_i1 envelope_491_i1 := by + refine finite_compose HasSnaky 8 childrenC_491_i1 childrenD_491_i1 finite_children_work_491_i1 (5, 3) + required_491_i1 envelope_491_i1 pivot_mem_491_i1 child_required_sub_491_i1 child_envelope_sub_491_i1 ?_ + intro b hb + exact common_sub_491_i1 (mem_commonEnvelope childrenD_491_i1 b hb) + +theorem finite_children_work_491 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_491 j) (childrenD_491 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_270 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_491_i0.mono (by decide +kernel) + · exact finite_row_works_491_i1.mono (by decide +kernel) + +theorem finite_row_works_491 : FiniteTemplate HasSnaky 10 required_491 envelope_491 := by + refine finite_compose HasSnaky 9 childrenC_491 childrenD_491 finite_children_work_491 (3, 3) + required_491 envelope_491 pivot_mem_491 child_required_sub_491 child_envelope_sub_491 ?_ + intro b hb + exact common_sub_491 (mem_commonEnvelope childrenD_491 b hb) + +theorem finite_children_work_508 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_508 j) (childrenD_508 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_13 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_297.mono (by decide +kernel) + · exact finite_row_works_298.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 4 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_507 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_508 : FiniteTemplate HasSnaky 10 required_508 envelope_508 := by + refine finite_compose HasSnaky 9 childrenC_508 childrenD_508 finite_children_work_508 (4, 3) + required_508 envelope_508 pivot_mem_508 child_required_sub_508 child_envelope_sub_508 ?_ + intro b hb + exact common_sub_508 (mem_commonEnvelope childrenD_508 b hb) + +theorem finite_children_work_509 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_509 j) (childrenD_509 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_127 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_128 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_507 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_509 : FiniteTemplate HasSnaky 10 required_509 envelope_509 := by + refine finite_compose HasSnaky 9 childrenC_509 childrenD_509 finite_children_work_509 (4, 3) + required_509 envelope_509 pivot_mem_509 child_required_sub_509 child_envelope_sub_509 ?_ + intro b hb + exact common_sub_509 (mem_commonEnvelope childrenD_509 b hb) + +theorem finite_children_work_520 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_520 j) (childrenD_520 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 3 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_317 6 (6, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_519 2 (6, 2)).mono (by decide +kernel) + +theorem finite_row_works_520 : FiniteTemplate HasSnaky 10 required_520 envelope_520 := by + refine finite_compose HasSnaky 9 childrenC_520 childrenD_520 finite_children_work_520 (4, 5) + required_520 envelope_520 pivot_mem_520 child_required_sub_520 child_envelope_sub_520 ?_ + intro b hb + exact common_sub_520 (mem_commonEnvelope childrenD_520 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height10Part02.lean b/lean/snaky/FiniteCards/Height10Part02.lean new file mode 100644 index 0000000..b76f28c --- /dev/null +++ b/lean/snaky/FiniteCards/Height10Part02.lean @@ -0,0 +1,325 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_529_i4 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_529_i4 j) (childrenD_529_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 6 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_4 4 (3, 6)).mono (by decide +kernel) + +theorem finite_row_works_529_i4 : FiniteTemplate HasSnaky 2 required_529_i4 envelope_529_i4 := by + refine finite_compose HasSnaky 1 childrenC_529_i4 childrenD_529_i4 finite_children_work_529_i4 (3, 6) + required_529_i4 envelope_529_i4 pivot_mem_529_i4 child_required_sub_529_i4 child_envelope_sub_529_i4 ?_ + intro b hb + exact common_sub_529_i4 (mem_commonEnvelope childrenD_529_i4 b hb) + +theorem finite_children_work_529_i5 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_529_i5 j) (childrenD_529_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_38 3 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_351 4 (4, 7)).mono (by decide +kernel) + +theorem finite_row_works_529_i5 : FiniteTemplate HasSnaky 5 required_529_i5 envelope_529_i5 := by + refine finite_compose HasSnaky 4 childrenC_529_i5 childrenD_529_i5 finite_children_work_529_i5 (7, 3) + required_529_i5 envelope_529_i5 pivot_mem_529_i5 child_required_sub_529_i5 child_envelope_sub_529_i5 ?_ + intro b hb + exact common_sub_529_i5 (mem_commonEnvelope childrenD_529_i5 b hb) + +theorem finite_children_work_529_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_529_i3 j) (childrenD_529_i3 j) := by + intro j + fin_cases j + · exact finite_row_works_529_i4.mono (by decide +kernel) + · exact finite_row_works_529_i5.mono (by decide +kernel) + +theorem finite_row_works_529_i3 : FiniteTemplate HasSnaky 6 required_529_i3 envelope_529_i3 := by + refine finite_compose HasSnaky 5 childrenC_529_i3 childrenD_529_i3 finite_children_work_529_i3 (7, 5) + required_529_i3 envelope_529_i3 pivot_mem_529_i3 child_required_sub_529_i3 child_envelope_sub_529_i3 ?_ + intro b hb + exact common_sub_529_i3 (mem_commonEnvelope childrenD_529_i3 b hb) + +theorem finite_children_work_529_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_529_i2 j) (childrenD_529_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_529_i3.mono (by decide +kernel) + +theorem finite_row_works_529_i2 : FiniteTemplate HasSnaky 7 required_529_i2 envelope_529_i2 := by + refine finite_compose HasSnaky 6 childrenC_529_i2 childrenD_529_i2 finite_children_work_529_i2 (4, 6) + required_529_i2 envelope_529_i2 pivot_mem_529_i2 child_required_sub_529_i2 child_envelope_sub_529_i2 ?_ + intro b hb + exact common_sub_529_i2 (mem_commonEnvelope childrenD_529_i2 b hb) + +theorem finite_children_work_529_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_529_i1 j) (childrenD_529_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_529_i2.mono (by decide +kernel) + +theorem finite_row_works_529_i1 : FiniteTemplate HasSnaky 8 required_529_i1 envelope_529_i1 := by + refine finite_compose HasSnaky 7 childrenC_529_i1 childrenD_529_i1 finite_children_work_529_i1 (6, 6) + required_529_i1 envelope_529_i1 pivot_mem_529_i1 child_required_sub_529_i1 child_envelope_sub_529_i1 ?_ + intro b hb + exact common_sub_529_i1 (mem_commonEnvelope childrenD_529_i1 b hb) + +theorem finite_children_work_529_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_529_i0 j) (childrenD_529_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_133 3 (3, 7)).mono (by decide +kernel) + · exact finite_row_works_529_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_505 7 (6, 6)).mono (by decide +kernel) + +theorem finite_row_works_529_i0 : FiniteTemplate HasSnaky 9 required_529_i0 envelope_529_i0 := by + refine finite_compose HasSnaky 8 childrenC_529_i0 childrenD_529_i0 finite_children_work_529_i0 (5, 3) + required_529_i0 envelope_529_i0 pivot_mem_529_i0 child_required_sub_529_i0 child_envelope_sub_529_i0 ?_ + intro b hb + exact common_sub_529_i0 (mem_commonEnvelope childrenD_529_i0 b hb) + +theorem finite_children_work_529 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_529 j) (childrenD_529 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 1 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_189 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_369 2 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 1 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_528 0 (4, 0)).mono (by decide +kernel) + · exact finite_row_works_529_i0.mono (by decide +kernel) + +theorem finite_row_works_529 : FiniteTemplate HasSnaky 10 required_529 envelope_529 := by + refine finite_compose HasSnaky 9 childrenC_529 childrenD_529 finite_children_work_529 (5, 6) + required_529 envelope_529 pivot_mem_529 child_required_sub_529 child_envelope_sub_529 ?_ + intro b hb + exact common_sub_529 (mem_commonEnvelope childrenD_529 b hb) + +theorem finite_children_work_535 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_535 j) (childrenD_535 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_345 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_421 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_522 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_530 4 (1, 8)).mono (by decide +kernel) + · exact finite_row_works_532.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_533 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_534 4 (0, 8)).mono (by decide +kernel) + +theorem finite_row_works_535 : FiniteTemplate HasSnaky 10 required_535 envelope_535 := by + refine finite_compose HasSnaky 9 childrenC_535 childrenD_535 finite_children_work_535 (3, 5) + required_535 envelope_535 pivot_mem_535 child_required_sub_535 child_envelope_sub_535 ?_ + intro b hb + exact common_sub_535 (mem_commonEnvelope childrenD_535 b hb) + +theorem finite_children_work_540_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_540_i0 j) (childrenD_540_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_237 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_281 5 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_540_i0 : FiniteTemplate HasSnaky 6 required_540_i0 envelope_540_i0 := by + refine finite_compose HasSnaky 5 childrenC_540_i0 childrenD_540_i0 finite_children_work_540_i0 (2, 3) + required_540_i0 envelope_540_i0 pivot_mem_540_i0 child_required_sub_540_i0 child_envelope_sub_540_i0 ?_ + intro b hb + exact common_sub_540_i0 (mem_commonEnvelope childrenD_540_i0 b hb) + +theorem finite_children_work_540_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_540_i3 j) (childrenD_540_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_164 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_199 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_283 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_540_i3 : FiniteTemplate HasSnaky 7 required_540_i3 envelope_540_i3 := by + refine finite_compose HasSnaky 6 childrenC_540_i3 childrenD_540_i3 finite_children_work_540_i3 (4, 4) + required_540_i3 envelope_540_i3 pivot_mem_540_i3 child_required_sub_540_i3 child_envelope_sub_540_i3 ?_ + intro b hb + exact common_sub_540_i3 (mem_commonEnvelope childrenD_540_i3 b hb) + +theorem finite_children_work_540_i2 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_540_i2 j) (childrenD_540_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_170 0 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_540_i3.mono (by decide +kernel) + +theorem finite_row_works_540_i2 : FiniteTemplate HasSnaky 8 required_540_i2 envelope_540_i2 := by + refine finite_compose HasSnaky 7 childrenC_540_i2 childrenD_540_i2 finite_children_work_540_i2 (4, 5) + required_540_i2 envelope_540_i2 pivot_mem_540_i2 child_required_sub_540_i2 child_envelope_sub_540_i2 ?_ + intro b hb + exact common_sub_540_i2 (mem_commonEnvelope childrenD_540_i2 b hb) + +theorem finite_children_work_540_i1 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_540_i1 j) (childrenD_540_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_16 2 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_540_i2.mono (by decide +kernel) + +theorem finite_row_works_540_i1 : FiniteTemplate HasSnaky 9 required_540_i1 envelope_540_i1 := by + refine finite_compose HasSnaky 8 childrenC_540_i1 childrenD_540_i1 finite_children_work_540_i1 (0, 6) + required_540_i1 envelope_540_i1 pivot_mem_540_i1 child_required_sub_540_i1 child_envelope_sub_540_i1 ?_ + intro b hb + exact common_sub_540_i1 (mem_commonEnvelope childrenD_540_i1 b hb) + +theorem finite_children_work_540 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_540 j) (childrenD_540 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 4 (3, 6)).mono (by decide +kernel) + · exact finite_row_works_540_i0.mono (by decide +kernel) + · exact finite_row_works_540_i1.mono (by decide +kernel) + +theorem finite_row_works_540 : FiniteTemplate HasSnaky 10 required_540 envelope_540 := by + refine finite_compose HasSnaky 9 childrenC_540 childrenD_540 finite_children_work_540 (4, 3) + required_540 envelope_540 pivot_mem_540 child_required_sub_540 child_envelope_sub_540 ?_ + intro b hb + exact common_sub_540 (mem_commonEnvelope childrenD_540 b hb) + +theorem finite_children_work_541_i6 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_541_i6 j) (childrenD_541_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_35 7 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_541_i6 : FiniteTemplate HasSnaky 3 required_541_i6 envelope_541_i6 := by + refine finite_compose HasSnaky 2 childrenC_541_i6 childrenD_541_i6 finite_children_work_541_i6 (4, 2) + required_541_i6 envelope_541_i6 pivot_mem_541_i6 child_required_sub_541_i6 child_envelope_sub_541_i6 ?_ + intro b hb + exact common_sub_541_i6 (mem_commonEnvelope childrenD_541_i6 b hb) + +theorem finite_children_work_541_i5 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_541_i5 j) (childrenD_541_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_170 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_541_i6.mono (by decide +kernel) + +theorem finite_row_works_541_i5 : FiniteTemplate HasSnaky 4 required_541_i5 envelope_541_i5 := by + refine finite_compose HasSnaky 3 childrenC_541_i5 childrenD_541_i5 finite_children_work_541_i5 (4, 3) + required_541_i5 envelope_541_i5 pivot_mem_541_i5 child_required_sub_541_i5 child_envelope_sub_541_i5 ?_ + intro b hb + exact common_sub_541_i5 (mem_commonEnvelope childrenD_541_i5 b hb) + +theorem finite_children_work_541_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_541_i4 j) (childrenD_541_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 4 (3, 5)).mono (by decide +kernel) + · exact finite_row_works_86.mono (by decide +kernel) + · exact finite_row_works_541_i5.mono (by decide +kernel) + +theorem finite_row_works_541_i4 : FiniteTemplate HasSnaky 5 required_541_i4 envelope_541_i4 := by + refine finite_compose HasSnaky 4 childrenC_541_i4 childrenD_541_i4 finite_children_work_541_i4 (3, 4) + required_541_i4 envelope_541_i4 pivot_mem_541_i4 child_required_sub_541_i4 child_envelope_sub_541_i4 ?_ + intro b hb + exact common_sub_541_i4 (mem_commonEnvelope childrenD_541_i4 b hb) + +theorem finite_children_work_541_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_541_i3 j) (childrenD_541_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (4, 5)).mono (by decide +kernel) + · exact finite_row_works_541_i4.mono (by decide +kernel) + +theorem finite_row_works_541_i3 : FiniteTemplate HasSnaky 6 required_541_i3 envelope_541_i3 := by + refine finite_compose HasSnaky 5 childrenC_541_i3 childrenD_541_i3 finite_children_work_541_i3 (3, 5) + required_541_i3 envelope_541_i3 pivot_mem_541_i3 child_required_sub_541_i3 child_envelope_sub_541_i3 ?_ + intro b hb + exact common_sub_541_i3 (mem_commonEnvelope childrenD_541_i3 b hb) + +theorem finite_children_work_541_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_541_i2 j) (childrenD_541_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 3 (1, 9)).mono (by decide +kernel) + · exact finite_row_works_541_i3.mono (by decide +kernel) + +theorem finite_row_works_541_i2 : FiniteTemplate HasSnaky 7 required_541_i2 envelope_541_i2 := by + refine finite_compose HasSnaky 6 childrenC_541_i2 childrenD_541_i2 finite_children_work_541_i2 (2, 5) + required_541_i2 envelope_541_i2 pivot_mem_541_i2 child_required_sub_541_i2 child_envelope_sub_541_i2 ?_ + intro b hb + exact common_sub_541_i2 (mem_commonEnvelope childrenD_541_i2 b hb) + +theorem finite_children_work_541_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_541_i1 j) (childrenD_541_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (1, 8)).mono (by decide +kernel) + · exact finite_row_works_541_i2.mono (by decide +kernel) + +theorem finite_row_works_541_i1 : FiniteTemplate HasSnaky 8 required_541_i1 envelope_541_i1 := by + refine finite_compose HasSnaky 7 childrenC_541_i1 childrenD_541_i1 finite_children_work_541_i1 (0, 4) + required_541_i1 envelope_541_i1 pivot_mem_541_i1 child_required_sub_541_i1 child_envelope_sub_541_i1 ?_ + intro b hb + exact common_sub_541_i1 (mem_commonEnvelope childrenD_541_i1 b hb) + +theorem finite_children_work_541_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_541_i0 j) (childrenD_541_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_541_i1.mono (by decide +kernel) + +theorem finite_row_works_541_i0 : FiniteTemplate HasSnaky 9 required_541_i0 envelope_541_i0 := by + refine finite_compose HasSnaky 8 childrenC_541_i0 childrenD_541_i0 finite_children_work_541_i0 (1, 9) + required_541_i0 envelope_541_i0 pivot_mem_541_i0 child_required_sub_541_i0 child_envelope_sub_541_i0 ?_ + intro b hb + exact common_sub_541_i0 (mem_commonEnvelope childrenD_541_i0 b hb) + +theorem finite_children_work_541 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_541 j) (childrenD_541 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 2 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_541_i0.mono (by decide +kernel) + +theorem finite_row_works_541 : FiniteTemplate HasSnaky 10 required_541 envelope_541 := by + refine finite_compose HasSnaky 9 childrenC_541 childrenD_541 finite_children_work_541 (1, 8) + required_541 envelope_541 pivot_mem_541 child_required_sub_541 child_envelope_sub_541 ?_ + intro b hb + exact common_sub_541 (mem_commonEnvelope childrenD_541 b hb) + +theorem finite_children_work_545_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_545_i0 j) (childrenD_545_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_84 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 5 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_419 4 (0, 7)).mono (by decide +kernel) + +theorem finite_row_works_545_i0 : FiniteTemplate HasSnaky 9 required_545_i0 envelope_545_i0 := by + refine finite_compose HasSnaky 8 childrenC_545_i0 childrenD_545_i0 finite_children_work_545_i0 (1, 6) + required_545_i0 envelope_545_i0 pivot_mem_545_i0 child_required_sub_545_i0 child_envelope_sub_545_i0 ?_ + intro b hb + exact common_sub_545_i0 (mem_commonEnvelope childrenD_545_i0 b hb) + +theorem finite_children_work_545 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_545 j) (childrenD_545 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_27 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_284 6 (2, 9)).mono (by decide +kernel) + · exact finite_row_works_545_i0.mono (by decide +kernel) + +theorem finite_row_works_545 : FiniteTemplate HasSnaky 10 required_545 envelope_545 := by + refine finite_compose HasSnaky 9 childrenC_545 childrenD_545 finite_children_work_545 (1, 3) + required_545 envelope_545 pivot_mem_545 child_required_sub_545 child_envelope_sub_545 ?_ + intro b hb + exact common_sub_545 (mem_commonEnvelope childrenD_545 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height10Part03.lean b/lean/snaky/FiniteCards/Height10Part03.lean new file mode 100644 index 0000000..8ecb909 --- /dev/null +++ b/lean/snaky/FiniteCards/Height10Part03.lean @@ -0,0 +1,327 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part03 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part04 +import FiniteCards.Height09Part03 +import FiniteCards.Height09Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_546_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_546_i4 j) (childrenD_546_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_25 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_27 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_37 1 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_546_i4 : FiniteTemplate HasSnaky 5 required_546_i4 envelope_546_i4 := by + refine finite_compose HasSnaky 4 childrenC_546_i4 childrenD_546_i4 finite_children_work_546_i4 (3, 6) + required_546_i4 envelope_546_i4 pivot_mem_546_i4 child_required_sub_546_i4 child_envelope_sub_546_i4 ?_ + intro b hb + exact common_sub_546_i4 (mem_commonEnvelope childrenD_546_i4 b hb) + +theorem finite_children_work_546_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_546_i3 j) (childrenD_546_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_546_i4.mono (by decide +kernel) + +theorem finite_row_works_546_i3 : FiniteTemplate HasSnaky 6 required_546_i3 envelope_546_i3 := by + refine finite_compose HasSnaky 5 childrenC_546_i3 childrenD_546_i3 finite_children_work_546_i3 (0, 6) + required_546_i3 envelope_546_i3 pivot_mem_546_i3 child_required_sub_546_i3 child_envelope_sub_546_i3 ?_ + intro b hb + exact common_sub_546_i3 (mem_commonEnvelope childrenD_546_i3 b hb) + +theorem finite_children_work_546_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_546_i2 j) (childrenD_546_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_546_i3.mono (by decide +kernel) + +theorem finite_row_works_546_i2 : FiniteTemplate HasSnaky 7 required_546_i2 envelope_546_i2 := by + refine finite_compose HasSnaky 6 childrenC_546_i2 childrenD_546_i2 finite_children_work_546_i2 (2, 6) + required_546_i2 envelope_546_i2 pivot_mem_546_i2 child_required_sub_546_i2 child_envelope_sub_546_i2 ?_ + intro b hb + exact common_sub_546_i2 (mem_commonEnvelope childrenD_546_i2 b hb) + +theorem finite_children_work_546_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_546_i1 j) (childrenD_546_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_546_i2.mono (by decide +kernel) + +theorem finite_row_works_546_i1 : FiniteTemplate HasSnaky 8 required_546_i1 envelope_546_i1 := by + refine finite_compose HasSnaky 7 childrenC_546_i1 childrenD_546_i1 finite_children_work_546_i1 (2, 3) + required_546_i1 envelope_546_i1 pivot_mem_546_i1 child_required_sub_546_i1 child_envelope_sub_546_i1 ?_ + intro b hb + exact common_sub_546_i1 (mem_commonEnvelope childrenD_546_i1 b hb) + +theorem finite_children_work_546_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_546_i0 j) (childrenD_546_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_19 6 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_62 4 (0, 7)).mono (by decide +kernel) + · exact finite_row_works_546_i1.mono (by decide +kernel) + +theorem finite_row_works_546_i0 : FiniteTemplate HasSnaky 9 required_546_i0 envelope_546_i0 := by + refine finite_compose HasSnaky 8 childrenC_546_i0 childrenD_546_i0 finite_children_work_546_i0 (1, 3) + required_546_i0 envelope_546_i0 pivot_mem_546_i0 child_required_sub_546_i0 child_envelope_sub_546_i0 ?_ + intro b hb + exact common_sub_546_i0 (mem_commonEnvelope childrenD_546_i0 b hb) + +theorem finite_children_work_546 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_546 j) (childrenD_546 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 2 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_63 2 (2, 3)).mono (by decide +kernel) + · exact finite_row_works_546_i0.mono (by decide +kernel) + +theorem finite_row_works_546 : FiniteTemplate HasSnaky 10 required_546 envelope_546 := by + refine finite_compose HasSnaky 9 childrenC_546 childrenD_546 finite_children_work_546 (1, 6) + required_546 envelope_546 pivot_mem_546 child_required_sub_546 child_envelope_sub_546 ?_ + intro b hb + exact common_sub_546 (mem_commonEnvelope childrenD_546 b hb) + +theorem finite_children_work_556_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_556_i0 j) (childrenD_556_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_115 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_171 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 4 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 0 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_285 4 (2, 7)).mono (by decide +kernel) + +theorem finite_row_works_556_i0 : FiniteTemplate HasSnaky 9 required_556_i0 envelope_556_i0 := by + refine finite_compose HasSnaky 8 childrenC_556_i0 childrenD_556_i0 finite_children_work_556_i0 (5, 4) + required_556_i0 envelope_556_i0 pivot_mem_556_i0 child_required_sub_556_i0 child_envelope_sub_556_i0 ?_ + intro b hb + exact common_sub_556_i0 (mem_commonEnvelope childrenD_556_i0 b hb) + +theorem finite_children_work_556 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_556 j) (childrenD_556 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 6 (4, 4)).mono (by decide +kernel) + · exact finite_row_works_556_i0.mono (by decide +kernel) + +theorem finite_row_works_556 : FiniteTemplate HasSnaky 10 required_556 envelope_556 := by + refine finite_compose HasSnaky 9 childrenC_556 childrenD_556 finite_children_work_556 (2, 4) + required_556 envelope_556 pivot_mem_556 child_required_sub_556 child_envelope_sub_556 ?_ + intro b hb + exact common_sub_556 (mem_commonEnvelope childrenD_556 b hb) + +theorem finite_children_work_560_i4 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_560_i4 j) (childrenD_560_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 1 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_156 4 (3, 5)).mono (by decide +kernel) + +theorem finite_row_works_560_i4 : FiniteTemplate HasSnaky 4 required_560_i4 envelope_560_i4 := by + refine finite_compose HasSnaky 3 childrenC_560_i4 childrenD_560_i4 finite_children_work_560_i4 (5, 2) + required_560_i4 envelope_560_i4 pivot_mem_560_i4 child_required_sub_560_i4 child_envelope_sub_560_i4 ?_ + intro b hb + exact common_sub_560_i4 (mem_commonEnvelope childrenD_560_i4 b hb) + +theorem finite_children_work_560_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_560_i3 j) (childrenD_560_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 5 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 5 (6, 1)).mono (by decide +kernel) + · exact finite_row_works_560_i4.mono (by decide +kernel) + +theorem finite_row_works_560_i3 : FiniteTemplate HasSnaky 5 required_560_i3 envelope_560_i3 := by + refine finite_compose HasSnaky 4 childrenC_560_i3 childrenD_560_i3 finite_children_work_560_i3 (5, 1) + required_560_i3 envelope_560_i3 pivot_mem_560_i3 child_required_sub_560_i3 child_envelope_sub_560_i3 ?_ + intro b hb + exact common_sub_560_i3 (mem_commonEnvelope childrenD_560_i3 b hb) + +theorem finite_children_work_560_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_560_i2 j) (childrenD_560_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_560_i3.mono (by decide +kernel) + +theorem finite_row_works_560_i2 : FiniteTemplate HasSnaky 6 required_560_i2 envelope_560_i2 := by + refine finite_compose HasSnaky 5 childrenC_560_i2 childrenD_560_i2 finite_children_work_560_i2 (4, 1) + required_560_i2 envelope_560_i2 pivot_mem_560_i2 child_required_sub_560_i2 child_envelope_sub_560_i2 ?_ + intro b hb + exact common_sub_560_i2 (mem_commonEnvelope childrenD_560_i2 b hb) + +theorem finite_children_work_560_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_560_i1 j) (childrenD_560_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_153 7 (6, 5)).mono (by decide +kernel) + · exact finite_row_works_560_i2.mono (by decide +kernel) + +theorem finite_row_works_560_i1 : FiniteTemplate HasSnaky 7 required_560_i1 envelope_560_i1 := by + refine finite_compose HasSnaky 6 childrenC_560_i1 childrenD_560_i1 finite_children_work_560_i1 (6, 5) + required_560_i1 envelope_560_i1 pivot_mem_560_i1 child_required_sub_560_i1 child_envelope_sub_560_i1 ?_ + intro b hb + exact common_sub_560_i1 (mem_commonEnvelope childrenD_560_i1 b hb) + +theorem finite_children_work_560_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_560_i0 j) (childrenD_560_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_560_i1.mono (by decide +kernel) + +theorem finite_row_works_560_i0 : FiniteTemplate HasSnaky 8 required_560_i0 envelope_560_i0 := by + refine finite_compose HasSnaky 7 childrenC_560_i0 childrenD_560_i0 finite_children_work_560_i0 (3, 1) + required_560_i0 envelope_560_i0 pivot_mem_560_i0 child_required_sub_560_i0 child_envelope_sub_560_i0 ?_ + intro b hb + exact common_sub_560_i0 (mem_commonEnvelope childrenD_560_i0 b hb) + +theorem finite_children_work_560_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_560_i5 j) (childrenD_560_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_227 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_245 7 (6, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_274 4 (2, 7)).mono (by decide +kernel) + +theorem finite_row_works_560_i5 : FiniteTemplate HasSnaky 6 required_560_i5 envelope_560_i5 := by + refine finite_compose HasSnaky 5 childrenC_560_i5 childrenD_560_i5 finite_children_work_560_i5 (5, 3) + required_560_i5 envelope_560_i5 pivot_mem_560_i5 child_required_sub_560_i5 child_envelope_sub_560_i5 ?_ + intro b hb + exact common_sub_560_i5 (mem_commonEnvelope childrenD_560_i5 b hb) + +theorem finite_children_work_560 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_560 j) (childrenD_560 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_67 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_228 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_373 4 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_531 0 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_560_i0.mono (by decide +kernel) + · exact finite_row_works_560_i5.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_559 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_560 : FiniteTemplate HasSnaky 10 required_560 envelope_560 := by + refine finite_compose HasSnaky 9 childrenC_560 childrenD_560 finite_children_work_560 (5, 4) + required_560 envelope_560 pivot_mem_560 child_required_sub_560 child_envelope_sub_560 ?_ + intro b hb + exact common_sub_560 (mem_commonEnvelope childrenD_560 b hb) + +theorem finite_children_work_563_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_563_i2 j) (childrenD_563_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_393 4 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_563_i2 : FiniteTemplate HasSnaky 7 required_563_i2 envelope_563_i2 := by + refine finite_compose HasSnaky 6 childrenC_563_i2 childrenD_563_i2 finite_children_work_563_i2 (2, 6) + required_563_i2 envelope_563_i2 pivot_mem_563_i2 child_required_sub_563_i2 child_envelope_sub_563_i2 ?_ + intro b hb + exact common_sub_563_i2 (mem_commonEnvelope childrenD_563_i2 b hb) + +theorem finite_children_work_563_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_563_i1 j) (childrenD_563_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 5)).mono (by decide +kernel) + · exact finite_row_works_563_i2.mono (by decide +kernel) + +theorem finite_row_works_563_i1 : FiniteTemplate HasSnaky 8 required_563_i1 envelope_563_i1 := by + refine finite_compose HasSnaky 7 childrenC_563_i1 childrenD_563_i1 finite_children_work_563_i1 (2, 4) + required_563_i1 envelope_563_i1 pivot_mem_563_i1 child_required_sub_563_i1 child_envelope_sub_563_i1 ?_ + intro b hb + exact common_sub_563_i1 (mem_commonEnvelope childrenD_563_i1 b hb) + +theorem finite_children_work_563_i6 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_563_i6 j) (childrenD_563_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 6 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_38 7 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_563_i6 : FiniteTemplate HasSnaky 3 required_563_i6 envelope_563_i6 := by + refine finite_compose HasSnaky 2 childrenC_563_i6 childrenD_563_i6 finite_children_work_563_i6 (3, 3) + required_563_i6 envelope_563_i6 pivot_mem_563_i6 child_required_sub_563_i6 child_envelope_sub_563_i6 ?_ + intro b hb + exact common_sub_563_i6 (mem_commonEnvelope childrenD_563_i6 b hb) + +theorem finite_children_work_563_i5 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_563_i5 j) (childrenD_563_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 4 (3, 7)).mono (by decide +kernel) + · exact finite_row_works_563_i6.mono (by decide +kernel) + +theorem finite_row_works_563_i5 : FiniteTemplate HasSnaky 4 required_563_i5 envelope_563_i5 := by + refine finite_compose HasSnaky 3 childrenC_563_i5 childrenD_563_i5 finite_children_work_563_i5 (3, 6) + required_563_i5 envelope_563_i5 pivot_mem_563_i5 child_required_sub_563_i5 child_envelope_sub_563_i5 ?_ + intro b hb + exact common_sub_563_i5 (mem_commonEnvelope childrenD_563_i5 b hb) + +theorem finite_children_work_563_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_563_i4 j) (childrenD_563_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 4 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_563_i5.mono (by decide +kernel) + +theorem finite_row_works_563_i4 : FiniteTemplate HasSnaky 5 required_563_i4 envelope_563_i4 := by + refine finite_compose HasSnaky 4 childrenC_563_i4 childrenD_563_i4 finite_children_work_563_i4 (3, 4) + required_563_i4 envelope_563_i4 pivot_mem_563_i4 child_required_sub_563_i4 child_envelope_sub_563_i4 ?_ + intro b hb + exact common_sub_563_i4 (mem_commonEnvelope childrenD_563_i4 b hb) + +theorem finite_children_work_563_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_563_i3 j) (childrenD_563_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_563_i4.mono (by decide +kernel) + +theorem finite_row_works_563_i3 : FiniteTemplate HasSnaky 6 required_563_i3 envelope_563_i3 := by + refine finite_compose HasSnaky 5 childrenC_563_i3 childrenD_563_i3 finite_children_work_563_i3 (4, 4) + required_563_i3 envelope_563_i3 pivot_mem_563_i3 child_required_sub_563_i3 child_envelope_sub_563_i3 ?_ + intro b hb + exact common_sub_563_i3 (mem_commonEnvelope childrenD_563_i3 b hb) + +theorem finite_children_work_563_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_563_i0 j) (childrenD_563_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 1 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_563_i1.mono (by decide +kernel) + · exact finite_row_works_563_i3.mono (by decide +kernel) + +theorem finite_row_works_563_i0 : FiniteTemplate HasSnaky 9 required_563_i0 envelope_563_i0 := by + refine finite_compose HasSnaky 8 childrenC_563_i0 childrenD_563_i0 finite_children_work_563_i0 (4, 5) + required_563_i0 envelope_563_i0 pivot_mem_563_i0 child_required_sub_563_i0 child_envelope_sub_563_i0 ?_ + intro b hb + exact common_sub_563_i0 (mem_commonEnvelope childrenD_563_i0 b hb) + +theorem finite_children_work_563 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_563 j) (childrenD_563 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_134 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_258 4 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 4 (0, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_507 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_563_i0.mono (by decide +kernel) + · exact finite_row_works_561.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_562 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_563 : FiniteTemplate HasSnaky 10 required_563 envelope_563 := by + refine finite_compose HasSnaky 9 childrenC_563 childrenD_563 finite_children_work_563 (3, 5) + required_563 envelope_563 pivot_mem_563 child_required_sub_563 child_envelope_sub_563 ?_ + intro b hb + exact common_sub_563 (mem_commonEnvelope childrenD_563 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height10Part04.lean b/lean/snaky/FiniteCards/Height10Part04.lean new file mode 100644 index 0000000..f64b80f --- /dev/null +++ b/lean/snaky/FiniteCards/Height10Part04.lean @@ -0,0 +1,282 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part01 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_569_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_569_i2 j) (childrenD_569_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_54 0 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_569_i2 : FiniteTemplate HasSnaky 4 required_569_i2 envelope_569_i2 := by + refine finite_compose HasSnaky 3 childrenC_569_i2 childrenD_569_i2 finite_children_work_569_i2 (6, 6) + required_569_i2 envelope_569_i2 pivot_mem_569_i2 child_required_sub_569_i2 child_envelope_sub_569_i2 ?_ + intro b hb + exact common_sub_569_i2 (mem_commonEnvelope childrenD_569_i2 b hb) + +theorem finite_children_work_569_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_569_i1 j) (childrenD_569_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_68 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_569_i2.mono (by decide +kernel) + +theorem finite_row_works_569_i1 : FiniteTemplate HasSnaky 5 required_569_i1 envelope_569_i1 := by + refine finite_compose HasSnaky 4 childrenC_569_i1 childrenD_569_i1 finite_children_work_569_i1 (5, 3) + required_569_i1 envelope_569_i1 pivot_mem_569_i1 child_required_sub_569_i1 child_envelope_sub_569_i1 ?_ + intro b hb + exact common_sub_569_i1 (mem_commonEnvelope childrenD_569_i1 b hb) + +theorem finite_children_work_569_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_569_i3 j) (childrenD_569_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_169 7 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_202 4 (3, 6)).mono (by decide +kernel) + +theorem finite_row_works_569_i3 : FiniteTemplate HasSnaky 6 required_569_i3 envelope_569_i3 := by + refine finite_compose HasSnaky 5 childrenC_569_i3 childrenD_569_i3 finite_children_work_569_i3 (6, 3) + required_569_i3 envelope_569_i3 pivot_mem_569_i3 child_required_sub_569_i3 child_envelope_sub_569_i3 ?_ + intro b hb + exact common_sub_569_i3 (mem_commonEnvelope childrenD_569_i3 b hb) + +theorem finite_children_work_569_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_569_i0 j) (childrenD_569_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_569_i1.mono (by decide +kernel) + · exact finite_row_works_569_i3.mono (by decide +kernel) + +theorem finite_row_works_569_i0 : FiniteTemplate HasSnaky 7 required_569_i0 envelope_569_i0 := by + refine finite_compose HasSnaky 6 childrenC_569_i0 childrenD_569_i0 finite_children_work_569_i0 (6, 5) + required_569_i0 envelope_569_i0 pivot_mem_569_i0 child_required_sub_569_i0 child_envelope_sub_569_i0 ?_ + intro b hb + exact common_sub_569_i0 (mem_commonEnvelope childrenD_569_i0 b hb) + +theorem finite_children_work_569_i4 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_569_i4 j) (childrenD_569_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_68 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_495 0 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_569_i4 : FiniteTemplate HasSnaky 6 required_569_i4 envelope_569_i4 := by + refine finite_compose HasSnaky 5 childrenC_569_i4 childrenD_569_i4 finite_children_work_569_i4 (5, 3) + required_569_i4 envelope_569_i4 pivot_mem_569_i4 child_required_sub_569_i4 child_envelope_sub_569_i4 ?_ + intro b hb + exact common_sub_569_i4 (mem_commonEnvelope childrenD_569_i4 b hb) + +theorem finite_children_work_569_i6 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_569_i6 j) (childrenD_569_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_99 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_169 7 (6, 3)).mono (by decide +kernel) + +theorem finite_row_works_569_i6 : FiniteTemplate HasSnaky 5 required_569_i6 envelope_569_i6 := by + refine finite_compose HasSnaky 4 childrenC_569_i6 childrenD_569_i6 finite_children_work_569_i6 (6, 3) + required_569_i6 envelope_569_i6 pivot_mem_569_i6 child_required_sub_569_i6 child_envelope_sub_569_i6 ?_ + intro b hb + exact common_sub_569_i6 (mem_commonEnvelope childrenD_569_i6 b hb) + +theorem finite_children_work_569_i7 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_569_i7 j) (childrenD_569_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 1 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_288 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_569_i7 : FiniteTemplate HasSnaky 5 required_569_i7 envelope_569_i7 := by + refine finite_compose HasSnaky 4 childrenC_569_i7 childrenD_569_i7 finite_children_work_569_i7 (4, 6) + required_569_i7 envelope_569_i7 pivot_mem_569_i7 child_required_sub_569_i7 child_envelope_sub_569_i7 ?_ + intro b hb + exact common_sub_569_i7 (mem_commonEnvelope childrenD_569_i7 b hb) + +theorem finite_children_work_569_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_569_i5 j) (childrenD_569_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 3 (2, 6)).mono (by decide +kernel) + · exact finite_row_works_569_i6.mono (by decide +kernel) + · exact finite_row_works_569_i7.mono (by decide +kernel) + +theorem finite_row_works_569_i5 : FiniteTemplate HasSnaky 6 required_569_i5 envelope_569_i5 := by + refine finite_compose HasSnaky 5 childrenC_569_i5 childrenD_569_i5 finite_children_work_569_i5 (6, 5) + required_569_i5 envelope_569_i5 pivot_mem_569_i5 child_required_sub_569_i5 child_envelope_sub_569_i5 ?_ + intro b hb + exact common_sub_569_i5 (mem_commonEnvelope childrenD_569_i5 b hb) + +theorem finite_children_work_569 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_569 j) (childrenD_569 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_287 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_322 4 (2, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_457 1 (2, 4)).mono (by decide +kernel) + · exact finite_row_works_569_i0.mono (by decide +kernel) + · exact finite_row_works_569_i4.mono (by decide +kernel) + · exact finite_row_works_569_i5.mono (by decide +kernel) + +theorem finite_row_works_569 : FiniteTemplate HasSnaky 10 required_569 envelope_569 := by + refine finite_compose HasSnaky 9 childrenC_569 childrenD_569 finite_children_work_569 (5, 5) + required_569 envelope_569 pivot_mem_569 child_required_sub_569 child_envelope_sub_569 ?_ + intro b hb + exact common_sub_569 (mem_commonEnvelope childrenD_569 b hb) + +theorem finite_children_work_575_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_575_i0 j) (childrenD_575_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 6 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 0 (2, 3)).mono (by decide +kernel) + +theorem finite_row_works_575_i0 : FiniteTemplate HasSnaky 4 required_575_i0 envelope_575_i0 := by + refine finite_compose HasSnaky 3 childrenC_575_i0 childrenD_575_i0 finite_children_work_575_i0 (2, 4) + required_575_i0 envelope_575_i0 pivot_mem_575_i0 child_required_sub_575_i0 child_envelope_sub_575_i0 ?_ + intro b hb + exact common_sub_575_i0 (mem_commonEnvelope childrenD_575_i0 b hb) + +theorem finite_children_work_575_i2 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_575_i2 j) (childrenD_575_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 6 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 3 (2, 4)).mono (by decide +kernel) + +theorem finite_row_works_575_i2 : FiniteTemplate HasSnaky 3 required_575_i2 envelope_575_i2 := by + refine finite_compose HasSnaky 2 childrenC_575_i2 childrenD_575_i2 finite_children_work_575_i2 (2, 4) + required_575_i2 envelope_575_i2 pivot_mem_575_i2 child_required_sub_575_i2 child_envelope_sub_575_i2 ?_ + intro b hb + exact common_sub_575_i2 (mem_commonEnvelope childrenD_575_i2 b hb) + +theorem finite_children_work_575_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_575_i1 j) (childrenD_575_i1 j) := by + intro j + fin_cases j + · exact finite_row_works_575_i2.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_554 5 (7, 4)).mono (by decide +kernel) + +theorem finite_row_works_575_i1 : FiniteTemplate HasSnaky 8 required_575_i1 envelope_575_i1 := by + refine finite_compose HasSnaky 7 childrenC_575_i1 childrenD_575_i1 finite_children_work_575_i1 (6, 4) + required_575_i1 envelope_575_i1 pivot_mem_575_i1 child_required_sub_575_i1 child_envelope_sub_575_i1 ?_ + intro b hb + exact common_sub_575_i1 (mem_commonEnvelope childrenD_575_i1 b hb) + +theorem finite_children_work_575_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_575_i3 j) (childrenD_575_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_280 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_554 5 (7, 4)).mono (by decide +kernel) + +theorem finite_row_works_575_i3 : FiniteTemplate HasSnaky 8 required_575_i3 envelope_575_i3 := by + refine finite_compose HasSnaky 7 childrenC_575_i3 childrenD_575_i3 finite_children_work_575_i3 (6, 4) + required_575_i3 envelope_575_i3 pivot_mem_575_i3 child_required_sub_575_i3 child_envelope_sub_575_i3 ?_ + intro b hb + exact common_sub_575_i3 (mem_commonEnvelope childrenD_575_i3 b hb) + +theorem finite_children_work_575 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_575 j) (childrenD_575 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_257 0 (2, 1)).mono (by decide +kernel) + · exact finite_row_works_326.mono (by decide +kernel) + · exact finite_row_works_575_i0.mono (by decide +kernel) + · exact finite_row_works_575_i1.mono (by decide +kernel) + · exact finite_row_works_575_i3.mono (by decide +kernel) + +theorem finite_row_works_575 : FiniteTemplate HasSnaky 10 required_575 envelope_575 := by + refine finite_compose HasSnaky 9 childrenC_575 childrenD_575 finite_children_work_575 (5, 4) + required_575 envelope_575 pivot_mem_575 child_required_sub_575 child_envelope_sub_575 ?_ + intro b hb + exact common_sub_575 (mem_commonEnvelope childrenD_575 b hb) + +theorem finite_children_work_578 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_578 j) (childrenD_578 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_26 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_49 4 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_117 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_577 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_578 : FiniteTemplate HasSnaky 10 required_578 envelope_578 := by + refine finite_compose HasSnaky 9 childrenC_578 childrenD_578 finite_children_work_578 (4, 3) + required_578 envelope_578 pivot_mem_578 child_required_sub_578 child_envelope_sub_578 ?_ + intro b hb + exact common_sub_578 (mem_commonEnvelope childrenD_578 b hb) + +theorem finite_children_work_580 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_580 j) (childrenD_580 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_24 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_49 4 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_194 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_577.mono (by decide +kernel) + +theorem finite_row_works_580 : FiniteTemplate HasSnaky 10 required_580 envelope_580 := by + refine finite_compose HasSnaky 9 childrenC_580 childrenD_580 finite_children_work_580 (4, 2) + required_580 envelope_580 pivot_mem_580 child_required_sub_580 child_envelope_sub_580 ?_ + intro b hb + exact common_sub_580 (mem_commonEnvelope childrenD_580 b hb) + +theorem finite_children_work_585_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_585_i2 j) (childrenD_585_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_358 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_585_i2 : FiniteTemplate HasSnaky 7 required_585_i2 envelope_585_i2 := by + refine finite_compose HasSnaky 6 childrenC_585_i2 childrenD_585_i2 finite_children_work_585_i2 (1, 4) + required_585_i2 envelope_585_i2 pivot_mem_585_i2 child_required_sub_585_i2 child_envelope_sub_585_i2 ?_ + intro b hb + exact common_sub_585_i2 (mem_commonEnvelope childrenD_585_i2 b hb) + +theorem finite_children_work_585_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_585_i1 j) (childrenD_585_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_585_i2.mono (by decide +kernel) + +theorem finite_row_works_585_i1 : FiniteTemplate HasSnaky 8 required_585_i1 envelope_585_i1 := by + refine finite_compose HasSnaky 7 childrenC_585_i1 childrenD_585_i1 finite_children_work_585_i1 (4, 1) + required_585_i1 envelope_585_i1 pivot_mem_585_i1 child_required_sub_585_i1 child_envelope_sub_585_i1 ?_ + intro b hb + exact common_sub_585_i1 (mem_commonEnvelope childrenD_585_i1 b hb) + +theorem finite_children_work_585_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_585_i0 j) (childrenD_585_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_585_i1.mono (by decide +kernel) + +theorem finite_row_works_585_i0 : FiniteTemplate HasSnaky 9 required_585_i0 envelope_585_i0 := by + refine finite_compose HasSnaky 8 childrenC_585_i0 childrenD_585_i0 finite_children_work_585_i0 (1, 1) + required_585_i0 envelope_585_i0 pivot_mem_585_i0 child_required_sub_585_i0 child_envelope_sub_585_i0 ?_ + intro b hb + exact common_sub_585_i0 (mem_commonEnvelope childrenD_585_i0 b hb) + +theorem finite_children_work_585 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_585 j) (childrenD_585 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_585_i0.mono (by decide +kernel) + +theorem finite_row_works_585 : FiniteTemplate HasSnaky 10 required_585 envelope_585 := by + refine finite_compose HasSnaky 9 childrenC_585 childrenD_585 finite_children_work_585 (1, 3) + required_585 envelope_585 pivot_mem_585 child_required_sub_585 child_envelope_sub_585 ?_ + intro b hb + exact common_sub_585 (mem_commonEnvelope childrenD_585 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height10Part05.lean b/lean/snaky/FiniteCards/Height10Part05.lean new file mode 100644 index 0000000..5a74e4a --- /dev/null +++ b/lean/snaky/FiniteCards/Height10Part05.lean @@ -0,0 +1,299 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part05 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part04 +import FiniteCards.Height07Part05 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_594_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_594_i0 j) (childrenD_594_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_91 0 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_594_i0 : FiniteTemplate HasSnaky 5 required_594_i0 envelope_594_i0 := by + refine finite_compose HasSnaky 4 childrenC_594_i0 childrenD_594_i0 finite_children_work_594_i0 (5, 5) + required_594_i0 envelope_594_i0 pivot_mem_594_i0 child_required_sub_594_i0 child_envelope_sub_594_i0 ?_ + intro b hb + exact common_sub_594_i0 (mem_commonEnvelope childrenD_594_i0 b hb) + +theorem finite_children_work_594_i7 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_594_i7 j) (childrenD_594_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 4 (5, 5)).mono (by decide +kernel) + +theorem finite_row_works_594_i7 : FiniteTemplate HasSnaky 3 required_594_i7 envelope_594_i7 := by + refine finite_compose HasSnaky 2 childrenC_594_i7 childrenD_594_i7 finite_children_work_594_i7 (5, 2) + required_594_i7 envelope_594_i7 pivot_mem_594_i7 child_required_sub_594_i7 child_envelope_sub_594_i7 ?_ + intro b hb + exact common_sub_594_i7 (mem_commonEnvelope childrenD_594_i7 b hb) + +theorem finite_children_work_594_i6 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_594_i6 j) (childrenD_594_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_594_i7.mono (by decide +kernel) + +theorem finite_row_works_594_i6 : FiniteTemplate HasSnaky 4 required_594_i6 envelope_594_i6 := by + refine finite_compose HasSnaky 3 childrenC_594_i6 childrenD_594_i6 finite_children_work_594_i6 (5, 5) + required_594_i6 envelope_594_i6 pivot_mem_594_i6 child_required_sub_594_i6 child_envelope_sub_594_i6 ?_ + intro b hb + exact common_sub_594_i6 (mem_commonEnvelope childrenD_594_i6 b hb) + +theorem finite_children_work_594_i5 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_594_i5 j) (childrenD_594_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_375 3 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_594_i6.mono (by decide +kernel) + +theorem finite_row_works_594_i5 : FiniteTemplate HasSnaky 5 required_594_i5 envelope_594_i5 := by + refine finite_compose HasSnaky 4 childrenC_594_i5 childrenD_594_i5 finite_children_work_594_i5 (5, 1) + required_594_i5 envelope_594_i5 pivot_mem_594_i5 child_required_sub_594_i5 child_envelope_sub_594_i5 ?_ + intro b hb + exact common_sub_594_i5 (mem_commonEnvelope childrenD_594_i5 b hb) + +theorem finite_children_work_594_i4 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_594_i4 j) (childrenD_594_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (2, 6)).mono (by decide +kernel) + · exact finite_row_works_594_i5.mono (by decide +kernel) + +theorem finite_row_works_594_i4 : FiniteTemplate HasSnaky 6 required_594_i4 envelope_594_i4 := by + refine finite_compose HasSnaky 5 childrenC_594_i4 childrenD_594_i4 finite_children_work_594_i4 (1, 2) + required_594_i4 envelope_594_i4 pivot_mem_594_i4 child_required_sub_594_i4 child_envelope_sub_594_i4 ?_ + intro b hb + exact common_sub_594_i4 (mem_commonEnvelope childrenD_594_i4 b hb) + +theorem finite_children_work_594_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_594_i3 j) (childrenD_594_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 6 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_208 1 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_594_i4.mono (by decide +kernel) + +theorem finite_row_works_594_i3 : FiniteTemplate HasSnaky 7 required_594_i3 envelope_594_i3 := by + refine finite_compose HasSnaky 6 childrenC_594_i3 childrenD_594_i3 finite_children_work_594_i3 (2, 5) + required_594_i3 envelope_594_i3 pivot_mem_594_i3 child_required_sub_594_i3 child_envelope_sub_594_i3 ?_ + intro b hb + exact common_sub_594_i3 (mem_commonEnvelope childrenD_594_i3 b hb) + +theorem finite_children_work_594_i2 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_594_i2 j) (childrenD_594_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (2, 3)).mono (by decide +kernel) + · exact finite_row_works_594_i3.mono (by decide +kernel) + +theorem finite_row_works_594_i2 : FiniteTemplate HasSnaky 8 required_594_i2 envelope_594_i2 := by + refine finite_compose HasSnaky 7 childrenC_594_i2 childrenD_594_i2 finite_children_work_594_i2 (2, 3) + required_594_i2 envelope_594_i2 pivot_mem_594_i2 child_required_sub_594_i2 child_envelope_sub_594_i2 ?_ + intro b hb + exact common_sub_594_i2 (mem_commonEnvelope childrenD_594_i2 b hb) + +theorem finite_children_work_594_i8 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_594_i8 j) (childrenD_594_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_268 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_594_i8 : FiniteTemplate HasSnaky 5 required_594_i8 envelope_594_i8 := by + refine finite_compose HasSnaky 4 childrenC_594_i8 childrenD_594_i8 finite_children_work_594_i8 (2, 3) + required_594_i8 envelope_594_i8 pivot_mem_594_i8 child_required_sub_594_i8 child_envelope_sub_594_i8 ?_ + intro b hb + exact common_sub_594_i8 (mem_commonEnvelope childrenD_594_i8 b hb) + +theorem finite_children_work_594_i1 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_594_i1 j) (childrenD_594_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_272 5 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_290 7 (6, 7)).mono (by decide +kernel) + · exact finite_row_works_594_i2.mono (by decide +kernel) + · exact finite_row_works_594_i8.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_593 5 (7, 3)).mono (by decide +kernel) + +theorem finite_row_works_594_i1 : FiniteTemplate HasSnaky 9 required_594_i1 envelope_594_i1 := by + refine finite_compose HasSnaky 8 childrenC_594_i1 childrenD_594_i1 finite_children_work_594_i1 (2, 6) + required_594_i1 envelope_594_i1 pivot_mem_594_i1 child_required_sub_594_i1 child_envelope_sub_594_i1 ?_ + intro b hb + exact common_sub_594_i1 (mem_commonEnvelope childrenD_594_i1 b hb) + +theorem finite_children_work_594 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_594 j) (childrenD_594 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 7 (8, 4)).mono (by decide +kernel) + · exact finite_row_works_594_i0.mono (by decide +kernel) + · exact finite_row_works_594_i1.mono (by decide +kernel) + +theorem finite_row_works_594 : FiniteTemplate HasSnaky 10 required_594 envelope_594 := by + refine finite_compose HasSnaky 9 childrenC_594 childrenD_594 finite_children_work_594 (6, 4) + required_594 envelope_594 pivot_mem_594 child_required_sub_594 child_envelope_sub_594 ?_ + intro b hb + exact common_sub_594 (mem_commonEnvelope childrenD_594 b hb) + +theorem finite_children_work_608_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_608_i1 j) (childrenD_608_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 2 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_375 7 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_608_i1 : FiniteTemplate HasSnaky 5 required_608_i1 envelope_608_i1 := by + refine finite_compose HasSnaky 4 childrenC_608_i1 childrenD_608_i1 finite_children_work_608_i1 (5, 3) + required_608_i1 envelope_608_i1 pivot_mem_608_i1 child_required_sub_608_i1 child_envelope_sub_608_i1 ?_ + intro b hb + exact common_sub_608_i1 (mem_commonEnvelope childrenD_608_i1 b hb) + +theorem finite_children_work_608_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_608_i2 j) (childrenD_608_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_28 7 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_42 6 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_608_i2 : FiniteTemplate HasSnaky 5 required_608_i2 envelope_608_i2 := by + refine finite_compose HasSnaky 4 childrenC_608_i2 childrenD_608_i2 finite_children_work_608_i2 (2, 5) + required_608_i2 envelope_608_i2 pivot_mem_608_i2 child_required_sub_608_i2 child_envelope_sub_608_i2 ?_ + intro b hb + exact common_sub_608_i2 (mem_commonEnvelope childrenD_608_i2 b hb) + +theorem finite_children_work_608_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_608_i3 j) (childrenD_608_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_42 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_58 0 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_608_i3 : FiniteTemplate HasSnaky 5 required_608_i3 envelope_608_i3 := by + refine finite_compose HasSnaky 4 childrenC_608_i3 childrenD_608_i3 finite_children_work_608_i3 (2, 5) + required_608_i3 envelope_608_i3 pivot_mem_608_i3 child_required_sub_608_i3 child_envelope_sub_608_i3 ?_ + intro b hb + exact common_sub_608_i3 (mem_commonEnvelope childrenD_608_i3 b hb) + +theorem finite_children_work_608_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_608_i0 j) (childrenD_608_i0 j) := by + intro j + fin_cases j + · exact finite_row_works_608_i1.mono (by decide +kernel) + · exact finite_row_works_608_i2.mono (by decide +kernel) + · exact finite_row_works_608_i3.mono (by decide +kernel) + +theorem finite_row_works_608_i0 : FiniteTemplate HasSnaky 6 required_608_i0 envelope_608_i0 := by + refine finite_compose HasSnaky 5 childrenC_608_i0 childrenD_608_i0 finite_children_work_608_i0 (1, 2) + required_608_i0 envelope_608_i0 pivot_mem_608_i0 child_required_sub_608_i0 child_envelope_sub_608_i0 ?_ + intro b hb + exact common_sub_608_i0 (mem_commonEnvelope childrenD_608_i0 b hb) + +theorem finite_children_work_608 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_608 j) (childrenD_608 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_31 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_355 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_364 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_434 0 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_608_i0.mono (by decide +kernel) + +theorem finite_row_works_608 : FiniteTemplate HasSnaky 10 required_608 envelope_608 := by + refine finite_compose HasSnaky 9 childrenC_608 childrenD_608 finite_children_work_608 (4, 6) + required_608 envelope_608 pivot_mem_608 child_required_sub_608 child_envelope_sub_608 ?_ + intro b hb + exact common_sub_608 (mem_commonEnvelope childrenD_608 b hb) + +theorem finite_children_work_616_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_616_i1 j) (childrenD_616_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_123 5 (3, 3)).mono (by decide +kernel) + +theorem finite_row_works_616_i1 : FiniteTemplate HasSnaky 3 required_616_i1 envelope_616_i1 := by + refine finite_compose HasSnaky 2 childrenC_616_i1 childrenD_616_i1 finite_children_work_616_i1 (2, 6) + required_616_i1 envelope_616_i1 pivot_mem_616_i1 child_required_sub_616_i1 child_envelope_sub_616_i1 ?_ + intro b hb + exact common_sub_616_i1 (mem_commonEnvelope childrenD_616_i1 b hb) + +theorem finite_children_work_616_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_616_i0 j) (childrenD_616_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 0 (2, 1)).mono (by decide +kernel) + · exact finite_row_works_616_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_521 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_616_i0 : FiniteTemplate HasSnaky 7 required_616_i0 envelope_616_i0 := by + refine finite_compose HasSnaky 6 childrenC_616_i0 childrenD_616_i0 finite_children_work_616_i0 (2, 5) + required_616_i0 envelope_616_i0 pivot_mem_616_i0 child_required_sub_616_i0 child_envelope_sub_616_i0 ?_ + intro b hb + exact common_sub_616_i0 (mem_commonEnvelope childrenD_616_i0 b hb) + +theorem finite_children_work_616 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_616 j) (childrenD_616 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_345 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_421 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_522 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_530 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_533 4 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_534.mono (by decide +kernel) + · exact finite_row_works_616_i0.mono (by decide +kernel) + +theorem finite_row_works_616 : FiniteTemplate HasSnaky 10 required_616 envelope_616 := by + refine finite_compose HasSnaky 9 childrenC_616 childrenD_616 finite_children_work_616 (3, 3) + required_616 envelope_616 pivot_mem_616 child_required_sub_616 child_envelope_sub_616 ?_ + intro b hb + exact common_sub_616 (mem_commonEnvelope childrenD_616 b hb) + +theorem finite_children_work_631_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_631_i1 j) (childrenD_631_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_45 7 (5, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_418 1 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_631_i1 : FiniteTemplate HasSnaky 8 required_631_i1 envelope_631_i1 := by + refine finite_compose HasSnaky 7 childrenC_631_i1 childrenD_631_i1 finite_children_work_631_i1 (3, 2) + required_631_i1 envelope_631_i1 pivot_mem_631_i1 child_required_sub_631_i1 child_envelope_sub_631_i1 ?_ + intro b hb + exact common_sub_631_i1 (mem_commonEnvelope childrenD_631_i1 b hb) + +theorem finite_children_work_631_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_631_i0 j) (childrenD_631_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_43 4 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_51 4 (3, 5)).mono (by decide +kernel) + · exact finite_row_works_631_i1.mono (by decide +kernel) + +theorem finite_row_works_631_i0 : FiniteTemplate HasSnaky 9 required_631_i0 envelope_631_i0 := by + refine finite_compose HasSnaky 8 childrenC_631_i0 childrenD_631_i0 finite_children_work_631_i0 (4, 2) + required_631_i0 envelope_631_i0 pivot_mem_631_i0 child_required_sub_631_i0 child_envelope_sub_631_i0 ?_ + intro b hb + exact common_sub_631_i0 (mem_commonEnvelope childrenD_631_i0 b hb) + +theorem finite_children_work_631 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_631 j) (childrenD_631 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_63 2 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_631_i0.mono (by decide +kernel) + +theorem finite_row_works_631 : FiniteTemplate HasSnaky 10 required_631 envelope_631 := by + refine finite_compose HasSnaky 9 childrenC_631 childrenD_631 finite_children_work_631 (3, 5) + required_631 envelope_631 pivot_mem_631 child_required_sub_631 child_envelope_sub_631 ?_ + intro b hb + exact common_sub_631 (mem_commonEnvelope childrenD_631 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height10Part06.lean b/lean/snaky/FiniteCards/Height10Part06.lean new file mode 100644 index 0000000..86102b3 --- /dev/null +++ b/lean/snaky/FiniteCards/Height10Part06.lean @@ -0,0 +1,305 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part06 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part05 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part03 +import FiniteCards.Height08Part05 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part08 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_652_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_652_i3 j) (childrenD_652_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_245 2 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_652_i3 : FiniteTemplate HasSnaky 4 required_652_i3 envelope_652_i3 := by + refine finite_compose HasSnaky 3 childrenC_652_i3 childrenD_652_i3 finite_children_work_652_i3 (3, 5) + required_652_i3 envelope_652_i3 pivot_mem_652_i3 child_required_sub_652_i3 child_envelope_sub_652_i3 ?_ + intro b hb + exact common_sub_652_i3 (mem_commonEnvelope childrenD_652_i3 b hb) + +theorem finite_children_work_652_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_652_i2 j) (childrenD_652_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_36 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 6 (4, 6)).mono (by decide +kernel) + · exact finite_row_works_652_i3.mono (by decide +kernel) + +theorem finite_row_works_652_i2 : FiniteTemplate HasSnaky 5 required_652_i2 envelope_652_i2 := by + refine finite_compose HasSnaky 4 childrenC_652_i2 childrenD_652_i2 finite_children_work_652_i2 (4, 5) + required_652_i2 envelope_652_i2 pivot_mem_652_i2 child_required_sub_652_i2 child_envelope_sub_652_i2 ?_ + intro b hb + exact common_sub_652_i2 (mem_commonEnvelope childrenD_652_i2 b hb) + +theorem finite_children_work_652_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_652_i1 j) (childrenD_652_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_222 3 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_652_i2.mono (by decide +kernel) + +theorem finite_row_works_652_i1 : FiniteTemplate HasSnaky 6 required_652_i1 envelope_652_i1 := by + refine finite_compose HasSnaky 5 childrenC_652_i1 childrenD_652_i1 finite_children_work_652_i1 (4, 4) + required_652_i1 envelope_652_i1 pivot_mem_652_i1 child_required_sub_652_i1 child_envelope_sub_652_i1 ?_ + intro b hb + exact common_sub_652_i1 (mem_commonEnvelope childrenD_652_i1 b hb) + +theorem finite_children_work_652_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_652_i0 j) (childrenD_652_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 2 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_558 1 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_652_i1.mono (by decide +kernel) + +theorem finite_row_works_652_i0 : FiniteTemplate HasSnaky 9 required_652_i0 envelope_652_i0 := by + refine finite_compose HasSnaky 8 childrenC_652_i0 childrenD_652_i0 finite_children_work_652_i0 (2, 5) + required_652_i0 envelope_652_i0 pivot_mem_652_i0 child_required_sub_652_i0 child_envelope_sub_652_i0 ?_ + intro b hb + exact common_sub_652_i0 (mem_commonEnvelope childrenD_652_i0 b hb) + +theorem finite_children_work_652 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_652 j) (childrenD_652 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_652_i0.mono (by decide +kernel) + +theorem finite_row_works_652 : FiniteTemplate HasSnaky 10 required_652 envelope_652 := by + refine finite_compose HasSnaky 9 childrenC_652 childrenD_652 finite_children_work_652 (4, 3) + required_652 envelope_652 pivot_mem_652 child_required_sub_652 child_envelope_sub_652 ?_ + intro b hb + exact common_sub_652 (mem_commonEnvelope childrenD_652 b hb) + +theorem finite_children_work_674 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_674 j) (childrenD_674 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_34 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_149 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_673.mono (by decide +kernel) + +theorem finite_row_works_674 : FiniteTemplate HasSnaky 10 required_674 envelope_674 := by + refine finite_compose HasSnaky 9 childrenC_674 childrenD_674 finite_children_work_674 (2, 4) + required_674 envelope_674 pivot_mem_674 child_required_sub_674 child_envelope_sub_674 ?_ + intro b hb + exact common_sub_674 (mem_commonEnvelope childrenD_674 b hb) + +theorem finite_children_work_702_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_702_i1 j) (childrenD_702_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_40 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_702_i1 : FiniteTemplate HasSnaky 3 required_702_i1 envelope_702_i1 := by + refine finite_compose HasSnaky 2 childrenC_702_i1 childrenD_702_i1 finite_children_work_702_i1 (1, 1) + required_702_i1 envelope_702_i1 pivot_mem_702_i1 child_required_sub_702_i1 child_envelope_sub_702_i1 ?_ + intro b hb + exact common_sub_702_i1 (mem_commonEnvelope childrenD_702_i1 b hb) + +theorem finite_children_work_702_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_702_i0 j) (childrenD_702_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_30 1 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_108.mono (by decide +kernel) + · exact finite_row_works_702_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_511 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_702_i0 : FiniteTemplate HasSnaky 8 required_702_i0 envelope_702_i0 := by + refine finite_compose HasSnaky 7 childrenC_702_i0 childrenD_702_i0 finite_children_work_702_i0 (4, 2) + required_702_i0 envelope_702_i0 pivot_mem_702_i0 child_required_sub_702_i0 child_envelope_sub_702_i0 ?_ + intro b hb + exact common_sub_702_i0 (mem_commonEnvelope childrenD_702_i0 b hb) + +theorem finite_children_work_702 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_702 j) (childrenD_702 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_400 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_702_i0.mono (by decide +kernel) + +theorem finite_row_works_702 : FiniteTemplate HasSnaky 10 required_702 envelope_702 := by + refine finite_compose HasSnaky 9 childrenC_702 childrenD_702 finite_children_work_702 (4, 3) + required_702 envelope_702 pivot_mem_702 child_required_sub_702 child_envelope_sub_702 ?_ + intro b hb + exact common_sub_702 (mem_commonEnvelope childrenD_702 b hb) + +theorem finite_children_work_704_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_704_i1 j) (childrenD_704_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_28 5 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_58 0 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_306 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_704_i1 : FiniteTemplate HasSnaky 6 required_704_i1 envelope_704_i1 := by + refine finite_compose HasSnaky 5 childrenC_704_i1 childrenD_704_i1 finite_children_work_704_i1 (4, 6) + required_704_i1 envelope_704_i1 pivot_mem_704_i1 child_required_sub_704_i1 child_envelope_sub_704_i1 ?_ + intro b hb + exact common_sub_704_i1 (mem_commonEnvelope childrenD_704_i1 b hb) + +theorem finite_children_work_704_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_704_i3 j) (childrenD_704_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 6 (5, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_704_i3 : FiniteTemplate HasSnaky 4 required_704_i3 envelope_704_i3 := by + refine finite_compose HasSnaky 3 childrenC_704_i3 childrenD_704_i3 finite_children_work_704_i3 (5, 5) + required_704_i3 envelope_704_i3 pivot_mem_704_i3 child_required_sub_704_i3 child_envelope_sub_704_i3 ?_ + intro b hb + exact common_sub_704_i3 (mem_commonEnvelope childrenD_704_i3 b hb) + +theorem finite_children_work_704_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_704_i4 j) (childrenD_704_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 6 (5, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_10 6 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_704_i4 : FiniteTemplate HasSnaky 5 required_704_i4 envelope_704_i4 := by + refine finite_compose HasSnaky 4 childrenC_704_i4 childrenD_704_i4 finite_children_work_704_i4 (5, 5) + required_704_i4 envelope_704_i4 pivot_mem_704_i4 child_required_sub_704_i4 child_envelope_sub_704_i4 ?_ + intro b hb + exact common_sub_704_i4 (mem_commonEnvelope childrenD_704_i4 b hb) + +theorem finite_children_work_704_i5 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_704_i5 j) (childrenD_704_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_25 5 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 7 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_704_i5 : FiniteTemplate HasSnaky 4 required_704_i5 envelope_704_i5 := by + refine finite_compose HasSnaky 3 childrenC_704_i5 childrenD_704_i5 finite_children_work_704_i5 (4, 6) + required_704_i5 envelope_704_i5 pivot_mem_704_i5 child_required_sub_704_i5 child_envelope_sub_704_i5 ?_ + intro b hb + exact common_sub_704_i5 (mem_commonEnvelope childrenD_704_i5 b hb) + +theorem finite_children_work_704_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_704_i2 j) (childrenD_704_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_516 4 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_704_i3.mono (by decide +kernel) + · exact finite_row_works_704_i4.mono (by decide +kernel) + · exact finite_row_works_704_i5.mono (by decide +kernel) + +theorem finite_row_works_704_i2 : FiniteTemplate HasSnaky 7 required_704_i2 envelope_704_i2 := by + refine finite_compose HasSnaky 6 childrenC_704_i2 childrenD_704_i2 finite_children_work_704_i2 (4, 3) + required_704_i2 envelope_704_i2 pivot_mem_704_i2 child_required_sub_704_i2 child_envelope_sub_704_i2 ?_ + intro b hb + exact common_sub_704_i2 (mem_commonEnvelope childrenD_704_i2 b hb) + +theorem finite_children_work_704_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_704_i0 j) (childrenD_704_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_30 3 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_704_i1.mono (by decide +kernel) + · exact finite_row_works_703.mono (by decide +kernel) + · exact finite_row_works_704_i2.mono (by decide +kernel) + +theorem finite_row_works_704_i0 : FiniteTemplate HasSnaky 9 required_704_i0 envelope_704_i0 := by + refine finite_compose HasSnaky 8 childrenC_704_i0 childrenD_704_i0 finite_children_work_704_i0 (4, 5) + required_704_i0 envelope_704_i0 pivot_mem_704_i0 child_required_sub_704_i0 child_envelope_sub_704_i0 ?_ + intro b hb + exact common_sub_704_i0 (mem_commonEnvelope childrenD_704_i0 b hb) + +theorem finite_children_work_704 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_704 j) (childrenD_704 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_400 4 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_704_i0.mono (by decide +kernel) + +theorem finite_row_works_704 : FiniteTemplate HasSnaky 10 required_704 envelope_704 := by + refine finite_compose HasSnaky 9 childrenC_704 childrenD_704 finite_children_work_704 (4, 4) + required_704 envelope_704 pivot_mem_704 child_required_sub_704 child_envelope_sub_704 ?_ + intro b hb + exact common_sub_704 (mem_commonEnvelope childrenD_704 b hb) + +theorem finite_children_work_721_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_721_i4 j) (childrenD_721_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_208 6 (5, 7)).mono (by decide +kernel) + +theorem finite_row_works_721_i4 : FiniteTemplate HasSnaky 5 required_721_i4 envelope_721_i4 := by + refine finite_compose HasSnaky 4 childrenC_721_i4 childrenD_721_i4 finite_children_work_721_i4 (2, 6) + required_721_i4 envelope_721_i4 pivot_mem_721_i4 child_required_sub_721_i4 child_envelope_sub_721_i4 ?_ + intro b hb + exact common_sub_721_i4 (mem_commonEnvelope childrenD_721_i4 b hb) + +theorem finite_children_work_721_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_721_i3 j) (childrenD_721_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_721_i4.mono (by decide +kernel) + +theorem finite_row_works_721_i3 : FiniteTemplate HasSnaky 6 required_721_i3 envelope_721_i3 := by + refine finite_compose HasSnaky 5 childrenC_721_i3 childrenD_721_i3 finite_children_work_721_i3 (4, 6) + required_721_i3 envelope_721_i3 pivot_mem_721_i3 child_required_sub_721_i3 child_envelope_sub_721_i3 ?_ + intro b hb + exact common_sub_721_i3 (mem_commonEnvelope childrenD_721_i3 b hb) + +theorem finite_children_work_721_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_721_i2 j) (childrenD_721_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 2 (3, 2)).mono (by decide +kernel) + · exact finite_row_works_721_i3.mono (by decide +kernel) + +theorem finite_row_works_721_i2 : FiniteTemplate HasSnaky 7 required_721_i2 envelope_721_i2 := by + refine finite_compose HasSnaky 6 childrenC_721_i2 childrenD_721_i2 finite_children_work_721_i2 (3, 6) + required_721_i2 envelope_721_i2 pivot_mem_721_i2 child_required_sub_721_i2 child_envelope_sub_721_i2 ?_ + intro b hb + exact common_sub_721_i2 (mem_commonEnvelope childrenD_721_i2 b hb) + +theorem finite_children_work_721_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_721_i1 j) (childrenD_721_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_25 7 (6, 6)).mono (by decide +kernel) + · exact finite_row_works_721_i2.mono (by decide +kernel) + +theorem finite_row_works_721_i1 : FiniteTemplate HasSnaky 8 required_721_i1 envelope_721_i1 := by + refine finite_compose HasSnaky 7 childrenC_721_i1 childrenD_721_i1 finite_children_work_721_i1 (2, 4) + required_721_i1 envelope_721_i1 pivot_mem_721_i1 child_required_sub_721_i1 child_envelope_sub_721_i1 ?_ + intro b hb + exact common_sub_721_i1 (mem_commonEnvelope childrenD_721_i1 b hb) + +theorem finite_children_work_721_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_721_i0 j) (childrenD_721_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 5 (6, 3)).mono (by decide +kernel) + · exact finite_row_works_721_i1.mono (by decide +kernel) + +theorem finite_row_works_721_i0 : FiniteTemplate HasSnaky 9 required_721_i0 envelope_721_i0 := by + refine finite_compose HasSnaky 8 childrenC_721_i0 childrenD_721_i0 finite_children_work_721_i0 (5, 6) + required_721_i0 envelope_721_i0 pivot_mem_721_i0 child_required_sub_721_i0 child_envelope_sub_721_i0 ?_ + intro b hb + exact common_sub_721_i0 (mem_commonEnvelope childrenD_721_i0 b hb) + +theorem finite_children_work_721 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_721 j) (childrenD_721 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 2 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_176 4 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_216 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_218 1 (2, 3)).mono (by decide +kernel) + · exact finite_row_works_721_i0.mono (by decide +kernel) + +theorem finite_row_works_721 : FiniteTemplate HasSnaky 10 required_721 envelope_721 := by + refine finite_compose HasSnaky 9 childrenC_721 childrenD_721 finite_children_work_721 (5, 4) + required_721 envelope_721 pivot_mem_721 child_required_sub_721 child_envelope_sub_721 ?_ + intro b hb + exact common_sub_721 (mem_commonEnvelope childrenD_721 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height10Part07.lean b/lean/snaky/FiniteCards/Height10Part07.lean new file mode 100644 index 0000000..d3328ca --- /dev/null +++ b/lean/snaky/FiniteCards/Height10Part07.lean @@ -0,0 +1,97 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part07 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part04 +import FiniteCards.Height06Part02 +import FiniteCards.Height08Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_722_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_722_i1 j) (childrenD_722_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_17 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_32 7 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_722_i1 : FiniteTemplate HasSnaky 5 required_722_i1 envelope_722_i1 := by + refine finite_compose HasSnaky 4 childrenC_722_i1 childrenD_722_i1 finite_children_work_722_i1 (3, 4) + required_722_i1 envelope_722_i1 pivot_mem_722_i1 child_required_sub_722_i1 child_envelope_sub_722_i1 ?_ + intro b hb + exact common_sub_722_i1 (mem_commonEnvelope childrenD_722_i1 b hb) + +theorem finite_children_work_722_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_722_i0 j) (childrenD_722_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 5 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_366 6 (5, 8)).mono (by decide +kernel) + · exact finite_row_works_722_i1.mono (by decide +kernel) + +theorem finite_row_works_722_i0 : FiniteTemplate HasSnaky 6 required_722_i0 envelope_722_i0 := by + refine finite_compose HasSnaky 5 childrenC_722_i0 childrenD_722_i0 finite_children_work_722_i0 (4, 6) + required_722_i0 envelope_722_i0 pivot_mem_722_i0 child_required_sub_722_i0 child_envelope_sub_722_i0 ?_ + intro b hb + exact common_sub_722_i0 (mem_commonEnvelope childrenD_722_i0 b hb) + +theorem finite_children_work_722_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_722_i2 j) (childrenD_722_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 6 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_345 1 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_722_i2 : FiniteTemplate HasSnaky 9 required_722_i2 envelope_722_i2 := by + refine finite_compose HasSnaky 8 childrenC_722_i2 childrenD_722_i2 finite_children_work_722_i2 (5, 4) + required_722_i2 envelope_722_i2 pivot_mem_722_i2 child_required_sub_722_i2 child_envelope_sub_722_i2 ?_ + intro b hb + exact common_sub_722_i2 (mem_commonEnvelope childrenD_722_i2 b hb) + +theorem finite_children_work_722_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_722_i3 j) (childrenD_722_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_307 2 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_722_i3 : FiniteTemplate HasSnaky 5 required_722_i3 envelope_722_i3 := by + refine finite_compose HasSnaky 4 childrenC_722_i3 childrenD_722_i3 finite_children_work_722_i3 (3, 4) + required_722_i3 envelope_722_i3 pivot_mem_722_i3 child_required_sub_722_i3 child_envelope_sub_722_i3 ?_ + intro b hb + exact common_sub_722_i3 (mem_commonEnvelope childrenD_722_i3 b hb) + +theorem finite_children_work_722_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_722_i4 j) (childrenD_722_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_267 0 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_722_i4 : FiniteTemplate HasSnaky 7 required_722_i4 envelope_722_i4 := by + refine finite_compose HasSnaky 6 childrenC_722_i4 childrenD_722_i4 finite_children_work_722_i4 (3, 4) + required_722_i4 envelope_722_i4 pivot_mem_722_i4 child_required_sub_722_i4 child_envelope_sub_722_i4 ?_ + intro b hb + exact common_sub_722_i4 (mem_commonEnvelope childrenD_722_i4 b hb) + +theorem finite_children_work_722 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_722 j) (childrenD_722 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 2 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_176 4 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_722_i0.mono (by decide +kernel) + · exact finite_row_works_722_i2.mono (by decide +kernel) + · exact finite_row_works_722_i3.mono (by decide +kernel) + · exact finite_row_works_722_i4.mono (by decide +kernel) + +theorem finite_row_works_722 : FiniteTemplate HasSnaky 10 required_722 envelope_722 := by + refine finite_compose HasSnaky 9 childrenC_722 childrenD_722 finite_children_work_722 (4, 4) + required_722 envelope_722 pivot_mem_722 child_required_sub_722 child_envelope_sub_722 ?_ + intro b hb + exact common_sub_722 (mem_commonEnvelope childrenD_722 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height11Part01.lean b/lean/snaky/FiniteCards/Height11Part01.lean new file mode 100644 index 0000000..67a8d0d --- /dev/null +++ b/lean/snaky/FiniteCards/Height11Part01.lean @@ -0,0 +1,272 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part03 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part03 +import FiniteCards.Height09Part01 +import FiniteCards.Height10Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_427_i6 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_427_i6 j) (childrenD_427_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_70 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_226 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_427_i6 : FiniteTemplate HasSnaky 4 required_427_i6 envelope_427_i6 := by + refine finite_compose HasSnaky 3 childrenC_427_i6 childrenD_427_i6 finite_children_work_427_i6 (4, 3) + required_427_i6 envelope_427_i6 pivot_mem_427_i6 child_required_sub_427_i6 child_envelope_sub_427_i6 ?_ + intro b hb + exact common_sub_427_i6 (mem_commonEnvelope childrenD_427_i6 b hb) + +theorem finite_children_work_427_i5 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_427_i5 j) (childrenD_427_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_427_i6.mono (by decide +kernel) + +theorem finite_row_works_427_i5 : FiniteTemplate HasSnaky 5 required_427_i5 envelope_427_i5 := by + refine finite_compose HasSnaky 4 childrenC_427_i5 childrenD_427_i5 finite_children_work_427_i5 (4, 1) + required_427_i5 envelope_427_i5 pivot_mem_427_i5 child_required_sub_427_i5 child_envelope_sub_427_i5 ?_ + intro b hb + exact common_sub_427_i5 (mem_commonEnvelope childrenD_427_i5 b hb) + +theorem finite_children_work_427_i4 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_427_i4 j) (childrenD_427_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_427_i5.mono (by decide +kernel) + +theorem finite_row_works_427_i4 : FiniteTemplate HasSnaky 6 required_427_i4 envelope_427_i4 := by + refine finite_compose HasSnaky 5 childrenC_427_i4 childrenD_427_i4 finite_children_work_427_i4 (4, 2) + required_427_i4 envelope_427_i4 pivot_mem_427_i4 child_required_sub_427_i4 child_envelope_sub_427_i4 ?_ + intro b hb + exact common_sub_427_i4 (mem_commonEnvelope childrenD_427_i4 b hb) + +theorem finite_children_work_427_i9 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_427_i9 j) (childrenD_427_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 2 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_2 5 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_427_i9 : FiniteTemplate HasSnaky 2 required_427_i9 envelope_427_i9 := by + refine finite_compose HasSnaky 1 childrenC_427_i9 childrenD_427_i9 finite_children_work_427_i9 (3, 3) + required_427_i9 envelope_427_i9 pivot_mem_427_i9 child_required_sub_427_i9 child_envelope_sub_427_i9 ?_ + intro b hb + exact common_sub_427_i9 (mem_commonEnvelope childrenD_427_i9 b hb) + +theorem finite_children_work_427_i8 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_427_i8 j) (childrenD_427_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 3 (2, 4)).mono (by decide +kernel) + · exact finite_row_works_427_i9.mono (by decide +kernel) + +theorem finite_row_works_427_i8 : FiniteTemplate HasSnaky 3 required_427_i8 envelope_427_i8 := by + refine finite_compose HasSnaky 2 childrenC_427_i8 childrenD_427_i8 finite_children_work_427_i8 (2, 3) + required_427_i8 envelope_427_i8 pivot_mem_427_i8 child_required_sub_427_i8 child_envelope_sub_427_i8 ?_ + intro b hb + exact common_sub_427_i8 (mem_commonEnvelope childrenD_427_i8 b hb) + +theorem finite_children_work_427_i7 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_427_i7 j) (childrenD_427_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 3 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_427_i8.mono (by decide +kernel) + +theorem finite_row_works_427_i7 : FiniteTemplate HasSnaky 4 required_427_i7 envelope_427_i7 := by + refine finite_compose HasSnaky 3 childrenC_427_i7 childrenD_427_i7 finite_children_work_427_i7 (3, 0) + required_427_i7 envelope_427_i7 pivot_mem_427_i7 child_required_sub_427_i7 child_envelope_sub_427_i7 ?_ + intro b hb + exact common_sub_427_i7 (mem_commonEnvelope childrenD_427_i7 b hb) + +theorem finite_children_work_427_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_427_i3 j) (childrenD_427_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_17 3 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_357 3 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_427_i4.mono (by decide +kernel) + · exact finite_row_works_427_i7.mono (by decide +kernel) + +theorem finite_row_works_427_i3 : FiniteTemplate HasSnaky 7 required_427_i3 envelope_427_i3 := by + refine finite_compose HasSnaky 6 childrenC_427_i3 childrenD_427_i3 finite_children_work_427_i3 (3, 1) + required_427_i3 envelope_427_i3 pivot_mem_427_i3 child_required_sub_427_i3 child_envelope_sub_427_i3 ?_ + intro b hb + exact common_sub_427_i3 (mem_commonEnvelope childrenD_427_i3 b hb) + +theorem finite_children_work_427_i2 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_427_i2 j) (childrenD_427_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_427_i3.mono (by decide +kernel) + +theorem finite_row_works_427_i2 : FiniteTemplate HasSnaky 8 required_427_i2 envelope_427_i2 := by + refine finite_compose HasSnaky 7 childrenC_427_i2 childrenD_427_i2 finite_children_work_427_i2 (0, 1) + required_427_i2 envelope_427_i2 pivot_mem_427_i2 child_required_sub_427_i2 child_envelope_sub_427_i2 ?_ + intro b hb + exact common_sub_427_i2 (mem_commonEnvelope childrenD_427_i2 b hb) + +theorem finite_children_work_427_i1 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_427_i1 j) (childrenD_427_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_427_i2.mono (by decide +kernel) + +theorem finite_row_works_427_i1 : FiniteTemplate HasSnaky 9 required_427_i1 envelope_427_i1 := by + refine finite_compose HasSnaky 8 childrenC_427_i1 childrenD_427_i1 finite_children_work_427_i1 (0, 4) + required_427_i1 envelope_427_i1 pivot_mem_427_i1 child_required_sub_427_i1 child_envelope_sub_427_i1 ?_ + intro b hb + exact common_sub_427_i1 (mem_commonEnvelope childrenD_427_i1 b hb) + +theorem finite_children_work_427_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_427_i0 j) (childrenD_427_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_427_i1.mono (by decide +kernel) + +theorem finite_row_works_427_i0 : FiniteTemplate HasSnaky 10 required_427_i0 envelope_427_i0 := by + refine finite_compose HasSnaky 9 childrenC_427_i0 childrenD_427_i0 finite_children_work_427_i0 (2, 4) + required_427_i0 envelope_427_i0 pivot_mem_427_i0 child_required_sub_427_i0 child_envelope_sub_427_i0 ?_ + intro b hb + exact common_sub_427_i0 (mem_commonEnvelope childrenD_427_i0 b hb) + +theorem finite_children_work_427 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_427 j) (childrenD_427 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_427_i0.mono (by decide +kernel) + +theorem finite_row_works_427 : FiniteTemplate HasSnaky 11 required_427 envelope_427 := by + refine finite_compose HasSnaky 10 childrenC_427 childrenD_427 finite_children_work_427 (2, 1) + required_427 envelope_427 pivot_mem_427 child_required_sub_427 child_envelope_sub_427 ?_ + intro b hb + exact common_sub_427 (mem_commonEnvelope childrenD_427 b hb) + +theorem finite_children_work_463_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_463_i0 j) (childrenD_463_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_348 1 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_463_i0 : FiniteTemplate HasSnaky 7 required_463_i0 envelope_463_i0 := by + refine finite_compose HasSnaky 6 childrenC_463_i0 childrenD_463_i0 finite_children_work_463_i0 (2, 6) + required_463_i0 envelope_463_i0 pivot_mem_463_i0 child_required_sub_463_i0 child_envelope_sub_463_i0 ?_ + intro b hb + exact common_sub_463_i0 (mem_commonEnvelope childrenD_463_i0 b hb) + +theorem finite_children_work_463 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_463 j) (childrenD_463 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_147 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_167 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_463_i0.mono (by decide +kernel) + · exact finite_row_works_353.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_460 4 (3, 8)).mono (by decide +kernel) + +theorem finite_row_works_463 : FiniteTemplate HasSnaky 11 required_463 envelope_463 := by + refine finite_compose HasSnaky 10 childrenC_463 childrenD_463 finite_children_work_463 (4, 5) + required_463 envelope_463 pivot_mem_463 child_required_sub_463 child_envelope_sub_463 ?_ + intro b hb + exact common_sub_463 (mem_commonEnvelope childrenD_463 b hb) + +theorem finite_children_work_467 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_467 j) (childrenD_467 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_31 6 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_398 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_444 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_466 6 (5, 7)).mono (by decide +kernel) + +theorem finite_row_works_467 : FiniteTemplate HasSnaky 11 required_467 envelope_467 := by + refine finite_compose HasSnaky 10 childrenC_467 childrenD_467 finite_children_work_467 (4, 6) + required_467 envelope_467 pivot_mem_467 child_required_sub_467 child_envelope_sub_467 ?_ + intro b hb + exact common_sub_467 (mem_commonEnvelope childrenD_467 b hb) + +theorem finite_children_work_468_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_468_i1 j) (childrenD_468_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_71 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_71 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_73 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_73 2 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_468_i1 : FiniteTemplate HasSnaky 6 required_468_i1 envelope_468_i1 := by + refine finite_compose HasSnaky 5 childrenC_468_i1 childrenD_468_i1 finite_children_work_468_i1 (3, 3) + required_468_i1 envelope_468_i1 pivot_mem_468_i1 child_required_sub_468_i1 child_envelope_sub_468_i1 ?_ + intro b hb + exact common_sub_468_i1 (mem_commonEnvelope childrenD_468_i1 b hb) + +theorem finite_children_work_468_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_468_i3 j) (childrenD_468_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 2 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_75 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_266 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_447 0 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_468_i3 : FiniteTemplate HasSnaky 8 required_468_i3 envelope_468_i3 := by + refine finite_compose HasSnaky 7 childrenC_468_i3 childrenD_468_i3 finite_children_work_468_i3 (3, 6) + required_468_i3 envelope_468_i3 pivot_mem_468_i3 child_required_sub_468_i3 child_envelope_sub_468_i3 ?_ + intro b hb + exact common_sub_468_i3 (mem_commonEnvelope childrenD_468_i3 b hb) + +theorem finite_children_work_468_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_468_i2 j) (childrenD_468_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_71 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_73 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_426 6 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_468_i3.mono (by decide +kernel) + +theorem finite_row_works_468_i2 : FiniteTemplate HasSnaky 9 required_468_i2 envelope_468_i2 := by + refine finite_compose HasSnaky 8 childrenC_468_i2 childrenD_468_i2 finite_children_work_468_i2 (3, 3) + required_468_i2 envelope_468_i2 pivot_mem_468_i2 child_required_sub_468_i2 child_envelope_sub_468_i2 ?_ + intro b hb + exact common_sub_468_i2 (mem_commonEnvelope childrenD_468_i2 b hb) + +theorem finite_children_work_468_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_468_i0 j) (childrenD_468_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 3 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_468_i1.mono (by decide +kernel) + · exact finite_row_works_468_i2.mono (by decide +kernel) + +theorem finite_row_works_468_i0 : FiniteTemplate HasSnaky 10 required_468_i0 envelope_468_i0 := by + refine finite_compose HasSnaky 9 childrenC_468_i0 childrenD_468_i0 finite_children_work_468_i0 (3, 5) + required_468_i0 envelope_468_i0 pivot_mem_468_i0 child_required_sub_468_i0 child_envelope_sub_468_i0 ?_ + intro b hb + exact common_sub_468_i0 (mem_commonEnvelope childrenD_468_i0 b hb) + +theorem finite_children_work_468 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_468 j) (childrenD_468 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_28 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_126 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_126 3 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_468_i0.mono (by decide +kernel) + +theorem finite_row_works_468 : FiniteTemplate HasSnaky 11 required_468 envelope_468 := by + refine finite_compose HasSnaky 10 childrenC_468 childrenD_468 finite_children_work_468 (3, 4) + required_468 envelope_468 pivot_mem_468 child_required_sub_468 child_envelope_sub_468 ?_ + intro b hb + exact common_sub_468 (mem_commonEnvelope childrenD_468 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height11Part02.lean b/lean/snaky/FiniteCards/Height11Part02.lean new file mode 100644 index 0000000..d8184ce --- /dev/null +++ b/lean/snaky/FiniteCards/Height11Part02.lean @@ -0,0 +1,333 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part05 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part03 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part04 +import FiniteCards.Height10Part02 +import FiniteCards.Height10Part03 +import FiniteCards.Height10Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_517_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_517_i0 j) (childrenD_517_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_404 1 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_517_i0 : FiniteTemplate HasSnaky 8 required_517_i0 envelope_517_i0 := by + refine finite_compose HasSnaky 7 childrenC_517_i0 childrenD_517_i0 finite_children_work_517_i0 (3, 4) + required_517_i0 envelope_517_i0 pivot_mem_517_i0 child_required_sub_517_i0 child_envelope_sub_517_i0 ?_ + intro b hb + exact common_sub_517_i0 (mem_commonEnvelope childrenD_517_i0 b hb) + +theorem finite_children_work_517_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_517_i2 j) (childrenD_517_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_79 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_367 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_513 2 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_516 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_517_i2 : FiniteTemplate HasSnaky 9 required_517_i2 envelope_517_i2 := by + refine finite_compose HasSnaky 8 childrenC_517_i2 childrenD_517_i2 finite_children_work_517_i2 (4, 5) + required_517_i2 envelope_517_i2 pivot_mem_517_i2 child_required_sub_517_i2 child_envelope_sub_517_i2 ?_ + intro b hb + exact common_sub_517_i2 (mem_commonEnvelope childrenD_517_i2 b hb) + +theorem finite_children_work_517_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_517_i1 j) (childrenD_517_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_30 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_59 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_346 4 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_517_i2.mono (by decide +kernel) + +theorem finite_row_works_517_i1 : FiniteTemplate HasSnaky 10 required_517_i1 envelope_517_i1 := by + refine finite_compose HasSnaky 9 childrenC_517_i1 childrenD_517_i1 finite_children_work_517_i1 (4, 3) + required_517_i1 envelope_517_i1 pivot_mem_517_i1 child_required_sub_517_i1 child_envelope_sub_517_i1 ?_ + intro b hb + exact common_sub_517_i1 (mem_commonEnvelope childrenD_517_i1 b hb) + +theorem finite_children_work_517_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_517_i4 j) (childrenD_517_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_58 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_79 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_429 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_517_i4 : FiniteTemplate HasSnaky 7 required_517_i4 envelope_517_i4 := by + refine finite_compose HasSnaky 6 childrenC_517_i4 childrenD_517_i4 finite_children_work_517_i4 (4, 5) + required_517_i4 envelope_517_i4 pivot_mem_517_i4 child_required_sub_517_i4 child_envelope_sub_517_i4 ?_ + intro b hb + exact common_sub_517_i4 (mem_commonEnvelope childrenD_517_i4 b hb) + +theorem finite_children_work_517_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_517_i3 j) (childrenD_517_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_36 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_59 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_346 4 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_517_i4.mono (by decide +kernel) + +theorem finite_row_works_517_i3 : FiniteTemplate HasSnaky 8 required_517_i3 envelope_517_i3 := by + refine finite_compose HasSnaky 7 childrenC_517_i3 childrenD_517_i3 finite_children_work_517_i3 (4, 3) + required_517_i3 envelope_517_i3 pivot_mem_517_i3 child_required_sub_517_i3 child_envelope_sub_517_i3 ?_ + intro b hb + exact common_sub_517_i3 (mem_commonEnvelope childrenD_517_i3 b hb) + +theorem finite_children_work_517 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_517 j) (childrenD_517 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_74 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_517_i0.mono (by decide +kernel) + · exact finite_row_works_517_i1.mono (by decide +kernel) + · exact finite_row_works_517_i3.mono (by decide +kernel) + +theorem finite_row_works_517 : FiniteTemplate HasSnaky 11 required_517 envelope_517 := by + refine finite_compose HasSnaky 10 childrenC_517 childrenD_517 finite_children_work_517 (4, 4) + required_517 envelope_517 pivot_mem_517 child_required_sub_517 child_envelope_sub_517 ?_ + intro b hb + exact common_sub_517 (mem_commonEnvelope childrenD_517 b hb) + +theorem finite_children_work_527_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_527_i0 j) (childrenD_527_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_23 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_198 4 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_527_i0 : FiniteTemplate HasSnaky 4 required_527_i0 envelope_527_i0 := by + refine finite_compose HasSnaky 3 childrenC_527_i0 childrenD_527_i0 finite_children_work_527_i0 (2, 5) + required_527_i0 envelope_527_i0 pivot_mem_527_i0 child_required_sub_527_i0 child_envelope_sub_527_i0 ?_ + intro b hb + exact common_sub_527_i0 (mem_commonEnvelope childrenD_527_i0 b hb) + +theorem finite_children_work_527_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_527_i2 j) (childrenD_527_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_392 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_417 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_420 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_521 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_522 4 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_526 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_527_i2 : FiniteTemplate HasSnaky 9 required_527_i2 envelope_527_i2 := by + refine finite_compose HasSnaky 8 childrenC_527_i2 childrenD_527_i2 finite_children_work_527_i2 (3, 3) + required_527_i2 envelope_527_i2 pivot_mem_527_i2 child_required_sub_527_i2 child_envelope_sub_527_i2 ?_ + intro b hb + exact common_sub_527_i2 (mem_commonEnvelope childrenD_527_i2 b hb) + +theorem finite_children_work_527_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_527_i1 j) (childrenD_527_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_23 2 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_527_i2.mono (by decide +kernel) + +theorem finite_row_works_527_i1 : FiniteTemplate HasSnaky 10 required_527_i1 envelope_527_i1 := by + refine finite_compose HasSnaky 9 childrenC_527_i1 childrenD_527_i1 finite_children_work_527_i1 (2, 5) + required_527_i1 envelope_527_i1 pivot_mem_527_i1 child_required_sub_527_i1 child_envelope_sub_527_i1 ?_ + intro b hb + exact common_sub_527_i1 (mem_commonEnvelope childrenD_527_i1 b hb) + +theorem finite_children_work_527 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_527 j) (childrenD_527 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_206 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_527_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_405 4 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_527_i1.mono (by decide +kernel) + +theorem finite_row_works_527 : FiniteTemplate HasSnaky 11 required_527 envelope_527 := by + refine finite_compose HasSnaky 10 childrenC_527 childrenD_527 finite_children_work_527 (2, 2) + required_527 envelope_527 pivot_mem_527 child_required_sub_527 child_envelope_sub_527 ?_ + intro b hb + exact common_sub_527 (mem_commonEnvelope childrenD_527 b hb) + +theorem finite_children_work_550 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_550 j) (childrenD_550 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_390 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_544 5 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_545 6 (6, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_546 2 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_548 2 (6, 0)).mono (by decide +kernel) + +theorem finite_row_works_550 : FiniteTemplate HasSnaky 11 required_550 envelope_550 := by + refine finite_compose HasSnaky 10 childrenC_550 childrenD_550 finite_children_work_550 (5, 6) + required_550 envelope_550 pivot_mem_550 child_required_sub_550 child_envelope_sub_550 ?_ + intro b hb + exact common_sub_550 (mem_commonEnvelope childrenD_550 b hb) + +theorem finite_children_work_567_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_567_i4 j) (childrenD_567_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_92 7 (6, 5)).mono (by decide +kernel) + +theorem finite_row_works_567_i4 : FiniteTemplate HasSnaky 5 required_567_i4 envelope_567_i4 := by + refine finite_compose HasSnaky 4 childrenC_567_i4 childrenD_567_i4 finite_children_work_567_i4 (4, 3) + required_567_i4 envelope_567_i4 pivot_mem_567_i4 child_required_sub_567_i4 child_envelope_sub_567_i4 ?_ + intro b hb + exact common_sub_567_i4 (mem_commonEnvelope childrenD_567_i4 b hb) + +theorem finite_children_work_567_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_567_i3 j) (childrenD_567_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_94 4 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_102 4 (3, 6)).mono (by decide +kernel) + · exact finite_row_works_567_i4.mono (by decide +kernel) + +theorem finite_row_works_567_i3 : FiniteTemplate HasSnaky 6 required_567_i3 envelope_567_i3 := by + refine finite_compose HasSnaky 5 childrenC_567_i3 childrenD_567_i3 finite_children_work_567_i3 (4, 2) + required_567_i3 envelope_567_i3 pivot_mem_567_i3 child_required_sub_567_i3 child_envelope_sub_567_i3 ?_ + intro b hb + exact common_sub_567_i3 (mem_commonEnvelope childrenD_567_i3 b hb) + +theorem finite_children_work_567_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_567_i2 j) (childrenD_567_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (7, 5)).mono (by decide +kernel) + · exact finite_row_works_567_i3.mono (by decide +kernel) + +theorem finite_row_works_567_i2 : FiniteTemplate HasSnaky 7 required_567_i2 envelope_567_i2 := by + refine finite_compose HasSnaky 6 childrenC_567_i2 childrenD_567_i2 finite_children_work_567_i2 (4, 4) + required_567_i2 envelope_567_i2 pivot_mem_567_i2 child_required_sub_567_i2 child_envelope_sub_567_i2 ?_ + intro b hb + exact common_sub_567_i2 (mem_commonEnvelope childrenD_567_i2 b hb) + +theorem finite_children_work_567_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_567_i1 j) (childrenD_567_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_16 3 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_235 7 (7, 6)).mono (by decide +kernel) + · exact finite_row_works_567_i2.mono (by decide +kernel) + +theorem finite_row_works_567_i1 : FiniteTemplate HasSnaky 8 required_567_i1 envelope_567_i1 := by + refine finite_compose HasSnaky 7 childrenC_567_i1 childrenD_567_i1 finite_children_work_567_i1 (6, 5) + required_567_i1 envelope_567_i1 pivot_mem_567_i1 child_required_sub_567_i1 child_envelope_sub_567_i1 ?_ + intro b hb + exact common_sub_567_i1 (mem_commonEnvelope childrenD_567_i1 b hb) + +theorem finite_children_work_567_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_567_i0 j) (childrenD_567_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_67 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_134 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_327 6 (6, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_504 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_558 4 (3, 7)).mono (by decide +kernel) + · exact finite_row_works_567_i1.mono (by decide +kernel) + +theorem finite_row_works_567_i0 : FiniteTemplate HasSnaky 10 required_567_i0 envelope_567_i0 := by + refine finite_compose HasSnaky 9 childrenC_567_i0 childrenD_567_i0 finite_children_work_567_i0 (5, 5) + required_567_i0 envelope_567_i0 pivot_mem_567_i0 child_required_sub_567_i0 child_envelope_sub_567_i0 ?_ + intro b hb + exact common_sub_567_i0 (mem_commonEnvelope childrenD_567_i0 b hb) + +theorem finite_children_work_567 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_567 j) (childrenD_567 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_27 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_560 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_563 0 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_567_i0.mono (by decide +kernel) + +theorem finite_row_works_567 : FiniteTemplate HasSnaky 11 required_567 envelope_567 := by + refine finite_compose HasSnaky 10 childrenC_567 childrenD_567 finite_children_work_567 (4, 5) + required_567 envelope_567 pivot_mem_567 child_required_sub_567 child_envelope_sub_567 ?_ + intro b hb + exact common_sub_567 (mem_commonEnvelope childrenD_567 b hb) + +theorem finite_children_work_579 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_579 j) (childrenD_579 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_118 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_137 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_172 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_173 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_507 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_578 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_578 4 (0, 7)).mono (by decide +kernel) + +theorem finite_row_works_579 : FiniteTemplate HasSnaky 11 required_579 envelope_579 := by + refine finite_compose HasSnaky 10 childrenC_579 childrenD_579 finite_children_work_579 (3, 4) + required_579 envelope_579 pivot_mem_579 child_required_sub_579 child_envelope_sub_579 ?_ + intro b hb + exact common_sub_579 (mem_commonEnvelope childrenD_579 b hb) + +theorem finite_children_work_581 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_581 j) (childrenD_581 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_188 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_188 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_258 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_309 7 (7, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_578 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_578 5 (7, 3)).mono (by decide +kernel) + +theorem finite_row_works_581 : FiniteTemplate HasSnaky 11 required_581 envelope_581 := by + refine finite_compose HasSnaky 10 childrenC_581 childrenD_581 finite_children_work_581 (4, 6) + required_581 envelope_581 pivot_mem_581 child_required_sub_581 child_envelope_sub_581 ?_ + intro b hb + exact common_sub_581 (mem_commonEnvelope childrenD_581 b hb) + +theorem finite_children_work_586 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_586 j) (childrenD_586 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_179.mono (by decide +kernel) + · exact finite_row_works_585.mono (by decide +kernel) + +theorem finite_row_works_586 : FiniteTemplate HasSnaky 11 required_586 envelope_586 := by + refine finite_compose HasSnaky 10 childrenC_586 childrenD_586 finite_children_work_586 (4, 2) + required_586 envelope_586 pivot_mem_586 child_required_sub_586 child_envelope_sub_586 ?_ + intro b hb + exact common_sub_586 (mem_commonEnvelope childrenD_586 b hb) + +theorem finite_children_work_589 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_589 j) (childrenD_589 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_585 2 (5, 0)).mono (by decide +kernel) + +theorem finite_row_works_589 : FiniteTemplate HasSnaky 11 required_589 envelope_589 := by + refine finite_compose HasSnaky 10 childrenC_589 childrenD_589 finite_children_work_589 (4, 2) + required_589 envelope_589 pivot_mem_589 child_required_sub_589 child_envelope_sub_589 ?_ + intro b hb + exact common_sub_589 (mem_commonEnvelope childrenD_589 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height11Part03.lean b/lean/snaky/FiniteCards/Height11Part03.lean new file mode 100644 index 0000000..8b25211 --- /dev/null +++ b/lean/snaky/FiniteCards/Height11Part03.lean @@ -0,0 +1,253 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part03 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part06 +import FiniteCards.Height10Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_596_i1 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_596_i1 j) (childrenD_596_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 7 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 0 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_596_i1 : FiniteTemplate HasSnaky 2 required_596_i1 envelope_596_i1 := by + refine finite_compose HasSnaky 1 childrenC_596_i1 childrenD_596_i1 finite_children_work_596_i1 (4, 5) + required_596_i1 envelope_596_i1 pivot_mem_596_i1 child_required_sub_596_i1 child_envelope_sub_596_i1 ?_ + intro b hb + exact common_sub_596_i1 (mem_commonEnvelope childrenD_596_i1 b hb) + +theorem finite_children_work_596_i0 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_596_i0 j) (childrenD_596_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_596_i1.mono (by decide +kernel) + +theorem finite_row_works_596_i0 : FiniteTemplate HasSnaky 3 required_596_i0 envelope_596_i0 := by + refine finite_compose HasSnaky 2 childrenC_596_i0 childrenD_596_i0 finite_children_work_596_i0 (4, 2) + required_596_i0 envelope_596_i0 pivot_mem_596_i0 child_required_sub_596_i0 child_envelope_sub_596_i0 ?_ + intro b hb + exact common_sub_596_i0 (mem_commonEnvelope childrenD_596_i0 b hb) + +theorem finite_children_work_596_i3 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_596_i3 j) (childrenD_596_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 4 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_596_i3 : FiniteTemplate HasSnaky 2 required_596_i3 envelope_596_i3 := by + refine finite_compose HasSnaky 1 childrenC_596_i3 childrenD_596_i3 finite_children_work_596_i3 (4, 3) + required_596_i3 envelope_596_i3 pivot_mem_596_i3 child_required_sub_596_i3 child_envelope_sub_596_i3 ?_ + intro b hb + exact common_sub_596_i3 (mem_commonEnvelope childrenD_596_i3 b hb) + +theorem finite_children_work_596_i2 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_596_i2 j) (childrenD_596_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_596_i3.mono (by decide +kernel) + +theorem finite_row_works_596_i2 : FiniteTemplate HasSnaky 3 required_596_i2 envelope_596_i2 := by + refine finite_compose HasSnaky 2 childrenC_596_i2 childrenD_596_i2 finite_children_work_596_i2 (4, 2) + required_596_i2 envelope_596_i2 pivot_mem_596_i2 child_required_sub_596_i2 child_envelope_sub_596_i2 ?_ + intro b hb + exact common_sub_596_i2 (mem_commonEnvelope childrenD_596_i2 b hb) + +theorem finite_children_work_596_i5 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_596_i5 j) (childrenD_596_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_82 1 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_596_i5 : FiniteTemplate HasSnaky 5 required_596_i5 envelope_596_i5 := by + refine finite_compose HasSnaky 4 childrenC_596_i5 childrenD_596_i5 finite_children_work_596_i5 (4, 2) + required_596_i5 envelope_596_i5 pivot_mem_596_i5 child_required_sub_596_i5 child_envelope_sub_596_i5 ?_ + intro b hb + exact common_sub_596_i5 (mem_commonEnvelope childrenD_596_i5 b hb) + +theorem finite_children_work_596_i4 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_596_i4 j) (childrenD_596_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_595.mono (by decide +kernel) + · exact finite_row_works_596_i5.mono (by decide +kernel) + +theorem finite_row_works_596_i4 : FiniteTemplate HasSnaky 10 required_596_i4 envelope_596_i4 := by + refine finite_compose HasSnaky 9 childrenC_596_i4 childrenD_596_i4 finite_children_work_596_i4 (5, 4) + required_596_i4 envelope_596_i4 pivot_mem_596_i4 child_required_sub_596_i4 child_envelope_sub_596_i4 ?_ + intro b hb + exact common_sub_596_i4 (mem_commonEnvelope childrenD_596_i4 b hb) + +theorem finite_children_work_596 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_596 j) (childrenD_596 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_197 4 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_596_i0.mono (by decide +kernel) + · exact finite_row_works_596_i2.mono (by decide +kernel) + · exact finite_row_works_596_i4.mono (by decide +kernel) + +theorem finite_row_works_596 : FiniteTemplate HasSnaky 11 required_596 envelope_596 := by + refine finite_compose HasSnaky 10 childrenC_596 childrenD_596 finite_children_work_596 (4, 4) + required_596 envelope_596 pivot_mem_596 child_required_sub_596 child_envelope_sub_596 ?_ + intro b hb + exact common_sub_596 (mem_commonEnvelope childrenD_596 b hb) + +theorem finite_children_work_601_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_601_i1 j) (childrenD_601_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_29 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_35 7 (4, 5)).mono (by decide +kernel) + +theorem finite_row_works_601_i1 : FiniteTemplate HasSnaky 4 required_601_i1 envelope_601_i1 := by + refine finite_compose HasSnaky 3 childrenC_601_i1 childrenD_601_i1 finite_children_work_601_i1 (3, 5) + required_601_i1 envelope_601_i1 pivot_mem_601_i1 child_required_sub_601_i1 child_envelope_sub_601_i1 ?_ + intro b hb + exact common_sub_601_i1 (mem_commonEnvelope childrenD_601_i1 b hb) + +theorem finite_children_work_601_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_601_i0 j) (childrenD_601_i0 j) := by + intro j + fin_cases j + · exact finite_row_works_601_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_499 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_501 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_601_i0 : FiniteTemplate HasSnaky 8 required_601_i0 envelope_601_i0 := by + refine finite_compose HasSnaky 7 childrenC_601_i0 childrenD_601_i0 finite_children_work_601_i0 (4, 4) + required_601_i0 envelope_601_i0 pivot_mem_601_i0 child_required_sub_601_i0 child_envelope_sub_601_i0 ?_ + intro b hb + exact common_sub_601_i0 (mem_commonEnvelope childrenD_601_i0 b hb) + +theorem finite_children_work_601_i6 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_601_i6 j) (childrenD_601_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_66 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_94 1 (3, 2)).mono (by decide +kernel) + +theorem finite_row_works_601_i6 : FiniteTemplate HasSnaky 3 required_601_i6 envelope_601_i6 := by + refine finite_compose HasSnaky 2 childrenC_601_i6 childrenD_601_i6 finite_children_work_601_i6 (5, 2) + required_601_i6 envelope_601_i6 pivot_mem_601_i6 child_required_sub_601_i6 child_envelope_sub_601_i6 ?_ + intro b hb + exact common_sub_601_i6 (mem_commonEnvelope childrenD_601_i6 b hb) + +theorem finite_children_work_601_i5 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_601_i5 j) (childrenD_601_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 4 (3, 5)).mono (by decide +kernel) + · exact finite_row_works_601_i6.mono (by decide +kernel) + +theorem finite_row_works_601_i5 : FiniteTemplate HasSnaky 4 required_601_i5 envelope_601_i5 := by + refine finite_compose HasSnaky 3 childrenC_601_i5 childrenD_601_i5 finite_children_work_601_i5 (4, 2) + required_601_i5 envelope_601_i5 pivot_mem_601_i5 child_required_sub_601_i5 child_envelope_sub_601_i5 ?_ + intro b hb + exact common_sub_601_i5 (mem_commonEnvelope childrenD_601_i5 b hb) + +theorem finite_children_work_601_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_601_i4 j) (childrenD_601_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 2 (6, 3)).mono (by decide +kernel) + · exact finite_row_works_601_i5.mono (by decide +kernel) + +theorem finite_row_works_601_i4 : FiniteTemplate HasSnaky 5 required_601_i4 envelope_601_i4 := by + refine finite_compose HasSnaky 4 childrenC_601_i4 childrenD_601_i4 finite_children_work_601_i4 (6, 3) + required_601_i4 envelope_601_i4 pivot_mem_601_i4 child_required_sub_601_i4 child_envelope_sub_601_i4 ?_ + intro b hb + exact common_sub_601_i4 (mem_commonEnvelope childrenD_601_i4 b hb) + +theorem finite_children_work_601_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_601_i3 j) (childrenD_601_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 2 (4, 4)).mono (by decide +kernel) + · exact finite_row_works_601_i4.mono (by decide +kernel) + +theorem finite_row_works_601_i3 : FiniteTemplate HasSnaky 6 required_601_i3 envelope_601_i3 := by + refine finite_compose HasSnaky 5 childrenC_601_i3 childrenD_601_i3 finite_children_work_601_i3 (2, 4) + required_601_i3 envelope_601_i3 pivot_mem_601_i3 child_required_sub_601_i3 child_envelope_sub_601_i3 ?_ + intro b hb + exact common_sub_601_i3 (mem_commonEnvelope childrenD_601_i3 b hb) + +theorem finite_children_work_601_i7 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_601_i7 j) (childrenD_601_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 2 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_72 0 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_601_i7 : FiniteTemplate HasSnaky 6 required_601_i7 envelope_601_i7 := by + refine finite_compose HasSnaky 5 childrenC_601_i7 childrenD_601_i7 finite_children_work_601_i7 (2, 4) + required_601_i7 envelope_601_i7 pivot_mem_601_i7 child_required_sub_601_i7 child_envelope_sub_601_i7 ?_ + intro b hb + exact common_sub_601_i7 (mem_commonEnvelope childrenD_601_i7 b hb) + +theorem finite_children_work_601_i2 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_601_i2 j) (childrenD_601_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_406 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_499 1 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_601_i3.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_600 4 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_601_i7.mono (by decide +kernel) + +theorem finite_row_works_601_i2 : FiniteTemplate HasSnaky 10 required_601_i2 envelope_601_i2 := by + refine finite_compose HasSnaky 9 childrenC_601_i2 childrenD_601_i2 finite_children_work_601_i2 (4, 4) + required_601_i2 envelope_601_i2 pivot_mem_601_i2 child_required_sub_601_i2 child_envelope_sub_601_i2 ?_ + intro b hb + exact common_sub_601_i2 (mem_commonEnvelope childrenD_601_i2 b hb) + +theorem finite_children_work_601_i8 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_601_i8 j) (childrenD_601_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_406 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_501 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_601_i8 : FiniteTemplate HasSnaky 10 required_601_i8 envelope_601_i8 := by + refine finite_compose HasSnaky 9 childrenC_601_i8 childrenD_601_i8 finite_children_work_601_i8 (4, 4) + required_601_i8 envelope_601_i8 pivot_mem_601_i8 child_required_sub_601_i8 child_envelope_sub_601_i8 ?_ + intro b hb + exact common_sub_601_i8 (mem_commonEnvelope childrenD_601_i8 b hb) + +theorem finite_children_work_601 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_601 j) (childrenD_601 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_247 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_601_i0.mono (by decide +kernel) + · exact finite_row_works_601_i2.mono (by decide +kernel) + · exact finite_row_works_601_i8.mono (by decide +kernel) + +theorem finite_row_works_601 : FiniteTemplate HasSnaky 11 required_601 envelope_601 := by + refine finite_compose HasSnaky 10 childrenC_601 childrenD_601 finite_children_work_601 (4, 3) + required_601 envelope_601 pivot_mem_601 child_required_sub_601 child_envelope_sub_601 ?_ + intro b hb + exact common_sub_601 (mem_commonEnvelope childrenD_601 b hb) + +theorem finite_children_work_613 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_613 j) (childrenD_613 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_104 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_329 2 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_409 4 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_612 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_612 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_612 6 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_613 : FiniteTemplate HasSnaky 11 required_613 envelope_613 := by + refine finite_compose HasSnaky 10 childrenC_613 childrenD_613 finite_children_work_613 (2, 5) + required_613 envelope_613 pivot_mem_613 child_required_sub_613 child_envelope_sub_613 ?_ + intro b hb + exact common_sub_613 (mem_commonEnvelope childrenD_613 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height11Part04.lean b/lean/snaky/FiniteCards/Height11Part04.lean new file mode 100644 index 0000000..efb56b5 --- /dev/null +++ b/lean/snaky/FiniteCards/Height11Part04.lean @@ -0,0 +1,300 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part03 +import FiniteCards.Height09Part04 +import FiniteCards.Height09Part06 +import FiniteCards.Height10Part02 +import FiniteCards.Height10Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_615_i5 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_615_i5 j) (childrenD_615_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 4 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_20 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_402 0 (3, 2)).mono (by decide +kernel) + +theorem finite_row_works_615_i5 : FiniteTemplate HasSnaky 4 required_615_i5 envelope_615_i5 := by + refine finite_compose HasSnaky 3 childrenC_615_i5 childrenD_615_i5 finite_children_work_615_i5 (4, 3) + required_615_i5 envelope_615_i5 pivot_mem_615_i5 child_required_sub_615_i5 child_envelope_sub_615_i5 ?_ + intro b hb + exact common_sub_615_i5 (mem_commonEnvelope childrenD_615_i5 b hb) + +theorem finite_children_work_615_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_615_i4 j) (childrenD_615_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (7, 5)).mono (by decide +kernel) + · exact finite_row_works_615_i5.mono (by decide +kernel) + +theorem finite_row_works_615_i4 : FiniteTemplate HasSnaky 5 required_615_i4 envelope_615_i4 := by + refine finite_compose HasSnaky 4 childrenC_615_i4 childrenD_615_i4 finite_children_work_615_i4 (4, 4) + required_615_i4 envelope_615_i4 pivot_mem_615_i4 child_required_sub_615_i4 child_envelope_sub_615_i4 ?_ + intro b hb + exact common_sub_615_i4 (mem_commonEnvelope childrenD_615_i4 b hb) + +theorem finite_children_work_615_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_615_i3 j) (childrenD_615_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (3, 5)).mono (by decide +kernel) + · exact finite_row_works_615_i4.mono (by decide +kernel) + +theorem finite_row_works_615_i3 : FiniteTemplate HasSnaky 6 required_615_i3 envelope_615_i3 := by + refine finite_compose HasSnaky 5 childrenC_615_i3 childrenD_615_i3 finite_children_work_615_i3 (6, 5) + required_615_i3 envelope_615_i3 pivot_mem_615_i3 child_required_sub_615_i3 child_envelope_sub_615_i3 ?_ + intro b hb + exact common_sub_615_i3 (mem_commonEnvelope childrenD_615_i3 b hb) + +theorem finite_children_work_615_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_615_i2 j) (childrenD_615_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_139 3 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_148 5 (6, 4)).mono (by decide +kernel) + · exact finite_row_works_615_i3.mono (by decide +kernel) + +theorem finite_row_works_615_i2 : FiniteTemplate HasSnaky 7 required_615_i2 envelope_615_i2 := by + refine finite_compose HasSnaky 6 childrenC_615_i2 childrenD_615_i2 finite_children_work_615_i2 (6, 4) + required_615_i2 envelope_615_i2 pivot_mem_615_i2 child_required_sub_615_i2 child_envelope_sub_615_i2 ?_ + intro b hb + exact common_sub_615_i2 (mem_commonEnvelope childrenD_615_i2 b hb) + +theorem finite_children_work_615_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_615_i1 j) (childrenD_615_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_43 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_57 4 (2, 8)).mono (by decide +kernel) + · exact finite_row_works_615_i2.mono (by decide +kernel) + +theorem finite_row_works_615_i1 : FiniteTemplate HasSnaky 8 required_615_i1 envelope_615_i1 := by + refine finite_compose HasSnaky 7 childrenC_615_i1 childrenD_615_i1 finite_children_work_615_i1 (4, 6) + required_615_i1 envelope_615_i1 pivot_mem_615_i1 child_required_sub_615_i1 child_envelope_sub_615_i1 ?_ + intro b hb + exact common_sub_615_i1 (mem_commonEnvelope childrenD_615_i1 b hb) + +theorem finite_children_work_615_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_615_i0 j) (childrenD_615_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_116 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_134 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_558 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_561 0 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_615_i1.mono (by decide +kernel) + +theorem finite_row_works_615_i0 : FiniteTemplate HasSnaky 10 required_615_i0 envelope_615_i0 := by + refine finite_compose HasSnaky 9 childrenC_615_i0 childrenD_615_i0 finite_children_work_615_i0 (5, 5) + required_615_i0 envelope_615_i0 pivot_mem_615_i0 child_required_sub_615_i0 child_envelope_sub_615_i0 ?_ + intro b hb + exact common_sub_615_i0 (mem_commonEnvelope childrenD_615_i0 b hb) + +theorem finite_children_work_615 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_615 j) (childrenD_615 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_362 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_614.mono (by decide +kernel) + · exact finite_row_works_615_i0.mono (by decide +kernel) + +theorem finite_row_works_615 : FiniteTemplate HasSnaky 11 required_615 envelope_615 := by + refine finite_compose HasSnaky 10 childrenC_615 childrenD_615 finite_children_work_615 (4, 5) + required_615 envelope_615 pivot_mem_615 child_required_sub_615 child_envelope_sub_615 ?_ + intro b hb + exact common_sub_615 (mem_commonEnvelope childrenD_615 b hb) + +theorem finite_children_work_617 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_617 j) (childrenD_617 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_136 4 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_332 7 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_616 0 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_617 : FiniteTemplate HasSnaky 11 required_617 envelope_617 := by + refine finite_compose HasSnaky 10 childrenC_617 childrenD_617 finite_children_work_617 (4, 3) + required_617 envelope_617 pivot_mem_617 child_required_sub_617 child_envelope_sub_617 ?_ + intro b hb + exact common_sub_617 (mem_commonEnvelope childrenD_617 b hb) + +theorem finite_children_work_624_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_624_i1 j) (childrenD_624_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_64 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_315 2 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_624_i1 : FiniteTemplate HasSnaky 7 required_624_i1 envelope_624_i1 := by + refine finite_compose HasSnaky 6 childrenC_624_i1 childrenD_624_i1 finite_children_work_624_i1 (4, 3) + required_624_i1 envelope_624_i1 pivot_mem_624_i1 child_required_sub_624_i1 child_envelope_sub_624_i1 ?_ + intro b hb + exact common_sub_624_i1 (mem_commonEnvelope childrenD_624_i1 b hb) + +theorem finite_children_work_624_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_624_i0 j) (childrenD_624_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_82 4 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_624_i1.mono (by decide +kernel) + +theorem finite_row_works_624_i0 : FiniteTemplate HasSnaky 8 required_624_i0 envelope_624_i0 := by + refine finite_compose HasSnaky 7 childrenC_624_i0 childrenD_624_i0 finite_children_work_624_i0 (3, 3) + required_624_i0 envelope_624_i0 pivot_mem_624_i0 child_required_sub_624_i0 child_envelope_sub_624_i0 ?_ + intro b hb + exact common_sub_624_i0 (mem_commonEnvelope childrenD_624_i0 b hb) + +theorem finite_children_work_624 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_624 j) (childrenD_624 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_545 0 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_624_i0.mono (by decide +kernel) + +theorem finite_row_works_624 : FiniteTemplate HasSnaky 11 required_624 envelope_624 := by + refine finite_compose HasSnaky 10 childrenC_624 childrenD_624 finite_children_work_624 (3, 4) + required_624 envelope_624 pivot_mem_624 child_required_sub_624 child_envelope_sub_624 ?_ + intro b hb + exact common_sub_624 (mem_commonEnvelope childrenD_624 b hb) + +theorem finite_children_work_625_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_625_i2 j) (childrenD_625_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_56 7 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_73 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_625_i2 : FiniteTemplate HasSnaky 5 required_625_i2 envelope_625_i2 := by + refine finite_compose HasSnaky 4 childrenC_625_i2 childrenD_625_i2 finite_children_work_625_i2 (3, 1) + required_625_i2 envelope_625_i2 pivot_mem_625_i2 child_required_sub_625_i2 child_envelope_sub_625_i2 ?_ + intro b hb + exact common_sub_625_i2 (mem_commonEnvelope childrenD_625_i2 b hb) + +theorem finite_children_work_625_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_625_i1 j) (childrenD_625_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_82 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_625_i2.mono (by decide +kernel) + +theorem finite_row_works_625_i1 : FiniteTemplate HasSnaky 6 required_625_i1 envelope_625_i1 := by + refine finite_compose HasSnaky 5 childrenC_625_i1 childrenD_625_i1 finite_children_work_625_i1 (3, 4) + required_625_i1 envelope_625_i1 pivot_mem_625_i1 child_required_sub_625_i1 child_envelope_sub_625_i1 ?_ + intro b hb + exact common_sub_625_i1 (mem_commonEnvelope childrenD_625_i1 b hb) + +theorem finite_children_work_625_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_625_i0 j) (childrenD_625_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_294 5 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_449 1 (0, 0)).mono (by decide +kernel) + · exact finite_row_works_625_i1.mono (by decide +kernel) + +theorem finite_row_works_625_i0 : FiniteTemplate HasSnaky 10 required_625_i0 envelope_625_i0 := by + refine finite_compose HasSnaky 9 childrenC_625_i0 childrenD_625_i0 finite_children_work_625_i0 (3, 3) + required_625_i0 envelope_625_i0 pivot_mem_625_i0 child_required_sub_625_i0 child_envelope_sub_625_i0 ?_ + intro b hb + exact common_sub_625_i0 (mem_commonEnvelope childrenD_625_i0 b hb) + +theorem finite_children_work_625 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_625 j) (childrenD_625 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_50 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_125 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_454 5 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_455 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_625_i0.mono (by decide +kernel) + +theorem finite_row_works_625 : FiniteTemplate HasSnaky 11 required_625 envelope_625 := by + refine finite_compose HasSnaky 10 childrenC_625 childrenD_625 finite_children_work_625 (3, 2) + required_625 envelope_625 pivot_mem_625 child_required_sub_625 child_envelope_sub_625 ?_ + intro b hb + exact common_sub_625 (mem_commonEnvelope childrenD_625 b hb) + +theorem finite_children_work_626_i1 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_626_i1 j) (childrenD_626_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_38 6 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_626_i1 : FiniteTemplate HasSnaky 3 required_626_i1 envelope_626_i1 := by + refine finite_compose HasSnaky 2 childrenC_626_i1 childrenD_626_i1 finite_children_work_626_i1 (2, 5) + required_626_i1 envelope_626_i1 pivot_mem_626_i1 child_required_sub_626_i1 child_envelope_sub_626_i1 ?_ + intro b hb + exact common_sub_626_i1 (mem_commonEnvelope childrenD_626_i1 b hb) + +theorem finite_children_work_626_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_626_i0 j) (childrenD_626_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_317 4 (2, 9)).mono (by decide +kernel) + · exact finite_row_works_626_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_519 0 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_626_i0 : FiniteTemplate HasSnaky 10 required_626_i0 envelope_626_i0 := by + refine finite_compose HasSnaky 9 childrenC_626_i0 childrenD_626_i0 finite_children_work_626_i0 (4, 5) + required_626_i0 envelope_626_i0 pivot_mem_626_i0 child_required_sub_626_i0 child_envelope_sub_626_i0 ?_ + intro b hb + exact common_sub_626_i0 (mem_commonEnvelope childrenD_626_i0 b hb) + +theorem finite_children_work_626_i3 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_626_i3 j) (childrenD_626_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_412 1 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_626_i3 : FiniteTemplate HasSnaky 9 required_626_i3 envelope_626_i3 := by + refine finite_compose HasSnaky 8 childrenC_626_i3 childrenD_626_i3 finite_children_work_626_i3 (2, 5) + required_626_i3 envelope_626_i3 pivot_mem_626_i3 child_required_sub_626_i3 child_envelope_sub_626_i3 ?_ + intro b hb + exact common_sub_626_i3 (mem_commonEnvelope childrenD_626_i3 b hb) + +theorem finite_children_work_626_i2 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_626_i2 j) (childrenD_626_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_336 1 (2, 5)).mono (by decide +kernel) + · exact finite_row_works_626_i3.mono (by decide +kernel) + +theorem finite_row_works_626_i2 : FiniteTemplate HasSnaky 10 required_626_i2 envelope_626_i2 := by + refine finite_compose HasSnaky 9 childrenC_626_i2 childrenD_626_i2 finite_children_work_626_i2 (4, 6) + required_626_i2 envelope_626_i2 pivot_mem_626_i2 child_required_sub_626_i2 child_envelope_sub_626_i2 ?_ + intro b hb + exact common_sub_626_i2 (mem_commonEnvelope childrenD_626_i2 b hb) + +theorem finite_children_work_626 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_626 j) (childrenD_626 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_323 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_430 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_592 7 (6, 6)).mono (by decide +kernel) + · exact finite_row_works_626_i0.mono (by decide +kernel) + · exact finite_row_works_626_i2.mono (by decide +kernel) + +theorem finite_row_works_626 : FiniteTemplate HasSnaky 11 required_626 envelope_626 := by + refine finite_compose HasSnaky 10 childrenC_626 childrenD_626 finite_children_work_626 (5, 6) + required_626 envelope_626 pivot_mem_626 child_required_sub_626 child_envelope_sub_626 ?_ + intro b hb + exact common_sub_626 (mem_commonEnvelope childrenD_626 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height11Part05.lean b/lean/snaky/FiniteCards/Height11Part05.lean new file mode 100644 index 0000000..21e4f93 --- /dev/null +++ b/lean/snaky/FiniteCards/Height11Part05.lean @@ -0,0 +1,355 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part05 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part03 +import FiniteCards.Height07Part05 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part03 +import FiniteCards.Height09Part04 +import FiniteCards.Height09Part07 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part04 +import FiniteCards.Height10Part06 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_639_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_639_i2 j) (childrenD_639_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_37 2 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_62 6 (4, 7)).mono (by decide +kernel) + +theorem finite_row_works_639_i2 : FiniteTemplate HasSnaky 4 required_639_i2 envelope_639_i2 := by + refine finite_compose HasSnaky 3 childrenC_639_i2 childrenD_639_i2 finite_children_work_639_i2 (3, 6) + required_639_i2 envelope_639_i2 pivot_mem_639_i2 child_required_sub_639_i2 child_envelope_sub_639_i2 ?_ + intro b hb + exact common_sub_639_i2 (mem_commonEnvelope childrenD_639_i2 b hb) + +theorem finite_children_work_639_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_639_i1 j) (childrenD_639_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_71 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_73 6 (4, 6)).mono (by decide +kernel) + · exact finite_row_works_639_i2.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_451 6 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_639_i1 : FiniteTemplate HasSnaky 6 required_639_i1 envelope_639_i1 := by + refine finite_compose HasSnaky 5 childrenC_639_i1 childrenD_639_i1 finite_children_work_639_i1 (3, 5) + required_639_i1 envelope_639_i1 pivot_mem_639_i1 child_required_sub_639_i1 child_envelope_sub_639_i1 ?_ + intro b hb + exact common_sub_639_i1 (mem_commonEnvelope childrenD_639_i1 b hb) + +theorem finite_children_work_639_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_639_i3 j) (childrenD_639_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_71 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_73 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_451 6 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_639_i3 : FiniteTemplate HasSnaky 7 required_639_i3 envelope_639_i3 := by + refine finite_compose HasSnaky 6 childrenC_639_i3 childrenD_639_i3 finite_children_work_639_i3 (3, 5) + required_639_i3 envelope_639_i3 pivot_mem_639_i3 child_required_sub_639_i3 child_envelope_sub_639_i3 ?_ + intro b hb + exact common_sub_639_i3 (mem_commonEnvelope childrenD_639_i3 b hb) + +theorem finite_children_work_639_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_639_i0 j) (childrenD_639_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_638 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_639_i1.mono (by decide +kernel) + · exact finite_row_works_639_i3.mono (by decide +kernel) + +theorem finite_row_works_639_i0 : FiniteTemplate HasSnaky 10 required_639_i0 envelope_639_i0 := by + refine finite_compose HasSnaky 9 childrenC_639_i0 childrenD_639_i0 finite_children_work_639_i0 (3, 3) + required_639_i0 envelope_639_i0 pivot_mem_639_i0 child_required_sub_639_i0 child_envelope_sub_639_i0 ?_ + intro b hb + exact common_sub_639_i0 (mem_commonEnvelope childrenD_639_i0 b hb) + +theorem finite_children_work_639 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_639 j) (childrenD_639 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_50 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_125 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_478 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_482 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_639_i0.mono (by decide +kernel) + +theorem finite_row_works_639 : FiniteTemplate HasSnaky 11 required_639 envelope_639 := by + refine finite_compose HasSnaky 10 childrenC_639 childrenD_639 finite_children_work_639 (3, 4) + required_639 envelope_639 pivot_mem_639 child_required_sub_639 child_envelope_sub_639 ?_ + intro b hb + exact common_sub_639 (mem_commonEnvelope childrenD_639 b hb) + +theorem finite_children_work_646_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_646_i0 j) (childrenD_646_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_72 1 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_262 7 (6, 5)).mono (by decide +kernel) + +theorem finite_row_works_646_i0 : FiniteTemplate HasSnaky 6 required_646_i0 envelope_646_i0 := by + refine finite_compose HasSnaky 5 childrenC_646_i0 childrenD_646_i0 finite_children_work_646_i0 (4, 2) + required_646_i0 envelope_646_i0 pivot_mem_646_i0 child_required_sub_646_i0 child_envelope_sub_646_i0 ?_ + intro b hb + exact common_sub_646_i0 (mem_commonEnvelope childrenD_646_i0 b hb) + +theorem finite_children_work_646 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_646 j) (childrenD_646 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_361 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_361 5 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_411 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_600 5 (7, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_621 3 (0, 7)).mono (by decide +kernel) + · exact finite_row_works_646_i0.mono (by decide +kernel) + +theorem finite_row_works_646 : FiniteTemplate HasSnaky 11 required_646 envelope_646 := by + refine finite_compose HasSnaky 10 childrenC_646 childrenD_646 finite_children_work_646 (4, 4) + required_646 envelope_646 pivot_mem_646 child_required_sub_646 child_envelope_sub_646 ?_ + intro b hb + exact common_sub_646 (mem_commonEnvelope childrenD_646 b hb) + +theorem finite_children_work_653_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_653_i0 j) (childrenD_653_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_206 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_301 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_405 5 (5, 3)).mono (by decide +kernel) + +theorem finite_row_works_653_i0 : FiniteTemplate HasSnaky 9 required_653_i0 envelope_653_i0 := by + refine finite_compose HasSnaky 8 childrenC_653_i0 childrenD_653_i0 finite_children_work_653_i0 (4, 4) + required_653_i0 envelope_653_i0 pivot_mem_653_i0 child_required_sub_653_i0 child_envelope_sub_653_i0 ?_ + intro b hb + exact common_sub_653_i0 (mem_commonEnvelope childrenD_653_i0 b hb) + +theorem finite_children_work_653 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_653 j) (childrenD_653 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 5 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_652 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_653_i0.mono (by decide +kernel) + +theorem finite_row_works_653 : FiniteTemplate HasSnaky 11 required_653 envelope_653 := by + refine finite_compose HasSnaky 10 childrenC_653 childrenD_653 finite_children_work_653 (2, 4) + required_653 envelope_653 pivot_mem_653 child_required_sub_653 child_envelope_sub_653 ?_ + intro b hb + exact common_sub_653 (mem_commonEnvelope childrenD_653 b hb) + +theorem finite_children_work_660_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_660_i1 j) (childrenD_660_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 5 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_18 1 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_660_i1 : FiniteTemplate HasSnaky 5 required_660_i1 envelope_660_i1 := by + refine finite_compose HasSnaky 4 childrenC_660_i1 childrenD_660_i1 finite_children_work_660_i1 (7, 5) + required_660_i1 envelope_660_i1 pivot_mem_660_i1 child_required_sub_660_i1 child_envelope_sub_660_i1 ?_ + intro b hb + exact common_sub_660_i1 (mem_commonEnvelope childrenD_660_i1 b hb) + +theorem finite_children_work_660_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_660_i2 j) (childrenD_660_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 5 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_252 0 (3, 2)).mono (by decide +kernel) + +theorem finite_row_works_660_i2 : FiniteTemplate HasSnaky 6 required_660_i2 envelope_660_i2 := by + refine finite_compose HasSnaky 5 childrenC_660_i2 childrenD_660_i2 finite_children_work_660_i2 (7, 5) + required_660_i2 envelope_660_i2 pivot_mem_660_i2 child_required_sub_660_i2 child_envelope_sub_660_i2 ?_ + intro b hb + exact common_sub_660_i2 (mem_commonEnvelope childrenD_660_i2 b hb) + +theorem finite_children_work_660_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_660_i0 j) (childrenD_660_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 3 (2, 6)).mono (by decide +kernel) + · exact finite_row_works_660_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_659 0 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_660_i2.mono (by decide +kernel) + +theorem finite_row_works_660_i0 : FiniteTemplate HasSnaky 10 required_660_i0 envelope_660_i0 := by + refine finite_compose HasSnaky 9 childrenC_660_i0 childrenD_660_i0 finite_children_work_660_i0 (6, 5) + required_660_i0 envelope_660_i0 pivot_mem_660_i0 child_required_sub_660_i0 child_envelope_sub_660_i0 ?_ + intro b hb + exact common_sub_660_i0 (mem_commonEnvelope childrenD_660_i0 b hb) + +theorem finite_children_work_660 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_660 j) (childrenD_660 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_137 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_332 6 (6, 8)).mono (by decide +kernel) + · exact finite_row_works_660_i0.mono (by decide +kernel) + +theorem finite_row_works_660 : FiniteTemplate HasSnaky 11 required_660 envelope_660 := by + refine finite_compose HasSnaky 10 childrenC_660 childrenD_660 finite_children_work_660 (3, 5) + required_660 envelope_660 pivot_mem_660 child_required_sub_660 child_envelope_sub_660 ?_ + intro b hb + exact common_sub_660 (mem_commonEnvelope childrenD_660 b hb) + +theorem finite_children_work_663 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_663 j) (childrenD_663 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_134 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 4 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_507 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_558 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_562 4 (1, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_580 0 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_662.mono (by decide +kernel) + +theorem finite_row_works_663 : FiniteTemplate HasSnaky 11 required_663 envelope_663 := by + refine finite_compose HasSnaky 10 childrenC_663 childrenD_663 finite_children_work_663 (4, 5) + required_663 envelope_663 pivot_mem_663 child_required_sub_663 child_envelope_sub_663 ?_ + intro b hb + exact common_sub_663 (mem_commonEnvelope childrenD_663 b hb) + +theorem finite_children_work_664 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_664 j) (childrenD_664 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_134 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_309 2 (7, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_558 4 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_580 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_662 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_664 : FiniteTemplate HasSnaky 11 required_664 envelope_664 := by + refine finite_compose HasSnaky 10 childrenC_664 childrenD_664 finite_children_work_664 (6, 5) + required_664 envelope_664 pivot_mem_664 child_required_sub_664 child_envelope_sub_664 ?_ + intro b hb + exact common_sub_664 (mem_commonEnvelope childrenD_664 b hb) + +theorem finite_children_work_676_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_676_i0 j) (childrenD_676_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_55 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_380 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_676_i0 : FiniteTemplate HasSnaky 10 required_676_i0 envelope_676_i0 := by + refine finite_compose HasSnaky 9 childrenC_676_i0 childrenD_676_i0 finite_children_work_676_i0 (2, 4) + required_676_i0 envelope_676_i0 pivot_mem_676_i0 child_required_sub_676_i0 child_envelope_sub_676_i0 ?_ + intro b hb + exact common_sub_676_i0 (mem_commonEnvelope childrenD_676_i0 b hb) + +theorem finite_children_work_676 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_676 j) (childrenD_676 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_676_i0.mono (by decide +kernel) + +theorem finite_row_works_676 : FiniteTemplate HasSnaky 11 required_676 envelope_676 := by + refine finite_compose HasSnaky 10 childrenC_676 childrenD_676 finite_children_work_676 (4, 3) + required_676 envelope_676 pivot_mem_676 child_required_sub_676 child_envelope_sub_676 ?_ + intro b hb + exact common_sub_676 (mem_commonEnvelope childrenD_676 b hb) + +theorem finite_children_work_685_i4 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_685_i4 j) (childrenD_685_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_312 0 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_685_i4 : FiniteTemplate HasSnaky 6 required_685_i4 envelope_685_i4 := by + refine finite_compose HasSnaky 5 childrenC_685_i4 childrenD_685_i4 finite_children_work_685_i4 (3, 1) + required_685_i4 envelope_685_i4 pivot_mem_685_i4 child_required_sub_685_i4 child_envelope_sub_685_i4 ?_ + intro b hb + exact common_sub_685_i4 (mem_commonEnvelope childrenD_685_i4 b hb) + +theorem finite_children_work_685_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_685_i3 j) (childrenD_685_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (3, 5)).mono (by decide +kernel) + · exact finite_row_works_685_i4.mono (by decide +kernel) + +theorem finite_row_works_685_i3 : FiniteTemplate HasSnaky 7 required_685_i3 envelope_685_i3 := by + refine finite_compose HasSnaky 6 childrenC_685_i3 childrenD_685_i3 finite_children_work_685_i3 (2, 1) + required_685_i3 envelope_685_i3 pivot_mem_685_i3 child_required_sub_685_i3 child_envelope_sub_685_i3 ?_ + intro b hb + exact common_sub_685_i3 (mem_commonEnvelope childrenD_685_i3 b hb) + +theorem finite_children_work_685_i2 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_685_i2 j) (childrenD_685_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_351 4 (3, 6)).mono (by decide +kernel) + · exact finite_row_works_685_i3.mono (by decide +kernel) + +theorem finite_row_works_685_i2 : FiniteTemplate HasSnaky 8 required_685_i2 envelope_685_i2 := by + refine finite_compose HasSnaky 7 childrenC_685_i2 childrenD_685_i2 finite_children_work_685_i2 (6, 2) + required_685_i2 envelope_685_i2 pivot_mem_685_i2 child_required_sub_685_i2 child_envelope_sub_685_i2 ?_ + intro b hb + exact common_sub_685_i2 (mem_commonEnvelope childrenD_685_i2 b hb) + +theorem finite_children_work_685_i1 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_685_i1 j) (childrenD_685_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_96 1 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_685_i2.mono (by decide +kernel) + +theorem finite_row_works_685_i1 : FiniteTemplate HasSnaky 9 required_685_i1 envelope_685_i1 := by + refine finite_compose HasSnaky 8 childrenC_685_i1 childrenD_685_i1 finite_children_work_685_i1 (6, 4) + required_685_i1 envelope_685_i1 pivot_mem_685_i1 child_required_sub_685_i1 child_envelope_sub_685_i1 ?_ + intro b hb + exact common_sub_685_i1 (mem_commonEnvelope childrenD_685_i1 b hb) + +theorem finite_children_work_685_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_685_i0 j) (childrenD_685_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 2)).mono (by decide +kernel) + · exact finite_row_works_685_i1.mono (by decide +kernel) + +theorem finite_row_works_685_i0 : FiniteTemplate HasSnaky 10 required_685_i0 envelope_685_i0 := by + refine finite_compose HasSnaky 9 childrenC_685_i0 childrenD_685_i0 finite_children_work_685_i0 (3, 2) + required_685_i0 envelope_685_i0 pivot_mem_685_i0 child_required_sub_685_i0 child_envelope_sub_685_i0 ?_ + intro b hb + exact common_sub_685_i0 (mem_commonEnvelope childrenD_685_i0 b hb) + +theorem finite_children_work_685 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_685 j) (childrenD_685 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_67 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_175 7 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_228 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_531 0 (3, 2)).mono (by decide +kernel) + · exact finite_row_works_685_i0.mono (by decide +kernel) + +theorem finite_row_works_685 : FiniteTemplate HasSnaky 11 required_685 envelope_685 := by + refine finite_compose HasSnaky 10 childrenC_685 childrenD_685 finite_children_work_685 (5, 5) + required_685 envelope_685 pivot_mem_685 child_required_sub_685 child_envelope_sub_685 ?_ + intro b hb + exact common_sub_685 (mem_commonEnvelope childrenD_685 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height11Part06.lean b/lean/snaky/FiniteCards/Height11Part06.lean new file mode 100644 index 0000000..1eb21c6 --- /dev/null +++ b/lean/snaky/FiniteCards/Height11Part06.lean @@ -0,0 +1,226 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part06 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height08Part01 +import FiniteCards.Height09Part05 +import FiniteCards.Height09Part07 +import FiniteCards.Height09Part08 +import FiniteCards.Height10Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_689_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_689_i0 j) (childrenD_689_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_67 2 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_175 6 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_228 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_373 5 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_688 1 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_689_i0 : FiniteTemplate HasSnaky 10 required_689_i0 envelope_689_i0 := by + refine finite_compose HasSnaky 9 childrenC_689_i0 childrenD_689_i0 finite_children_work_689_i0 (4, 6) + required_689_i0 envelope_689_i0 pivot_mem_689_i0 child_required_sub_689_i0 child_envelope_sub_689_i0 ?_ + intro b hb + exact common_sub_689_i0 (mem_commonEnvelope childrenD_689_i0 b hb) + +theorem finite_children_work_689 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_689 j) (childrenD_689 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_324 2 (5, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_686 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_689_i0.mono (by decide +kernel) + +theorem finite_row_works_689 : FiniteTemplate HasSnaky 11 required_689 envelope_689 := by + refine finite_compose HasSnaky 10 childrenC_689 childrenD_689 finite_children_work_689 (4, 5) + required_689 envelope_689 pivot_mem_689 child_required_sub_689 child_envelope_sub_689 ?_ + intro b hb + exact common_sub_689 (mem_commonEnvelope childrenD_689 b hb) + +theorem finite_children_work_700_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_700_i0 j) (childrenD_700_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_39 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_700_i0 : FiniteTemplate HasSnaky 5 required_700_i0 envelope_700_i0 := by + refine finite_compose HasSnaky 4 childrenC_700_i0 childrenD_700_i0 finite_children_work_700_i0 (2, 5) + required_700_i0 envelope_700_i0 pivot_mem_700_i0 child_required_sub_700_i0 child_envelope_sub_700_i0 ?_ + intro b hb + exact common_sub_700_i0 (mem_commonEnvelope childrenD_700_i0 b hb) + +theorem finite_children_work_700_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_700_i3 j) (childrenD_700_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 4 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_700_i3 : FiniteTemplate HasSnaky 6 required_700_i3 envelope_700_i3 := by + refine finite_compose HasSnaky 5 childrenC_700_i3 childrenD_700_i3 finite_children_work_700_i3 (3, 5) + required_700_i3 envelope_700_i3 pivot_mem_700_i3 child_required_sub_700_i3 child_envelope_sub_700_i3 ?_ + intro b hb + exact common_sub_700_i3 (mem_commonEnvelope childrenD_700_i3 b hb) + +theorem finite_children_work_700_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_700_i2 j) (childrenD_700_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_700_i3.mono (by decide +kernel) + +theorem finite_row_works_700_i2 : FiniteTemplate HasSnaky 7 required_700_i2 envelope_700_i2 := by + refine finite_compose HasSnaky 6 childrenC_700_i2 childrenD_700_i2 finite_children_work_700_i2 (2, 5) + required_700_i2 envelope_700_i2 pivot_mem_700_i2 child_required_sub_700_i2 child_envelope_sub_700_i2 ?_ + intro b hb + exact common_sub_700_i2 (mem_commonEnvelope childrenD_700_i2 b hb) + +theorem finite_children_work_700_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_700_i1 j) (childrenD_700_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_61 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_348 1 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_700_i2.mono (by decide +kernel) + +theorem finite_row_works_700_i1 : FiniteTemplate HasSnaky 8 required_700_i1 envelope_700_i1 := by + refine finite_compose HasSnaky 7 childrenC_700_i1 childrenD_700_i1 finite_children_work_700_i1 (2, 6) + required_700_i1 envelope_700_i1 pivot_mem_700_i1 child_required_sub_700_i1 child_envelope_sub_700_i1 ?_ + intro b hb + exact common_sub_700_i1 (mem_commonEnvelope childrenD_700_i1 b hb) + +theorem finite_children_work_700_i5 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_700_i5 j) (childrenD_700_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 3 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 4 (3, 7)).mono (by decide +kernel) + +theorem finite_row_works_700_i5 : FiniteTemplate HasSnaky 4 required_700_i5 envelope_700_i5 := by + refine finite_compose HasSnaky 3 childrenC_700_i5 childrenD_700_i5 finite_children_work_700_i5 (4, 4) + required_700_i5 envelope_700_i5 pivot_mem_700_i5 child_required_sub_700_i5 child_envelope_sub_700_i5 ?_ + intro b hb + exact common_sub_700_i5 (mem_commonEnvelope childrenD_700_i5 b hb) + +theorem finite_children_work_700_i6 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_700_i6 j) (childrenD_700_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_40 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_700_i6 : FiniteTemplate HasSnaky 4 required_700_i6 envelope_700_i6 := by + refine finite_compose HasSnaky 3 childrenC_700_i6 childrenD_700_i6 finite_children_work_700_i6 (2, 5) + required_700_i6 envelope_700_i6 pivot_mem_700_i6 child_required_sub_700_i6 child_envelope_sub_700_i6 ?_ + intro b hb + exact common_sub_700_i6 (mem_commonEnvelope childrenD_700_i6 b hb) + +theorem finite_children_work_700_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_700_i4 j) (childrenD_700_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_304 6 (5, 8)).mono (by decide +kernel) + · exact finite_row_works_700_i5.mono (by decide +kernel) + · exact finite_row_works_700_i6.mono (by decide +kernel) + +theorem finite_row_works_700_i4 : FiniteTemplate HasSnaky 5 required_700_i4 envelope_700_i4 := by + refine finite_compose HasSnaky 4 childrenC_700_i4 childrenD_700_i4 finite_children_work_700_i4 (4, 6) + required_700_i4 envelope_700_i4 pivot_mem_700_i4 child_required_sub_700_i4 child_envelope_sub_700_i4 ?_ + intro b hb + exact common_sub_700_i4 (mem_commonEnvelope childrenD_700_i4 b hb) + +theorem finite_children_work_700 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_700 j) (childrenD_700 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_204 4 (0, 8)).mono (by decide +kernel) + · exact finite_row_works_700_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_460 0 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_700_i1.mono (by decide +kernel) + · exact finite_row_works_700_i4.mono (by decide +kernel) + +theorem finite_row_works_700 : FiniteTemplate HasSnaky 11 required_700 envelope_700 := by + refine finite_compose HasSnaky 10 childrenC_700 childrenD_700 finite_children_work_700 (4, 5) + required_700 envelope_700 pivot_mem_700 child_required_sub_700 child_envelope_sub_700 ?_ + intro b hb + exact common_sub_700 (mem_commonEnvelope childrenD_700 b hb) + +theorem finite_children_work_710_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_710_i1 j) (childrenD_710_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_196 3 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_710_i1 : FiniteTemplate HasSnaky 5 required_710_i1 envelope_710_i1 := by + refine finite_compose HasSnaky 4 childrenC_710_i1 childrenD_710_i1 finite_children_work_710_i1 (3, 2) + required_710_i1 envelope_710_i1 pivot_mem_710_i1 child_required_sub_710_i1 child_envelope_sub_710_i1 ?_ + intro b hb + exact common_sub_710_i1 (mem_commonEnvelope childrenD_710_i1 b hb) + +theorem finite_children_work_710_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_710_i0 j) (childrenD_710_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_115 3 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_710_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_577 1 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_710_i0 : FiniteTemplate HasSnaky 10 required_710_i0 envelope_710_i0 := by + refine finite_compose HasSnaky 9 childrenC_710_i0 childrenD_710_i0 finite_children_work_710_i0 (3, 3) + required_710_i0 envelope_710_i0 pivot_mem_710_i0 child_required_sub_710_i0 child_envelope_sub_710_i0 ?_ + intro b hb + exact common_sub_710_i0 (mem_commonEnvelope childrenD_710_i0 b hb) + +theorem finite_children_work_710 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_710 j) (childrenD_710 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_117 1 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_710_i0.mono (by decide +kernel) + +theorem finite_row_works_710 : FiniteTemplate HasSnaky 11 required_710 envelope_710 := by + refine finite_compose HasSnaky 10 childrenC_710 childrenD_710 finite_children_work_710 (3, 6) + required_710 envelope_710 pivot_mem_710 child_required_sub_710 child_envelope_sub_710 ?_ + intro b hb + exact common_sub_710 (mem_commonEnvelope childrenD_710 b hb) + +theorem finite_children_work_716_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_716_i0 j) (childrenD_716_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_55 0 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_659 2 (7, 0)).mono (by decide +kernel) + +theorem finite_row_works_716_i0 : FiniteTemplate HasSnaky 10 required_716_i0 envelope_716_i0 := by + refine finite_compose HasSnaky 9 childrenC_716_i0 childrenD_716_i0 finite_children_work_716_i0 (6, 4) + required_716_i0 envelope_716_i0 pivot_mem_716_i0 child_required_sub_716_i0 child_envelope_sub_716_i0 ?_ + intro b hb + exact common_sub_716_i0 (mem_commonEnvelope childrenD_716_i0 b hb) + +theorem finite_children_work_716 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_716 j) (childrenD_716 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 1 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_49 4 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_142 0 (3, 2)).mono (by decide +kernel) + · exact finite_row_works_716_i0.mono (by decide +kernel) + +theorem finite_row_works_716 : FiniteTemplate HasSnaky 11 required_716 envelope_716 := by + refine finite_compose HasSnaky 10 childrenC_716 childrenD_716 finite_children_work_716 (7, 5) + required_716 envelope_716 pivot_mem_716 child_required_sub_716 child_envelope_sub_716 ?_ + intro b hb + exact common_sub_716 (mem_commonEnvelope childrenD_716 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height12Part01.lean b/lean/snaky/FiniteCards/Height12Part01.lean new file mode 100644 index 0000000..1043ef4 --- /dev/null +++ b/lean/snaky/FiniteCards/Height12Part01.lean @@ -0,0 +1,324 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part05 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part03 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part02 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part04 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part02 +import FiniteCards.Height11Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_428 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_428 j) (childrenD_428 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_427 4 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_428 : FiniteTemplate HasSnaky 12 required_428 envelope_428 := by + refine finite_compose HasSnaky 11 childrenC_428 childrenD_428 finite_children_work_428 (1, 4) + required_428 envelope_428 pivot_mem_428 child_required_sub_428 child_envelope_sub_428 ?_ + intro b hb + exact common_sub_428 (mem_commonEnvelope childrenD_428 b hb) + +theorem finite_children_work_485_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_485_i0 j) (childrenD_485_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_81 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_204 4 (0, 8)).mono (by decide +kernel) + · exact finite_row_works_353.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_481 4 (2, 8)).mono (by decide +kernel) + +theorem finite_row_works_485_i0 : FiniteTemplate HasSnaky 11 required_485_i0 envelope_485_i0 := by + refine finite_compose HasSnaky 10 childrenC_485_i0 childrenD_485_i0 finite_children_work_485_i0 (4, 5) + required_485_i0 envelope_485_i0 pivot_mem_485_i0 child_required_sub_485_i0 child_envelope_sub_485_i0 ?_ + intro b hb + exact common_sub_485_i0 (mem_commonEnvelope childrenD_485_i0 b hb) + +theorem finite_children_work_485_i2 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_485_i2 j) (childrenD_485_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 2 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_189 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_192 2 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_193 2 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_457 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_477 3 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_485_i2 : FiniteTemplate HasSnaky 10 required_485_i2 envelope_485_i2 := by + refine finite_compose HasSnaky 9 childrenC_485_i2 childrenD_485_i2 finite_children_work_485_i2 (4, 4) + required_485_i2 envelope_485_i2 pivot_mem_485_i2 child_required_sub_485_i2 child_envelope_sub_485_i2 ?_ + intro b hb + exact common_sub_485_i2 (mem_commonEnvelope childrenD_485_i2 b hb) + +theorem finite_children_work_485_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_485_i3 j) (childrenD_485_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_166 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 5 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_485_i3 : FiniteTemplate HasSnaky 7 required_485_i3 envelope_485_i3 := by + refine finite_compose HasSnaky 6 childrenC_485_i3 childrenD_485_i3 finite_children_work_485_i3 (2, 4) + required_485_i3 envelope_485_i3 pivot_mem_485_i3 child_required_sub_485_i3 child_envelope_sub_485_i3 ?_ + intro b hb + exact common_sub_485_i3 (mem_commonEnvelope childrenD_485_i3 b hb) + +theorem finite_children_work_485_i1 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_485_i1 j) (childrenD_485_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_81 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_167 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_485_i2.mono (by decide +kernel) + · exact finite_row_works_485_i3.mono (by decide +kernel) + +theorem finite_row_works_485_i1 : FiniteTemplate HasSnaky 11 required_485_i1 envelope_485_i1 := by + refine finite_compose HasSnaky 10 childrenC_485_i1 childrenD_485_i1 finite_children_work_485_i1 (4, 5) + required_485_i1 envelope_485_i1 pivot_mem_485_i1 child_required_sub_485_i1 child_envelope_sub_485_i1 ?_ + intro b hb + exact common_sub_485_i1 (mem_commonEnvelope childrenD_485_i1 b hb) + +theorem finite_children_work_485 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_485 j) (childrenD_485 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_313 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_469 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_485_i0.mono (by decide +kernel) + · exact finite_row_works_485_i1.mono (by decide +kernel) + · exact finite_row_works_484.mono (by decide +kernel) + +theorem finite_row_works_485 : FiniteTemplate HasSnaky 12 required_485 envelope_485 := by + refine finite_compose HasSnaky 11 childrenC_485 childrenD_485 finite_children_work_485 (4, 3) + required_485 envelope_485 pivot_mem_485 child_required_sub_485 child_envelope_sub_485 ?_ + intro b hb + exact common_sub_485 (mem_commonEnvelope childrenD_485 b hb) + +theorem finite_children_work_489_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_489_i1 j) (childrenD_489_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 0 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 6 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_63 0 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_486 3 (2, 8)).mono (by decide +kernel) + +theorem finite_row_works_489_i1 : FiniteTemplate HasSnaky 7 required_489_i1 envelope_489_i1 := by + refine finite_compose HasSnaky 6 childrenC_489_i1 childrenD_489_i1 finite_children_work_489_i1 (5, 7) + required_489_i1 envelope_489_i1 pivot_mem_489_i1 child_required_sub_489_i1 child_envelope_sub_489_i1 ?_ + intro b hb + exact common_sub_489_i1 (mem_commonEnvelope childrenD_489_i1 b hb) + +theorem finite_children_work_489_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_489_i0 j) (childrenD_489_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (2, 5)).mono (by decide +kernel) + · exact finite_row_works_489_i1.mono (by decide +kernel) + +theorem finite_row_works_489_i0 : FiniteTemplate HasSnaky 8 required_489_i0 envelope_489_i0 := by + refine finite_compose HasSnaky 7 childrenC_489_i0 childrenD_489_i0 finite_children_work_489_i0 (5, 6) + required_489_i0 envelope_489_i0 pivot_mem_489_i0 child_required_sub_489_i0 child_envelope_sub_489_i0 ?_ + intro b hb + exact common_sub_489_i0 (mem_commonEnvelope childrenD_489_i0 b hb) + +theorem finite_children_work_489_i2 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_489_i2 j) (childrenD_489_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_81 0 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_167 0 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_481 5 (8, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_488 1 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_489_i2 : FiniteTemplate HasSnaky 11 required_489_i2 envelope_489_i2 := by + refine finite_compose HasSnaky 10 childrenC_489_i2 childrenD_489_i2 finite_children_work_489_i2 (5, 8) + required_489_i2 envelope_489_i2 pivot_mem_489_i2 child_required_sub_489_i2 child_envelope_sub_489_i2 ?_ + intro b hb + exact common_sub_489_i2 (mem_commonEnvelope childrenD_489_i2 b hb) + +theorem finite_children_work_489 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_489 j) (childrenD_489 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_313 2 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_470 4 (1, 10)).mono (by decide +kernel) + · exact finite_row_works_489_i0.mono (by decide +kernel) + · exact finite_row_works_489_i2.mono (by decide +kernel) + +theorem finite_row_works_489 : FiniteTemplate HasSnaky 12 required_489 envelope_489 := by + refine finite_compose HasSnaky 11 childrenC_489 childrenD_489 finite_children_work_489 (3, 8) + required_489 envelope_489 pivot_mem_489 child_required_sub_489 child_envelope_sub_489 ?_ + intro b hb + exact common_sub_489 (mem_commonEnvelope childrenD_489 b hb) + +theorem finite_children_work_543_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_543_i1 j) (childrenD_543_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_261 0 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_370 1 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_543_i1 : FiniteTemplate HasSnaky 6 required_543_i1 envelope_543_i1 := by + refine finite_compose HasSnaky 5 childrenC_543_i1 childrenD_543_i1 finite_children_work_543_i1 (5, 7) + required_543_i1 envelope_543_i1 pivot_mem_543_i1 child_required_sub_543_i1 child_envelope_sub_543_i1 ?_ + intro b hb + exact common_sub_543_i1 (mem_commonEnvelope childrenD_543_i1 b hb) + +theorem finite_children_work_543_i6 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_543_i6 j) (childrenD_543_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_154 0 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_170 0 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_543_i6 : FiniteTemplate HasSnaky 3 required_543_i6 envelope_543_i6 := by + refine finite_compose HasSnaky 2 childrenC_543_i6 childrenD_543_i6 finite_children_work_543_i6 (5, 5) + required_543_i6 envelope_543_i6 pivot_mem_543_i6 child_required_sub_543_i6 child_envelope_sub_543_i6 ?_ + intro b hb + exact common_sub_543_i6 (mem_commonEnvelope childrenD_543_i6 b hb) + +theorem finite_children_work_543_i5 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_543_i5 j) (childrenD_543_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 6 (5, 7)).mono (by decide +kernel) + · exact finite_row_works_543_i6.mono (by decide +kernel) + +theorem finite_row_works_543_i5 : FiniteTemplate HasSnaky 4 required_543_i5 envelope_543_i5 := by + refine finite_compose HasSnaky 3 childrenC_543_i5 childrenD_543_i5 finite_children_work_543_i5 (5, 7) + required_543_i5 envelope_543_i5 pivot_mem_543_i5 child_required_sub_543_i5 child_envelope_sub_543_i5 ?_ + intro b hb + exact common_sub_543_i5 (mem_commonEnvelope childrenD_543_i5 b hb) + +theorem finite_children_work_543_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_543_i4 j) (childrenD_543_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_16 0 (2, 7)).mono (by decide +kernel) + · exact finite_row_works_543_i5.mono (by decide +kernel) + +theorem finite_row_works_543_i4 : FiniteTemplate HasSnaky 5 required_543_i4 envelope_543_i4 := by + refine finite_compose HasSnaky 4 childrenC_543_i4 childrenD_543_i4 finite_children_work_543_i4 (3, 7) + required_543_i4 envelope_543_i4 pivot_mem_543_i4 child_required_sub_543_i4 child_envelope_sub_543_i4 ?_ + intro b hb + exact common_sub_543_i4 (mem_commonEnvelope childrenD_543_i4 b hb) + +theorem finite_children_work_543_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_543_i3 j) (childrenD_543_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (2, 10)).mono (by decide +kernel) + · exact finite_row_works_543_i4.mono (by decide +kernel) + +theorem finite_row_works_543_i3 : FiniteTemplate HasSnaky 6 required_543_i3 envelope_543_i3 := by + refine finite_compose HasSnaky 5 childrenC_543_i3 childrenD_543_i3 finite_children_work_543_i3 (1, 6) + required_543_i3 envelope_543_i3 pivot_mem_543_i3 child_required_sub_543_i3 child_envelope_sub_543_i3 ?_ + intro b hb + exact common_sub_543_i3 (mem_commonEnvelope childrenD_543_i3 b hb) + +theorem finite_children_work_543_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_543_i2 j) (childrenD_543_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 2 (2, 6)).mono (by decide +kernel) + · exact finite_row_works_543_i3.mono (by decide +kernel) + +theorem finite_row_works_543_i2 : FiniteTemplate HasSnaky 7 required_543_i2 envelope_543_i2 := by + refine finite_compose HasSnaky 6 childrenC_543_i2 childrenD_543_i2 finite_children_work_543_i2 (2, 10) + required_543_i2 envelope_543_i2 pivot_mem_543_i2 child_required_sub_543_i2 child_envelope_sub_543_i2 ?_ + intro b hb + exact common_sub_543_i2 (mem_commonEnvelope childrenD_543_i2 b hb) + +theorem finite_children_work_543_i7 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_543_i7 j) (childrenD_543_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 2 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_539 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_543_i7 : FiniteTemplate HasSnaky 10 required_543_i7 envelope_543_i7 := by + refine finite_compose HasSnaky 9 childrenC_543_i7 childrenD_543_i7 finite_children_work_543_i7 (2, 10) + required_543_i7 envelope_543_i7 pivot_mem_543_i7 child_required_sub_543_i7 child_envelope_sub_543_i7 ?_ + intro b hb + exact common_sub_543_i7 (mem_commonEnvelope childrenD_543_i7 b hb) + +theorem finite_children_work_543_i8 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_543_i8 j) (childrenD_543_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_86 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_542 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_543_i8 : FiniteTemplate HasSnaky 8 required_543_i8 envelope_543_i8 := by + refine finite_compose HasSnaky 7 childrenC_543_i8 childrenD_543_i8 finite_children_work_543_i8 (4, 6) + required_543_i8 envelope_543_i8 pivot_mem_543_i8 child_required_sub_543_i8 child_envelope_sub_543_i8 ?_ + intro b hb + exact common_sub_543_i8 (mem_commonEnvelope childrenD_543_i8 b hb) + +theorem finite_children_work_543_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_543_i0 j) (childrenD_543_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_433 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_543_i1.mono (by decide +kernel) + · exact finite_row_works_543_i2.mono (by decide +kernel) + · exact finite_row_works_543_i7.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_540 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_541 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_543_i8.mono (by decide +kernel) + +theorem finite_row_works_543_i0 : FiniteTemplate HasSnaky 11 required_543_i0 envelope_543_i0 := by + refine finite_compose HasSnaky 10 childrenC_543_i0 childrenD_543_i0 finite_children_work_543_i0 (4, 5) + required_543_i0 envelope_543_i0 pivot_mem_543_i0 child_required_sub_543_i0 child_envelope_sub_543_i0 ?_ + intro b hb + exact common_sub_543_i0 (mem_commonEnvelope childrenD_543_i0 b hb) + +theorem finite_children_work_543_i10 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_543_i10 j) (childrenD_543_i10 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 7 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 1 (2, 5)).mono (by decide +kernel) + +theorem finite_row_works_543_i10 : FiniteTemplate HasSnaky 2 required_543_i10 envelope_543_i10 := by + refine finite_compose HasSnaky 1 childrenC_543_i10 childrenD_543_i10 finite_children_work_543_i10 (2, 5) + required_543_i10 envelope_543_i10 pivot_mem_543_i10 child_required_sub_543_i10 child_envelope_sub_543_i10 ?_ + intro b hb + exact common_sub_543_i10 (mem_commonEnvelope childrenD_543_i10 b hb) + +theorem finite_children_work_543_i9 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_543_i9 j) (childrenD_543_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_278 1 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_543_i10.mono (by decide +kernel) + +theorem finite_row_works_543_i9 : FiniteTemplate HasSnaky 6 required_543_i9 envelope_543_i9 := by + refine finite_compose HasSnaky 5 childrenC_543_i9 childrenD_543_i9 finite_children_work_543_i9 (3, 8) + required_543_i9 envelope_543_i9 pivot_mem_543_i9 child_required_sub_543_i9 child_envelope_sub_543_i9 ?_ + intro b hb + exact common_sub_543_i9 (mem_commonEnvelope childrenD_543_i9 b hb) + +theorem finite_children_work_543 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_543 j) (childrenD_543 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_280 0 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_543_i0.mono (by decide +kernel) + · exact finite_row_works_543_i9.mono (by decide +kernel) + +theorem finite_row_works_543 : FiniteTemplate HasSnaky 12 required_543 envelope_543 := by + refine finite_compose HasSnaky 11 childrenC_543 childrenD_543 finite_children_work_543 (2, 9) + required_543 envelope_543 pivot_mem_543 child_required_sub_543 child_envelope_sub_543 ?_ + intro b hb + exact common_sub_543 (mem_commonEnvelope childrenD_543 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height12Part02.lean b/lean/snaky/FiniteCards/Height12Part02.lean new file mode 100644 index 0000000..88ea2f3 --- /dev/null +++ b/lean/snaky/FiniteCards/Height12Part02.lean @@ -0,0 +1,322 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part02 +import FiniteCards.Height07Part02 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part04 +import FiniteCards.Height10Part04 +import FiniteCards.Height11Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_551_i7 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_551_i7 j) (childrenD_551_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 7 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 2 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_551_i7 : FiniteTemplate HasSnaky 4 required_551_i7 envelope_551_i7 := by + refine finite_compose HasSnaky 3 childrenC_551_i7 childrenD_551_i7 finite_children_work_551_i7 (3, 3) + required_551_i7 envelope_551_i7 pivot_mem_551_i7 child_required_sub_551_i7 child_envelope_sub_551_i7 ?_ + intro b hb + exact common_sub_551_i7 (mem_commonEnvelope childrenD_551_i7 b hb) + +theorem finite_children_work_551_i8 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_551_i8 j) (childrenD_551_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 0 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_6 7 (5, 3)).mono (by decide +kernel) + +theorem finite_row_works_551_i8 : FiniteTemplate HasSnaky 3 required_551_i8 envelope_551_i8 := by + refine finite_compose HasSnaky 2 childrenC_551_i8 childrenD_551_i8 finite_children_work_551_i8 (3, 3) + required_551_i8 envelope_551_i8 pivot_mem_551_i8 child_required_sub_551_i8 child_envelope_sub_551_i8 ?_ + intro b hb + exact common_sub_551_i8 (mem_commonEnvelope childrenD_551_i8 b hb) + +theorem finite_children_work_551_i6 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_551_i6 j) (childrenD_551_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_25 2 (7, 2)).mono (by decide +kernel) + · exact finite_row_works_551_i7.mono (by decide +kernel) + · exact finite_row_works_551_i8.mono (by decide +kernel) + +theorem finite_row_works_551_i6 : FiniteTemplate HasSnaky 5 required_551_i6 envelope_551_i6 := by + refine finite_compose HasSnaky 4 childrenC_551_i6 childrenD_551_i6 finite_children_work_551_i6 (4, 3) + required_551_i6 envelope_551_i6 pivot_mem_551_i6 child_required_sub_551_i6 child_envelope_sub_551_i6 ?_ + intro b hb + exact common_sub_551_i6 (mem_commonEnvelope childrenD_551_i6 b hb) + +theorem finite_children_work_551_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_551_i5 j) (childrenD_551_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (6, 6)).mono (by decide +kernel) + · exact finite_row_works_551_i6.mono (by decide +kernel) + +theorem finite_row_works_551_i5 : FiniteTemplate HasSnaky 6 required_551_i5 envelope_551_i5 := by + refine finite_compose HasSnaky 5 childrenC_551_i5 childrenD_551_i5 finite_children_work_551_i5 (7, 3) + required_551_i5 envelope_551_i5 pivot_mem_551_i5 child_required_sub_551_i5 child_envelope_sub_551_i5 ?_ + intro b hb + exact common_sub_551_i5 (mem_commonEnvelope childrenD_551_i5 b hb) + +theorem finite_children_work_551_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_551_i4 j) (childrenD_551_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (6, 6)).mono (by decide +kernel) + · exact finite_row_works_551_i5.mono (by decide +kernel) + +theorem finite_row_works_551_i4 : FiniteTemplate HasSnaky 7 required_551_i4 envelope_551_i4 := by + refine finite_compose HasSnaky 6 childrenC_551_i4 childrenD_551_i4 finite_children_work_551_i4 (5, 3) + required_551_i4 envelope_551_i4 pivot_mem_551_i4 child_required_sub_551_i4 child_envelope_sub_551_i4 ?_ + intro b hb + exact common_sub_551_i4 (mem_commonEnvelope childrenD_551_i4 b hb) + +theorem finite_children_work_551_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_551_i3 j) (childrenD_551_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (2, 5)).mono (by decide +kernel) + · exact finite_row_works_551_i4.mono (by decide +kernel) + +theorem finite_row_works_551_i3 : FiniteTemplate HasSnaky 8 required_551_i3 envelope_551_i3 := by + refine finite_compose HasSnaky 7 childrenC_551_i3 childrenD_551_i3 finite_children_work_551_i3 (2, 5) + required_551_i3 envelope_551_i3 pivot_mem_551_i3 child_required_sub_551_i3 child_envelope_sub_551_i3 ?_ + intro b hb + exact common_sub_551_i3 (mem_commonEnvelope childrenD_551_i3 b hb) + +theorem finite_children_work_551_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_551_i2 j) (childrenD_551_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (6, 3)).mono (by decide +kernel) + · exact finite_row_works_551_i3.mono (by decide +kernel) + +theorem finite_row_works_551_i2 : FiniteTemplate HasSnaky 9 required_551_i2 envelope_551_i2 := by + refine finite_compose HasSnaky 8 childrenC_551_i2 childrenD_551_i2 finite_children_work_551_i2 (5, 6) + required_551_i2 envelope_551_i2 pivot_mem_551_i2 child_required_sub_551_i2 child_envelope_sub_551_i2 ?_ + intro b hb + exact common_sub_551_i2 (mem_commonEnvelope childrenD_551_i2 b hb) + +theorem finite_children_work_551_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_551_i1 j) (childrenD_551_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 0 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_84 0 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 1 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_551_i2.mono (by decide +kernel) + +theorem finite_row_works_551_i1 : FiniteTemplate HasSnaky 10 required_551_i1 envelope_551_i1 := by + refine finite_compose HasSnaky 9 childrenC_551_i1 childrenD_551_i1 finite_children_work_551_i1 (6, 6) + required_551_i1 envelope_551_i1 pivot_mem_551_i1 child_required_sub_551_i1 child_envelope_sub_551_i1 ?_ + intro b hb + exact common_sub_551_i1 (mem_commonEnvelope childrenD_551_i1 b hb) + +theorem finite_children_work_551_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_551_i0 j) (childrenD_551_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 4 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_63 4 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_551_i1.mono (by decide +kernel) + +theorem finite_row_works_551_i0 : FiniteTemplate HasSnaky 11 required_551_i0 envelope_551_i0 := by + refine finite_compose HasSnaky 10 childrenC_551_i0 childrenD_551_i0 finite_children_work_551_i0 (6, 3) + required_551_i0 envelope_551_i0 pivot_mem_551_i0 child_required_sub_551_i0 child_envelope_sub_551_i0 ?_ + intro b hb + exact common_sub_551_i0 (mem_commonEnvelope childrenD_551_i0 b hb) + +theorem finite_children_work_551 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_551 j) (childrenD_551 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 3 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_523 0 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_551_i0.mono (by decide +kernel) + +theorem finite_row_works_551 : FiniteTemplate HasSnaky 12 required_551 envelope_551 := by + refine finite_compose HasSnaky 11 childrenC_551 childrenD_551 finite_children_work_551 (6, 4) + required_551 envelope_551 pivot_mem_551 child_required_sub_551 child_envelope_sub_551 ?_ + intro b hb + exact common_sub_551 (mem_commonEnvelope childrenD_551 b hb) + +theorem finite_children_work_571_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_571_i1 j) (childrenD_571_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_287 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_288 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_345 0 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_457 1 (2, 5)).mono (by decide +kernel) + +theorem finite_row_works_571_i1 : FiniteTemplate HasSnaky 10 required_571_i1 envelope_571_i1 := by + refine finite_compose HasSnaky 9 childrenC_571_i1 childrenD_571_i1 finite_children_work_571_i1 (5, 6) + required_571_i1 envelope_571_i1 pivot_mem_571_i1 child_required_sub_571_i1 child_envelope_sub_571_i1 ?_ + intro b hb + exact common_sub_571_i1 (mem_commonEnvelope childrenD_571_i1 b hb) + +theorem finite_children_work_571_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_571_i0 j) (childrenD_571_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 7 (4, 7)).mono (by decide +kernel) + · exact finite_row_works_571_i1.mono (by decide +kernel) + +theorem finite_row_works_571_i0 : FiniteTemplate HasSnaky 11 required_571_i0 envelope_571_i0 := by + refine finite_compose HasSnaky 10 childrenC_571_i0 childrenD_571_i0 finite_children_work_571_i0 (4, 7) + required_571_i0 envelope_571_i0 pivot_mem_571_i0 child_required_sub_571_i0 child_envelope_sub_571_i0 ?_ + intro b hb + exact common_sub_571_i0 (mem_commonEnvelope childrenD_571_i0 b hb) + +theorem finite_children_work_571_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_571_i3 j) (childrenD_571_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_446 4 (3, 9)).mono (by decide +kernel) + +theorem finite_row_works_571_i3 : FiniteTemplate HasSnaky 8 required_571_i3 envelope_571_i3 := by + refine finite_compose HasSnaky 7 childrenC_571_i3 childrenD_571_i3 finite_children_work_571_i3 (4, 3) + required_571_i3 envelope_571_i3 pivot_mem_571_i3 child_required_sub_571_i3 child_envelope_sub_571_i3 ?_ + intro b hb + exact common_sub_571_i3 (mem_commonEnvelope childrenD_571_i3 b hb) + +theorem finite_children_work_571_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_571_i2 j) (childrenD_571_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (4, 7)).mono (by decide +kernel) + · exact finite_row_works_571_i3.mono (by decide +kernel) + +theorem finite_row_works_571_i2 : FiniteTemplate HasSnaky 9 required_571_i2 envelope_571_i2 := by + refine finite_compose HasSnaky 8 childrenC_571_i2 childrenD_571_i2 finite_children_work_571_i2 (4, 5) + required_571_i2 envelope_571_i2 pivot_mem_571_i2 child_required_sub_571_i2 child_envelope_sub_571_i2 ?_ + intro b hb + exact common_sub_571_i2 (mem_commonEnvelope childrenD_571_i2 b hb) + +theorem finite_children_work_571_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_571_i5 j) (childrenD_571_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_283 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_571_i5 : FiniteTemplate HasSnaky 7 required_571_i5 envelope_571_i5 := by + refine finite_compose HasSnaky 6 childrenC_571_i5 childrenD_571_i5 finite_children_work_571_i5 (4, 3) + required_571_i5 envelope_571_i5 pivot_mem_571_i5 child_required_sub_571_i5 child_envelope_sub_571_i5 ?_ + intro b hb + exact common_sub_571_i5 (mem_commonEnvelope childrenD_571_i5 b hb) + +theorem finite_children_work_571_i4 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_571_i4 j) (childrenD_571_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (4, 7)).mono (by decide +kernel) + · exact finite_row_works_571_i5.mono (by decide +kernel) + +theorem finite_row_works_571_i4 : FiniteTemplate HasSnaky 8 required_571_i4 envelope_571_i4 := by + refine finite_compose HasSnaky 7 childrenC_571_i4 childrenD_571_i4 finite_children_work_571_i4 (4, 5) + required_571_i4 envelope_571_i4 pivot_mem_571_i4 child_required_sub_571_i4 child_envelope_sub_571_i4 ?_ + intro b hb + exact common_sub_571_i4 (mem_commonEnvelope childrenD_571_i4 b hb) + +theorem finite_children_work_571_i9 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_571_i9 j) (childrenD_571_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_29 1 (2, 3)).mono (by decide +kernel) + +theorem finite_row_works_571_i9 : FiniteTemplate HasSnaky 4 required_571_i9 envelope_571_i9 := by + refine finite_compose HasSnaky 3 childrenC_571_i9 childrenD_571_i9 finite_children_work_571_i9 (5, 3) + required_571_i9 envelope_571_i9 pivot_mem_571_i9 child_required_sub_571_i9 child_envelope_sub_571_i9 ?_ + intro b hb + exact common_sub_571_i9 (mem_commonEnvelope childrenD_571_i9 b hb) + +theorem finite_children_work_571_i8 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_571_i8 j) (childrenD_571_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (4, 7)).mono (by decide +kernel) + · exact finite_row_works_571_i9.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_446 4 (3, 9)).mono (by decide +kernel) + +theorem finite_row_works_571_i8 : FiniteTemplate HasSnaky 8 required_571_i8 envelope_571_i8 := by + refine finite_compose HasSnaky 7 childrenC_571_i8 childrenD_571_i8 finite_children_work_571_i8 (4, 3) + required_571_i8 envelope_571_i8 pivot_mem_571_i8 child_required_sub_571_i8 child_envelope_sub_571_i8 ?_ + intro b hb + exact common_sub_571_i8 (mem_commonEnvelope childrenD_571_i8 b hb) + +theorem finite_children_work_571_i7 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_571_i7 j) (childrenD_571_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (4, 7)).mono (by decide +kernel) + · exact finite_row_works_571_i8.mono (by decide +kernel) + +theorem finite_row_works_571_i7 : FiniteTemplate HasSnaky 9 required_571_i7 envelope_571_i7 := by + refine finite_compose HasSnaky 8 childrenC_571_i7 childrenD_571_i7 finite_children_work_571_i7 (4, 5) + required_571_i7 envelope_571_i7 pivot_mem_571_i7 child_required_sub_571_i7 child_envelope_sub_571_i7 ?_ + intro b hb + exact common_sub_571_i7 (mem_commonEnvelope childrenD_571_i7 b hb) + +theorem finite_children_work_571_i6 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_571_i6 j) (childrenD_571_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_571_i7.mono (by decide +kernel) + +theorem finite_row_works_571_i6 : FiniteTemplate HasSnaky 10 required_571_i6 envelope_571_i6 := by + refine finite_compose HasSnaky 9 childrenC_571_i6 childrenD_571_i6 finite_children_work_571_i6 (2, 3) + required_571_i6 envelope_571_i6 pivot_mem_571_i6 child_required_sub_571_i6 child_envelope_sub_571_i6 ?_ + intro b hb + exact common_sub_571_i6 (mem_commonEnvelope childrenD_571_i6 b hb) + +theorem finite_children_work_571 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_571 j) (childrenD_571 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_250 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_569 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_571_i0.mono (by decide +kernel) + · exact finite_row_works_571_i2.mono (by decide +kernel) + · exact finite_row_works_571_i4.mono (by decide +kernel) + · exact finite_row_works_570.mono (by decide +kernel) + · exact finite_row_works_571_i6.mono (by decide +kernel) + +theorem finite_row_works_571 : FiniteTemplate HasSnaky 12 required_571 envelope_571 := by + refine finite_compose HasSnaky 11 childrenC_571 childrenD_571 finite_children_work_571 (4, 4) + required_571 envelope_571 pivot_mem_571 child_required_sub_571 child_envelope_sub_571 ?_ + intro b hb + exact common_sub_571 (mem_commonEnvelope childrenD_571 b hb) + +theorem finite_children_work_587 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_587 j) (childrenD_587 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 2 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 6 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_586 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_586 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_587 : FiniteTemplate HasSnaky 12 required_587 envelope_587 := by + refine finite_compose HasSnaky 11 childrenC_587 childrenD_587 finite_children_work_587 (2, 5) + required_587 envelope_587 pivot_mem_587 child_required_sub_587 child_envelope_sub_587 ?_ + intro b hb + exact common_sub_587 (mem_commonEnvelope childrenD_587 b hb) + +theorem finite_children_work_588 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_588 j) (childrenD_588 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_42 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_289 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_291 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_586 1 (2, 0)).mono (by decide +kernel) + +theorem finite_row_works_588 : FiniteTemplate HasSnaky 12 required_588 envelope_588 := by + refine finite_compose HasSnaky 11 childrenC_588 childrenD_588 finite_children_work_588 (4, 3) + required_588 envelope_588 pivot_mem_588 child_required_sub_588 child_envelope_sub_588 ?_ + intro b hb + exact common_sub_588 (mem_commonEnvelope childrenD_588 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height12Part03.lean b/lean/snaky/FiniteCards/Height12Part03.lean new file mode 100644 index 0000000..a1f3c72 --- /dev/null +++ b/lean/snaky/FiniteCards/Height12Part03.lean @@ -0,0 +1,325 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height05Part01 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part05 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part04 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part05 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part04 +import FiniteCards.Height10Part05 +import FiniteCards.Height11Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_599_i6 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_599_i6 j) (childrenD_599_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_64 0 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_599_i6 : FiniteTemplate HasSnaky 4 required_599_i6 envelope_599_i6 := by + refine finite_compose HasSnaky 3 childrenC_599_i6 childrenD_599_i6 finite_children_work_599_i6 (5, 6) + required_599_i6 envelope_599_i6 pivot_mem_599_i6 child_required_sub_599_i6 child_envelope_sub_599_i6 ?_ + intro b hb + exact common_sub_599_i6 (mem_commonEnvelope childrenD_599_i6 b hb) + +theorem finite_children_work_599_i8 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_599_i8 j) (childrenD_599_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 0 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_599_i8 : FiniteTemplate HasSnaky 4 required_599_i8 envelope_599_i8 := by + refine finite_compose HasSnaky 3 childrenC_599_i8 childrenD_599_i8 finite_children_work_599_i8 (4, 4) + required_599_i8 envelope_599_i8 pivot_mem_599_i8 child_required_sub_599_i8 child_envelope_sub_599_i8 ?_ + intro b hb + exact common_sub_599_i8 (mem_commonEnvelope childrenD_599_i8 b hb) + +theorem finite_children_work_599_i7 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_599_i7 j) (childrenD_599_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_16 3 (3, 5)).mono (by decide +kernel) + · exact finite_row_works_599_i8.mono (by decide +kernel) + +theorem finite_row_works_599_i7 : FiniteTemplate HasSnaky 5 required_599_i7 envelope_599_i7 := by + refine finite_compose HasSnaky 4 childrenC_599_i7 childrenD_599_i7 finite_children_work_599_i7 (6, 5) + required_599_i7 envelope_599_i7 pivot_mem_599_i7 child_required_sub_599_i7 child_envelope_sub_599_i7 ?_ + intro b hb + exact common_sub_599_i7 (mem_commonEnvelope childrenD_599_i7 b hb) + +theorem finite_children_work_599_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_599_i5 j) (childrenD_599_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_41 1 (2, 4)).mono (by decide +kernel) + · exact finite_row_works_599_i6.mono (by decide +kernel) + · exact finite_row_works_599_i7.mono (by decide +kernel) + +theorem finite_row_works_599_i5 : FiniteTemplate HasSnaky 6 required_599_i5 envelope_599_i5 := by + refine finite_compose HasSnaky 5 childrenC_599_i5 childrenD_599_i5 finite_children_work_599_i5 (5, 5) + required_599_i5 envelope_599_i5 pivot_mem_599_i5 child_required_sub_599_i5 child_envelope_sub_599_i5 ?_ + intro b hb + exact common_sub_599_i5 (mem_commonEnvelope childrenD_599_i5 b hb) + +theorem finite_children_work_599_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_599_i4 j) (childrenD_599_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (3, 2)).mono (by decide +kernel) + · exact finite_row_works_599_i5.mono (by decide +kernel) + +theorem finite_row_works_599_i4 : FiniteTemplate HasSnaky 7 required_599_i4 envelope_599_i4 := by + refine finite_compose HasSnaky 6 childrenC_599_i4 childrenD_599_i4 finite_children_work_599_i4 (2, 5) + required_599_i4 envelope_599_i4 pivot_mem_599_i4 child_required_sub_599_i4 child_envelope_sub_599_i4 ?_ + intro b hb + exact common_sub_599_i4 (mem_commonEnvelope childrenD_599_i4 b hb) + +theorem finite_children_work_599_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_599_i3 j) (childrenD_599_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 2)).mono (by decide +kernel) + · exact finite_row_works_599_i4.mono (by decide +kernel) + +theorem finite_row_works_599_i3 : FiniteTemplate HasSnaky 8 required_599_i3 envelope_599_i3 := by + refine finite_compose HasSnaky 7 childrenC_599_i3 childrenD_599_i3 finite_children_work_599_i3 (4, 5) + required_599_i3 envelope_599_i3 pivot_mem_599_i3 child_required_sub_599_i3 child_envelope_sub_599_i3 ?_ + intro b hb + exact common_sub_599_i3 (mem_commonEnvelope childrenD_599_i3 b hb) + +theorem finite_children_work_599_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_599_i2 j) (childrenD_599_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_251 7 (4, 5)).mono (by decide +kernel) + · exact finite_row_works_599_i3.mono (by decide +kernel) + +theorem finite_row_works_599_i2 : FiniteTemplate HasSnaky 9 required_599_i2 envelope_599_i2 := by + refine finite_compose HasSnaky 8 childrenC_599_i2 childrenD_599_i2 finite_children_work_599_i2 (3, 2) + required_599_i2 envelope_599_i2 pivot_mem_599_i2 child_required_sub_599_i2 child_envelope_sub_599_i2 ?_ + intro b hb + exact common_sub_599_i2 (mem_commonEnvelope childrenD_599_i2 b hb) + +theorem finite_children_work_599_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_599_i1 j) (childrenD_599_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_27 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_48 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_63 2 (4, 2)).mono (by decide +kernel) + · exact finite_row_works_599_i2.mono (by decide +kernel) + +theorem finite_row_works_599_i1 : FiniteTemplate HasSnaky 10 required_599_i1 envelope_599_i1 := by + refine finite_compose HasSnaky 9 childrenC_599_i1 childrenD_599_i1 finite_children_work_599_i1 (3, 5) + required_599_i1 envelope_599_i1 pivot_mem_599_i1 child_required_sub_599_i1 child_envelope_sub_599_i1 ?_ + intro b hb + exact common_sub_599_i1 (mem_commonEnvelope childrenD_599_i1 b hb) + +theorem finite_children_work_599_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_599_i0 j) (childrenD_599_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_599_i1.mono (by decide +kernel) + +theorem finite_row_works_599_i0 : FiniteTemplate HasSnaky 11 required_599_i0 envelope_599_i0 := by + refine finite_compose HasSnaky 10 childrenC_599_i0 childrenD_599_i0 finite_children_work_599_i0 (3, 4) + required_599_i0 envelope_599_i0 pivot_mem_599_i0 child_required_sub_599_i0 child_envelope_sub_599_i0 ?_ + intro b hb + exact common_sub_599_i0 (mem_commonEnvelope childrenD_599_i0 b hb) + +theorem finite_children_work_599 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_599 j) (childrenD_599 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_107 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_163 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_401 4 (0, 7)).mono (by decide +kernel) + · exact finite_row_works_599_i0.mono (by decide +kernel) + +theorem finite_row_works_599 : FiniteTemplate HasSnaky 12 required_599 envelope_599 := by + refine finite_compose HasSnaky 11 childrenC_599 childrenD_599 finite_children_work_599 (4, 3) + required_599 envelope_599 pivot_mem_599 child_required_sub_599 child_envelope_sub_599 ?_ + intro b hb + exact common_sub_599 (mem_commonEnvelope childrenD_599 b hb) + +theorem finite_children_work_605_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_605_i0 j) (childrenD_605_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_115 2 (4, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_585 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_604 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_605_i0 : FiniteTemplate HasSnaky 11 required_605_i0 envelope_605_i0 := by + refine finite_compose HasSnaky 10 childrenC_605_i0 childrenD_605_i0 finite_children_work_605_i0 (1, 3) + required_605_i0 envelope_605_i0 pivot_mem_605_i0 child_required_sub_605_i0 child_envelope_sub_605_i0 ?_ + intro b hb + exact common_sub_605_i0 (mem_commonEnvelope childrenD_605_i0 b hb) + +theorem finite_children_work_605 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_605 j) (childrenD_605 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_135 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_182 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_605_i0.mono (by decide +kernel) + +theorem finite_row_works_605 : FiniteTemplate HasSnaky 12 required_605 envelope_605 := by + refine finite_compose HasSnaky 11 childrenC_605 childrenD_605 finite_children_work_605 (4, 3) + required_605 envelope_605 pivot_mem_605 child_required_sub_605 child_envelope_sub_605 ?_ + intro b hb + exact common_sub_605 (mem_commonEnvelope childrenD_605 b hb) + +theorem finite_children_work_618_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_618_i2 j) (childrenD_618_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 6 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_378 1 (3, 3)).mono (by decide +kernel) + +theorem finite_row_works_618_i2 : FiniteTemplate HasSnaky 7 required_618_i2 envelope_618_i2 := by + refine finite_compose HasSnaky 6 childrenC_618_i2 childrenD_618_i2 finite_children_work_618_i2 (3, 5) + required_618_i2 envelope_618_i2 pivot_mem_618_i2 child_required_sub_618_i2 child_envelope_sub_618_i2 ?_ + intro b hb + exact common_sub_618_i2 (mem_commonEnvelope childrenD_618_i2 b hb) + +theorem finite_children_work_618_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_618_i1 j) (childrenD_618_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_25 7 (6, 6)).mono (by decide +kernel) + · exact finite_row_works_618_i2.mono (by decide +kernel) + +theorem finite_row_works_618_i1 : FiniteTemplate HasSnaky 8 required_618_i1 envelope_618_i1 := by + refine finite_compose HasSnaky 7 childrenC_618_i1 childrenD_618_i1 finite_children_work_618_i1 (3, 4) + required_618_i1 envelope_618_i1 pivot_mem_618_i1 child_required_sub_618_i1 child_envelope_sub_618_i1 ?_ + intro b hb + exact common_sub_618_i1 (mem_commonEnvelope childrenD_618_i1 b hb) + +theorem finite_children_work_618_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_618_i0 j) (childrenD_618_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (6, 2)).mono (by decide +kernel) + · exact finite_row_works_618_i1.mono (by decide +kernel) + +theorem finite_row_works_618_i0 : FiniteTemplate HasSnaky 9 required_618_i0 envelope_618_i0 := by + refine finite_compose HasSnaky 8 childrenC_618_i0 childrenD_618_i0 finite_children_work_618_i0 (5, 6) + required_618_i0 envelope_618_i0 pivot_mem_618_i0 child_required_sub_618_i0 child_envelope_sub_618_i0 ?_ + intro b hb + exact common_sub_618_i0 (mem_commonEnvelope childrenD_618_i0 b hb) + +theorem finite_children_work_618_i3 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_618_i3 j) (childrenD_618_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_604 1 (2, 3)).mono (by decide +kernel) + +theorem finite_row_works_618_i3 : FiniteTemplate HasSnaky 9 required_618_i3 envelope_618_i3 := by + refine finite_compose HasSnaky 8 childrenC_618_i3 childrenD_618_i3 finite_children_work_618_i3 (5, 6) + required_618_i3 envelope_618_i3 pivot_mem_618_i3 child_required_sub_618_i3 child_envelope_sub_618_i3 ?_ + intro b hb + exact common_sub_618_i3 (mem_commonEnvelope childrenD_618_i3 b hb) + +theorem finite_children_work_618_i4 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_618_i4 j) (childrenD_618_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_171 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_577 3 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_609 6 (6, 7)).mono (by decide +kernel) + +theorem finite_row_works_618_i4 : FiniteTemplate HasSnaky 10 required_618_i4 envelope_618_i4 := by + refine finite_compose HasSnaky 9 childrenC_618_i4 childrenD_618_i4 finite_children_work_618_i4 (5, 6) + required_618_i4 envelope_618_i4 pivot_mem_618_i4 child_required_sub_618_i4 child_envelope_sub_618_i4 ?_ + intro b hb + exact common_sub_618_i4 (mem_commonEnvelope childrenD_618_i4 b hb) + +theorem finite_children_work_618_i5 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_618_i5 j) (childrenD_618_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_256 5 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_577 3 (3, 7)).mono (by decide +kernel) + +theorem finite_row_works_618_i5 : FiniteTemplate HasSnaky 10 required_618_i5 envelope_618_i5 := by + refine finite_compose HasSnaky 9 childrenC_618_i5 childrenD_618_i5 finite_children_work_618_i5 (5, 6) + required_618_i5 envelope_618_i5 pivot_mem_618_i5 child_required_sub_618_i5 child_envelope_sub_618_i5 ?_ + intro b hb + exact common_sub_618_i5 (mem_commonEnvelope childrenD_618_i5 b hb) + +theorem finite_children_work_618_i8 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_618_i8 j) (childrenD_618_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 6 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_113 1 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_618_i8 : FiniteTemplate HasSnaky 4 required_618_i8 envelope_618_i8 := by + refine finite_compose HasSnaky 3 childrenC_618_i8 childrenD_618_i8 finite_children_work_618_i8 (6, 4) + required_618_i8 envelope_618_i8 pivot_mem_618_i8 child_required_sub_618_i8 child_envelope_sub_618_i8 ?_ + intro b hb + exact common_sub_618_i8 (mem_commonEnvelope childrenD_618_i8 b hb) + +theorem finite_children_work_618_i7 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_618_i7 j) (childrenD_618_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (2, 4)).mono (by decide +kernel) + · exact finite_row_works_618_i8.mono (by decide +kernel) + +theorem finite_row_works_618_i7 : FiniteTemplate HasSnaky 5 required_618_i7 envelope_618_i7 := by + refine finite_compose HasSnaky 4 childrenC_618_i7 childrenD_618_i7 finite_children_work_618_i7 (3, 4) + required_618_i7 envelope_618_i7 pivot_mem_618_i7 child_required_sub_618_i7 child_envelope_sub_618_i7 ?_ + intro b hb + exact common_sub_618_i7 (mem_commonEnvelope childrenD_618_i7 b hb) + +theorem finite_children_work_618_i6 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_618_i6 j) (childrenD_618_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_80 5 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_111 1 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_616 0 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_618_i7.mono (by decide +kernel) + +theorem finite_row_works_618_i6 : FiniteTemplate HasSnaky 11 required_618_i6 envelope_618_i6 := by + refine finite_compose HasSnaky 10 childrenC_618_i6 childrenD_618_i6 finite_children_work_618_i6 (4, 4) + required_618_i6 envelope_618_i6 pivot_mem_618_i6 child_required_sub_618_i6 child_envelope_sub_618_i6 ?_ + intro b hb + exact common_sub_618_i6 (mem_commonEnvelope childrenD_618_i6 b hb) + +theorem finite_children_work_618 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_618 j) (childrenD_618 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_398 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_434 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_610 2 (6, 1)).mono (by decide +kernel) + · exact finite_row_works_618_i0.mono (by decide +kernel) + · exact finite_row_works_618_i3.mono (by decide +kernel) + · exact finite_row_works_618_i4.mono (by decide +kernel) + · exact finite_row_works_618_i5.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_615 0 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_618_i6.mono (by decide +kernel) + +theorem finite_row_works_618 : FiniteTemplate HasSnaky 12 required_618 envelope_618 := by + refine finite_compose HasSnaky 11 childrenC_618 childrenD_618 finite_children_work_618 (5, 5) + required_618 envelope_618 pivot_mem_618 child_required_sub_618 child_envelope_sub_618 ?_ + intro b hb + exact common_sub_618 (mem_commonEnvelope childrenD_618 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height12Part04.lean b/lean/snaky/FiniteCards/Height12Part04.lean new file mode 100644 index 0000000..f1f929d --- /dev/null +++ b/lean/snaky/FiniteCards/Height12Part04.lean @@ -0,0 +1,302 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height08Part03 +import FiniteCards.Height08Part04 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part08 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part05 +import FiniteCards.Height11Part02 +import FiniteCards.Height11Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_632_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_632_i2 j) (childrenD_632_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_92 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_378 1 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_632_i2 : FiniteTemplate HasSnaky 7 required_632_i2 envelope_632_i2 := by + refine finite_compose HasSnaky 6 childrenC_632_i2 childrenD_632_i2 finite_children_work_632_i2 (3, 2) + required_632_i2 envelope_632_i2 pivot_mem_632_i2 child_required_sub_632_i2 child_envelope_sub_632_i2 ?_ + intro b hb + exact common_sub_632_i2 (mem_commonEnvelope childrenD_632_i2 b hb) + +theorem finite_children_work_632_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_632_i1 j) (childrenD_632_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_82 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_632_i2.mono (by decide +kernel) + +theorem finite_row_works_632_i1 : FiniteTemplate HasSnaky 8 required_632_i1 envelope_632_i1 := by + refine finite_compose HasSnaky 7 childrenC_632_i1 childrenD_632_i1 finite_children_work_632_i1 (3, 5) + required_632_i1 envelope_632_i1 pivot_mem_632_i1 child_required_sub_632_i1 child_envelope_sub_632_i1 ?_ + intro b hb + exact common_sub_632_i1 (mem_commonEnvelope childrenD_632_i1 b hb) + +theorem finite_children_work_632_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_632_i0 j) (childrenD_632_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_294 5 (6, 2)).mono (by decide +kernel) + · exact finite_row_works_632_i1.mono (by decide +kernel) + · exact finite_row_works_631.mono (by decide +kernel) + +theorem finite_row_works_632_i0 : FiniteTemplate HasSnaky 11 required_632_i0 envelope_632_i0 := by + refine finite_compose HasSnaky 10 childrenC_632_i0 childrenD_632_i0 finite_children_work_632_i0 (3, 4) + required_632_i0 envelope_632_i0 pivot_mem_632_i0 child_required_sub_632_i0 child_envelope_sub_632_i0 ?_ + intro b hb + exact common_sub_632_i0 (mem_commonEnvelope childrenD_632_i0 b hb) + +theorem finite_children_work_632 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_632 j) (childrenD_632 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_50 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_125 3 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_454 5 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_455 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_632_i0.mono (by decide +kernel) + +theorem finite_row_works_632 : FiniteTemplate HasSnaky 12 required_632 envelope_632 := by + refine finite_compose HasSnaky 11 childrenC_632 childrenD_632 finite_children_work_632 (3, 3) + required_632 envelope_632 pivot_mem_632 child_required_sub_632 child_envelope_sub_632 ?_ + intro b hb + exact common_sub_632 (mem_commonEnvelope childrenD_632 b hb) + +theorem finite_children_work_635_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_635_i0 j) (childrenD_635_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_395 1 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_635_i0 : FiniteTemplate HasSnaky 9 required_635_i0 envelope_635_i0 := by + refine finite_compose HasSnaky 8 childrenC_635_i0 childrenD_635_i0 finite_children_work_635_i0 (2, 6) + required_635_i0 envelope_635_i0 pivot_mem_635_i0 child_required_sub_635_i0 child_envelope_sub_635_i0 ?_ + intro b hb + exact common_sub_635_i0 (mem_commonEnvelope childrenD_635_i0 b hb) + +theorem finite_children_work_635 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_635 j) (childrenD_635 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_33 6 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_589 3 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_635_i0.mono (by decide +kernel) + +theorem finite_row_works_635 : FiniteTemplate HasSnaky 12 required_635 envelope_635 := by + refine finite_compose HasSnaky 11 childrenC_635 childrenD_635 finite_children_work_635 (2, 3) + required_635 envelope_635 pivot_mem_635 child_required_sub_635 child_envelope_sub_635 ?_ + intro b hb + exact common_sub_635 (mem_commonEnvelope childrenD_635 b hb) + +theorem finite_children_work_649_i7 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_649_i7 j) (childrenD_649_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 2 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_649_i7 : FiniteTemplate HasSnaky 4 required_649_i7 envelope_649_i7 := by + refine finite_compose HasSnaky 3 childrenC_649_i7 childrenD_649_i7 finite_children_work_649_i7 (1, 3) + required_649_i7 envelope_649_i7 pivot_mem_649_i7 child_required_sub_649_i7 child_envelope_sub_649_i7 ?_ + intro b hb + exact common_sub_649_i7 (mem_commonEnvelope childrenD_649_i7 b hb) + +theorem finite_children_work_649_i6 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_649_i6 j) (childrenD_649_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (3, 6)).mono (by decide +kernel) + · exact finite_row_works_649_i7.mono (by decide +kernel) + +theorem finite_row_works_649_i6 : FiniteTemplate HasSnaky 5 required_649_i6 envelope_649_i6 := by + refine finite_compose HasSnaky 4 childrenC_649_i6 childrenD_649_i6 finite_children_work_649_i6 (2, 3) + required_649_i6 envelope_649_i6 pivot_mem_649_i6 child_required_sub_649_i6 child_envelope_sub_649_i6 ?_ + intro b hb + exact common_sub_649_i6 (mem_commonEnvelope childrenD_649_i6 b hb) + +theorem finite_children_work_649_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_649_i5 j) (childrenD_649_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (3, 3)).mono (by decide +kernel) + · exact finite_row_works_649_i6.mono (by decide +kernel) + +theorem finite_row_works_649_i5 : FiniteTemplate HasSnaky 6 required_649_i5 envelope_649_i5 := by + refine finite_compose HasSnaky 5 childrenC_649_i5 childrenD_649_i5 finite_children_work_649_i5 (3, 4) + required_649_i5 envelope_649_i5 pivot_mem_649_i5 child_required_sub_649_i5 child_envelope_sub_649_i5 ?_ + intro b hb + exact common_sub_649_i5 (mem_commonEnvelope childrenD_649_i5 b hb) + +theorem finite_children_work_649_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_649_i4 j) (childrenD_649_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 5 (5, 5)).mono (by decide +kernel) + · exact finite_row_works_649_i5.mono (by decide +kernel) + +theorem finite_row_works_649_i4 : FiniteTemplate HasSnaky 7 required_649_i4 envelope_649_i4 := by + refine finite_compose HasSnaky 6 childrenC_649_i4 childrenD_649_i4 finite_children_work_649_i4 (2, 6) + required_649_i4 envelope_649_i4 pivot_mem_649_i4 child_required_sub_649_i4 child_envelope_sub_649_i4 ?_ + intro b hb + exact common_sub_649_i4 (mem_commonEnvelope childrenD_649_i4 b hb) + +theorem finite_children_work_649_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_649_i3 j) (childrenD_649_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (4, 6)).mono (by decide +kernel) + · exact finite_row_works_649_i4.mono (by decide +kernel) + +theorem finite_row_works_649_i3 : FiniteTemplate HasSnaky 8 required_649_i3 envelope_649_i3 := by + refine finite_compose HasSnaky 7 childrenC_649_i3 childrenD_649_i3 finite_children_work_649_i3 (3, 3) + required_649_i3 envelope_649_i3 pivot_mem_649_i3 child_required_sub_649_i3 child_envelope_sub_649_i3 ?_ + intro b hb + exact common_sub_649_i3 (mem_commonEnvelope childrenD_649_i3 b hb) + +theorem finite_children_work_649_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_649_i2 j) (childrenD_649_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (4, 3)).mono (by decide +kernel) + · exact finite_row_works_649_i3.mono (by decide +kernel) + +theorem finite_row_works_649_i2 : FiniteTemplate HasSnaky 9 required_649_i2 envelope_649_i2 := by + refine finite_compose HasSnaky 8 childrenC_649_i2 childrenD_649_i2 finite_children_work_649_i2 (3, 6) + required_649_i2 envelope_649_i2 pivot_mem_649_i2 child_required_sub_649_i2 child_envelope_sub_649_i2 ?_ + intro b hb + exact common_sub_649_i2 (mem_commonEnvelope childrenD_649_i2 b hb) + +theorem finite_children_work_649_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_649_i1 j) (childrenD_649_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_84 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 1 (3, 3)).mono (by decide +kernel) + · exact finite_row_works_649_i2.mono (by decide +kernel) + +theorem finite_row_works_649_i1 : FiniteTemplate HasSnaky 10 required_649_i1 envelope_649_i1 := by + refine finite_compose HasSnaky 9 childrenC_649_i1 childrenD_649_i1 finite_children_work_649_i1 (4, 6) + required_649_i1 envelope_649_i1 pivot_mem_649_i1 child_required_sub_649_i1 child_envelope_sub_649_i1 ?_ + intro b hb + exact common_sub_649_i1 (mem_commonEnvelope childrenD_649_i1 b hb) + +theorem finite_children_work_649_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_649_i0 j) (childrenD_649_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_63 4 (3, 6)).mono (by decide +kernel) + · exact finite_row_works_649_i1.mono (by decide +kernel) + +theorem finite_row_works_649_i0 : FiniteTemplate HasSnaky 11 required_649_i0 envelope_649_i0 := by + refine finite_compose HasSnaky 10 childrenC_649_i0 childrenD_649_i0 finite_children_work_649_i0 (4, 3) + required_649_i0 envelope_649_i0 pivot_mem_649_i0 child_required_sub_649_i0 child_envelope_sub_649_i0 ?_ + intro b hb + exact common_sub_649_i0 (mem_commonEnvelope childrenD_649_i0 b hb) + +theorem finite_children_work_649 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_649 j) (childrenD_649 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_523 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_649_i0.mono (by decide +kernel) + +theorem finite_row_works_649 : FiniteTemplate HasSnaky 12 required_649 envelope_649 := by + refine finite_compose HasSnaky 11 childrenC_649 childrenD_649 finite_children_work_649 (4, 4) + required_649 envelope_649 pivot_mem_649 child_required_sub_649 child_envelope_sub_649 ?_ + intro b hb + exact common_sub_649 (mem_commonEnvelope childrenD_649 b hb) + +theorem finite_children_work_654_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_654_i1 j) (childrenD_654_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_502 3 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_654_i1 : FiniteTemplate HasSnaky 6 required_654_i1 envelope_654_i1 := by + refine finite_compose HasSnaky 5 childrenC_654_i1 childrenD_654_i1 finite_children_work_654_i1 (4, 6) + required_654_i1 envelope_654_i1 pivot_mem_654_i1 child_required_sub_654_i1 child_envelope_sub_654_i1 ?_ + intro b hb + exact common_sub_654_i1 (mem_commonEnvelope childrenD_654_i1 b hb) + +theorem finite_children_work_654_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_654_i0 j) (childrenD_654_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_651 6 (7, 8)).mono (by decide +kernel) + · exact finite_row_works_654_i1.mono (by decide +kernel) + +theorem finite_row_works_654_i0 : FiniteTemplate HasSnaky 9 required_654_i0 envelope_654_i0 := by + refine finite_compose HasSnaky 8 childrenC_654_i0 childrenD_654_i0 finite_children_work_654_i0 (4, 5) + required_654_i0 envelope_654_i0 pivot_mem_654_i0 child_required_sub_654_i0 child_envelope_sub_654_i0 ?_ + intro b hb + exact common_sub_654_i0 (mem_commonEnvelope childrenD_654_i0 b hb) + +theorem finite_children_work_654 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_654 j) (childrenD_654 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_248 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_300 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_436 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_449 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_509 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_510 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_653 3 (0, 7)).mono (by decide +kernel) + · exact finite_row_works_654_i0.mono (by decide +kernel) + +theorem finite_row_works_654 : FiniteTemplate HasSnaky 12 required_654 envelope_654 := by + refine finite_compose HasSnaky 11 childrenC_654 childrenD_654 finite_children_work_654 (4, 4) + required_654 envelope_654 pivot_mem_654 child_required_sub_654 child_envelope_sub_654 ?_ + intro b hb + exact common_sub_654 (mem_commonEnvelope childrenD_654 b hb) + +theorem finite_children_work_677 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_677 j) (childrenD_677 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_33 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_589 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_676 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_677 : FiniteTemplate HasSnaky 12 required_677 envelope_677 := by + refine finite_compose HasSnaky 11 childrenC_677 childrenD_677 finite_children_work_677 (3, 3) + required_677 envelope_677 pivot_mem_677 child_required_sub_677 child_envelope_sub_677 ?_ + intro b hb + exact common_sub_677 (mem_commonEnvelope childrenD_677 b hb) + +theorem finite_children_work_687 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_687 j) (childrenD_687 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_324 2 (6, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_685 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_686 0 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_687 : FiniteTemplate HasSnaky 12 required_687 envelope_687 := by + refine finite_compose HasSnaky 11 childrenC_687 childrenD_687 finite_children_work_687 (5, 5) + required_687 envelope_687 pivot_mem_687 child_required_sub_687 child_envelope_sub_687 ?_ + intro b hb + exact common_sub_687 (mem_commonEnvelope childrenD_687 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height12Part05.lean b/lean/snaky/FiniteCards/Height12Part05.lean new file mode 100644 index 0000000..c5736f6 --- /dev/null +++ b/lean/snaky/FiniteCards/Height12Part05.lean @@ -0,0 +1,287 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part05 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part04 +import FiniteCards.Height07Part05 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part03 +import FiniteCards.Height09Part07 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part02 +import FiniteCards.Height10Part04 +import FiniteCards.Height10Part06 +import FiniteCards.Height10Part07 +import FiniteCards.Height11Part02 +import FiniteCards.Height11Part05 +import FiniteCards.Height11Part06 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_715_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_715_i1 j) (childrenD_715_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 6 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 0 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_111 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_394 1 (2, 4)).mono (by decide +kernel) + +theorem finite_row_works_715_i1 : FiniteTemplate HasSnaky 8 required_715_i1 envelope_715_i1 := by + refine finite_compose HasSnaky 7 childrenC_715_i1 childrenD_715_i1 finite_children_work_715_i1 (4, 4) + required_715_i1 envelope_715_i1 pivot_mem_715_i1 child_required_sub_715_i1 child_envelope_sub_715_i1 ?_ + intro b hb + exact common_sub_715_i1 (mem_commonEnvelope childrenD_715_i1 b hb) + +theorem finite_children_work_715_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_715_i0 j) (childrenD_715_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 1 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 1 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_134 2 (6, 3)).mono (by decide +kernel) + · exact finite_row_works_715_i1.mono (by decide +kernel) + +theorem finite_row_works_715_i0 : FiniteTemplate HasSnaky 9 required_715_i0 envelope_715_i0 := by + refine finite_compose HasSnaky 8 childrenC_715_i0 childrenD_715_i0 finite_children_work_715_i0 (3, 5) + required_715_i0 envelope_715_i0 pivot_mem_715_i0 child_required_sub_715_i0 child_envelope_sub_715_i0 ?_ + intro b hb + exact common_sub_715_i0 (mem_commonEnvelope childrenD_715_i0 b hb) + +theorem finite_children_work_715_i4 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_715_i4 j) (childrenD_715_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_30 3 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_110 0 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_296 1 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_511 0 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_715_i4 : FiniteTemplate HasSnaky 8 required_715_i4 envelope_715_i4 := by + refine finite_compose HasSnaky 7 childrenC_715_i4 childrenD_715_i4 finite_children_work_715_i4 (7, 6) + required_715_i4 envelope_715_i4 pivot_mem_715_i4 child_required_sub_715_i4 child_envelope_sub_715_i4 ?_ + intro b hb + exact common_sub_715_i4 (mem_commonEnvelope childrenD_715_i4 b hb) + +theorem finite_children_work_715_i3 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_715_i3 j) (childrenD_715_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 1 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_74 1 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_325 0 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_715_i4.mono (by decide +kernel) + +theorem finite_row_works_715_i3 : FiniteTemplate HasSnaky 10 required_715_i3 envelope_715_i3 := by + refine finite_compose HasSnaky 9 childrenC_715_i3 childrenD_715_i3 finite_children_work_715_i3 (7, 5) + required_715_i3 envelope_715_i3 pivot_mem_715_i3 child_required_sub_715_i3 child_envelope_sub_715_i3 ?_ + intro b hb + exact common_sub_715_i3 (mem_commonEnvelope childrenD_715_i3 b hb) + +theorem finite_children_work_715_i2 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_715_i2 j) (childrenD_715_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_361 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_408 5 (8, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_621 7 (8, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_714 1 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_715_i3.mono (by decide +kernel) + +theorem finite_row_works_715_i2 : FiniteTemplate HasSnaky 11 required_715_i2 envelope_715_i2 := by + refine finite_compose HasSnaky 10 childrenC_715_i2 childrenD_715_i2 finite_children_work_715_i2 (4, 6) + required_715_i2 envelope_715_i2 pivot_mem_715_i2 child_required_sub_715_i2 child_envelope_sub_715_i2 ?_ + intro b hb + exact common_sub_715_i2 (mem_commonEnvelope childrenD_715_i2 b hb) + +theorem finite_children_work_715 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_715 j) (childrenD_715 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_523 4 (2, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_532 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_536 6 (8, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_545 6 (6, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_655 4 (2, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_664 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_715_i0.mono (by decide +kernel) + · exact finite_row_works_715_i2.mono (by decide +kernel) + +theorem finite_row_works_715 : FiniteTemplate HasSnaky 12 required_715 envelope_715 := by + refine finite_compose HasSnaky 11 childrenC_715 childrenD_715 finite_children_work_715 (5, 6) + required_715 envelope_715 pivot_mem_715 child_required_sub_715 child_envelope_sub_715 ?_ + intro b hb + exact common_sub_715 (mem_commonEnvelope childrenD_715 b hb) + +theorem finite_children_work_717 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_717 j) (childrenD_717 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_192 1 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_192 7 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_550 2 (10, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_550 4 (0, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_578 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_578 6 (7, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_622 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_622 7 (9, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_716 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_716 6 (10, 11)).mono (by decide +kernel) + +theorem finite_row_works_717 : FiniteTemplate HasSnaky 12 required_717 envelope_717 := by + refine finite_compose HasSnaky 11 childrenC_717 childrenD_717 finite_children_work_717 (6, 6) + required_717 envelope_717 pivot_mem_717 child_required_sub_717 child_envelope_sub_717 ?_ + intro b hb + exact common_sub_717 (mem_commonEnvelope childrenD_717 b hb) + +theorem finite_children_work_723_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_723_i0 j) (childrenD_723_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_46 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_321 0 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_723_i0 : FiniteTemplate HasSnaky 9 required_723_i0 envelope_723_i0 := by + refine finite_compose HasSnaky 8 childrenC_723_i0 childrenD_723_i0 finite_children_work_723_i0 (4, 5) + required_723_i0 envelope_723_i0 pivot_mem_723_i0 child_required_sub_723_i0 child_envelope_sub_723_i0 ?_ + intro b hb + exact common_sub_723_i0 (mem_commonEnvelope childrenD_723_i0 b hb) + +theorem finite_children_work_723_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_723_i1 j) (childrenD_723_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 6 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_310 1 (1, 4)).mono (by decide +kernel) + +theorem finite_row_works_723_i1 : FiniteTemplate HasSnaky 4 required_723_i1 envelope_723_i1 := by + refine finite_compose HasSnaky 3 childrenC_723_i1 childrenD_723_i1 finite_children_work_723_i1 (2, 4) + required_723_i1 envelope_723_i1 pivot_mem_723_i1 child_required_sub_723_i1 child_envelope_sub_723_i1 ?_ + intro b hb + exact common_sub_723_i1 (mem_commonEnvelope childrenD_723_i1 b hb) + +theorem finite_children_work_723_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_723_i4 j) (childrenD_723_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 6 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_90 3 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_99 5 (6, 4)).mono (by decide +kernel) + +theorem finite_row_works_723_i4 : FiniteTemplate HasSnaky 5 required_723_i4 envelope_723_i4 := by + refine finite_compose HasSnaky 4 childrenC_723_i4 childrenD_723_i4 finite_children_work_723_i4 (3, 4) + required_723_i4 envelope_723_i4 pivot_mem_723_i4 child_required_sub_723_i4 child_envelope_sub_723_i4 ?_ + intro b hb + exact common_sub_723_i4 (mem_commonEnvelope childrenD_723_i4 b hb) + +theorem finite_children_work_723_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_723_i3 j) (childrenD_723_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 5 (5, 4)).mono (by decide +kernel) + · exact finite_row_works_723_i4.mono (by decide +kernel) + +theorem finite_row_works_723_i3 : FiniteTemplate HasSnaky 7 required_723_i3 envelope_723_i3 := by + refine finite_compose HasSnaky 6 childrenC_723_i3 childrenD_723_i3 finite_children_work_723_i3 (3, 7) + required_723_i3 envelope_723_i3 pivot_mem_723_i3 child_required_sub_723_i3 child_envelope_sub_723_i3 ?_ + intro b hb + exact common_sub_723_i3 (mem_commonEnvelope childrenD_723_i3 b hb) + +theorem finite_children_work_723_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_723_i5 j) (childrenD_723_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_82 0 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_176 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_218 1 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_369 6 (6, 10)).mono (by decide +kernel) + +theorem finite_row_works_723_i5 : FiniteTemplate HasSnaky 7 required_723_i5 envelope_723_i5 := by + refine finite_compose HasSnaky 6 childrenC_723_i5 childrenD_723_i5 finite_children_work_723_i5 (5, 6) + required_723_i5 envelope_723_i5 pivot_mem_723_i5 child_required_sub_723_i5 child_envelope_sub_723_i5 ?_ + intro b hb + exact common_sub_723_i5 (mem_commonEnvelope childrenD_723_i5 b hb) + +theorem finite_children_work_723_i7 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_723_i7 j) (childrenD_723_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_145 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 3 (2, 7)).mono (by decide +kernel) + +theorem finite_row_works_723_i7 : FiniteTemplate HasSnaky 6 required_723_i7 envelope_723_i7 := by + refine finite_compose HasSnaky 5 childrenC_723_i7 childrenD_723_i7 finite_children_work_723_i7 (3, 4) + required_723_i7 envelope_723_i7 pivot_mem_723_i7 child_required_sub_723_i7 child_envelope_sub_723_i7 ?_ + intro b hb + exact common_sub_723_i7 (mem_commonEnvelope childrenD_723_i7 b hb) + +theorem finite_children_work_723_i6 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_723_i6 j) (childrenD_723_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 5 (5, 4)).mono (by decide +kernel) + · exact finite_row_works_723_i7.mono (by decide +kernel) + +theorem finite_row_works_723_i6 : FiniteTemplate HasSnaky 7 required_723_i6 envelope_723_i6 := by + refine finite_compose HasSnaky 6 childrenC_723_i6 childrenD_723_i6 finite_children_work_723_i6 (3, 7) + required_723_i6 envelope_723_i6 pivot_mem_723_i6 child_required_sub_723_i6 child_envelope_sub_723_i6 ?_ + intro b hb + exact common_sub_723_i6 (mem_commonEnvelope childrenD_723_i6 b hb) + +theorem finite_children_work_723_i8 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_723_i8 j) (childrenD_723_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_192 4 (4, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_369 6 (6, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 1 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_477 3 (3, 8)).mono (by decide +kernel) + +theorem finite_row_works_723_i8 : FiniteTemplate HasSnaky 10 required_723_i8 envelope_723_i8 := by + refine finite_compose HasSnaky 9 childrenC_723_i8 childrenD_723_i8 finite_children_work_723_i8 (5, 6) + required_723_i8 envelope_723_i8 pivot_mem_723_i8 child_required_sub_723_i8 child_envelope_sub_723_i8 ?_ + intro b hb + exact common_sub_723_i8 (mem_commonEnvelope childrenD_723_i8 b hb) + +theorem finite_children_work_723_i2 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_723_i2 j) (childrenD_723_i2 j) := by + intro j + fin_cases j + · exact finite_row_works_723_i3.mono (by decide +kernel) + · exact finite_row_works_723_i5.mono (by decide +kernel) + · exact finite_row_works_723_i6.mono (by decide +kernel) + · exact finite_row_works_723_i8.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_721 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_722 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_723_i2 : FiniteTemplate HasSnaky 11 required_723_i2 envelope_723_i2 := by + refine finite_compose HasSnaky 10 childrenC_723_i2 childrenD_723_i2 finite_children_work_723_i2 (5, 7) + required_723_i2 envelope_723_i2 pivot_mem_723_i2 child_required_sub_723_i2 child_envelope_sub_723_i2 ?_ + intro b hb + exact common_sub_723_i2 (mem_commonEnvelope childrenD_723_i2 b hb) + +theorem finite_children_work_723 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_723 j) (childrenD_723 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_328 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_330 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_723_i0.mono (by decide +kernel) + · exact finite_row_works_723_i1.mono (by decide +kernel) + · exact finite_row_works_723_i2.mono (by decide +kernel) + +theorem finite_row_works_723 : FiniteTemplate HasSnaky 12 required_723 envelope_723 := by + refine finite_compose HasSnaky 11 childrenC_723 childrenD_723 finite_children_work_723 (5, 5) + required_723 envelope_723 pivot_mem_723 child_required_sub_723 child_envelope_sub_723 ?_ + intro b hb + exact common_sub_723 (mem_commonEnvelope childrenD_723 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height13Part01.lean b/lean/snaky/FiniteCards/Height13Part01.lean new file mode 100644 index 0000000..c0f0b86 --- /dev/null +++ b/lean/snaky/FiniteCards/Height13Part01.lean @@ -0,0 +1,298 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part03 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part03 +import FiniteCards.Height09Part04 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part02 +import FiniteCards.Height10Part03 +import FiniteCards.Height11Part02 +import FiniteCards.Height12Part01 +import FiniteCards.Height12Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_462 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_462 j) (childrenD_462 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 2 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 6 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_31 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_189 2 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_367 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_428 4 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_457 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_462 : FiniteTemplate HasSnaky 13 required_462 envelope_462 := by + refine finite_compose HasSnaky 12 childrenC_462 childrenD_462 finite_children_work_462 (1, 5) + required_462 envelope_462 pivot_mem_462 child_required_sub_462 child_envelope_sub_462 ?_ + intro b hb + exact common_sub_462 (mem_commonEnvelope childrenD_462 b hb) + +theorem finite_children_work_490 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_490 j) (childrenD_490 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_321 0 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_321 4 (2, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_485 1 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_485 3 (0, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_489 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_489 4 (0, 12)).mono (by decide +kernel) + +theorem finite_row_works_490 : FiniteTemplate HasSnaky 13 required_490 envelope_490 := by + refine finite_compose HasSnaky 12 childrenC_490 childrenD_490 finite_children_work_490 (5, 7) + required_490 envelope_490 pivot_mem_490 child_required_sub_490 child_envelope_sub_490 ?_ + intro b hb + exact common_sub_490 (mem_commonEnvelope childrenD_490 b hb) + +theorem finite_children_work_538_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_538_i0 j) (childrenD_538_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_190 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_190 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_258 5 (8, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_273 4 (1, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_415 0 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_507 1 (2, 4)).mono (by decide +kernel) + +theorem finite_row_works_538_i0 : FiniteTemplate HasSnaky 9 required_538_i0 envelope_538_i0 := by + refine finite_compose HasSnaky 8 childrenC_538_i0 childrenD_538_i0 finite_children_work_538_i0 (5, 7) + required_538_i0 envelope_538_i0 pivot_mem_538_i0 child_required_sub_538_i0 child_envelope_sub_538_i0 ?_ + intro b hb + exact common_sub_538_i0 (mem_commonEnvelope childrenD_538_i0 b hb) + +theorem finite_children_work_538_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_538_i1 j) (childrenD_538_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_512 4 (3, 9)).mono (by decide +kernel) + +theorem finite_row_works_538_i1 : FiniteTemplate HasSnaky 10 required_538_i1 envelope_538_i1 := by + refine finite_compose HasSnaky 9 childrenC_538_i1 childrenD_538_i1 finite_children_work_538_i1 (4, 6) + required_538_i1 envelope_538_i1 pivot_mem_538_i1 child_required_sub_538_i1 child_envelope_sub_538_i1 ?_ + intro b hb + exact common_sub_538_i1 (mem_commonEnvelope childrenD_538_i1 b hb) + +theorem finite_children_work_538_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_538_i3 j) (childrenD_538_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_354 5 (6, 4)).mono (by decide +kernel) + +theorem finite_row_works_538_i3 : FiniteTemplate HasSnaky 5 required_538_i3 envelope_538_i3 := by + refine finite_compose HasSnaky 4 childrenC_538_i3 childrenD_538_i3 finite_children_work_538_i3 (5, 7) + required_538_i3 envelope_538_i3 pivot_mem_538_i3 child_required_sub_538_i3 child_envelope_sub_538_i3 ?_ + intro b hb + exact common_sub_538_i3 (mem_commonEnvelope childrenD_538_i3 b hb) + +theorem finite_children_work_538_i4 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_538_i4 j) (childrenD_538_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_15 2 (5, 3)).mono (by decide +kernel) + +theorem finite_row_works_538_i4 : FiniteTemplate HasSnaky 3 required_538_i4 envelope_538_i4 := by + refine finite_compose HasSnaky 2 childrenC_538_i4 childrenD_538_i4 finite_children_work_538_i4 (4, 6) + required_538_i4 envelope_538_i4 pivot_mem_538_i4 child_required_sub_538_i4 child_envelope_sub_538_i4 ?_ + intro b hb + exact common_sub_538_i4 (mem_commonEnvelope childrenD_538_i4 b hb) + +theorem finite_children_work_538_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_538_i5 j) (childrenD_538_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_505 7 (6, 7)).mono (by decide +kernel) + +theorem finite_row_works_538_i5 : FiniteTemplate HasSnaky 6 required_538_i5 envelope_538_i5 := by + refine finite_compose HasSnaky 5 childrenC_538_i5 childrenD_538_i5 finite_children_work_538_i5 (5, 7) + required_538_i5 envelope_538_i5 pivot_mem_538_i5 child_required_sub_538_i5 child_envelope_sub_538_i5 ?_ + intro b hb + exact common_sub_538_i5 (mem_commonEnvelope childrenD_538_i5 b hb) + +theorem finite_children_work_538_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_538_i2 j) (childrenD_538_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_136 4 (3, 7)).mono (by decide +kernel) + · exact finite_row_works_538_i3.mono (by decide +kernel) + · exact finite_row_works_538_i4.mono (by decide +kernel) + · exact finite_row_works_538_i5.mono (by decide +kernel) + +theorem finite_row_works_538_i2 : FiniteTemplate HasSnaky 7 required_538_i2 envelope_538_i2 := by + refine finite_compose HasSnaky 6 childrenC_538_i2 childrenD_538_i2 finite_children_work_538_i2 (5, 4) + required_538_i2 envelope_538_i2 pivot_mem_538_i2 child_required_sub_538_i2 child_envelope_sub_538_i2 ?_ + intro b hb + exact common_sub_538_i2 (mem_commonEnvelope childrenD_538_i2 b hb) + +theorem finite_children_work_538_i6 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_538_i6 j) (childrenD_538_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_517 0 (3, 2)).mono (by decide +kernel) + +theorem finite_row_works_538_i6 : FiniteTemplate HasSnaky 12 required_538_i6 envelope_538_i6 := by + refine finite_compose HasSnaky 11 childrenC_538_i6 childrenD_538_i6 finite_children_work_538_i6 (4, 6) + required_538_i6 envelope_538_i6 pivot_mem_538_i6 child_required_sub_538_i6 child_envelope_sub_538_i6 ?_ + intro b hb + exact common_sub_538_i6 (mem_commonEnvelope childrenD_538_i6 b hb) + +theorem finite_children_work_538_i7 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_538_i7 j) (childrenD_538_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_116 3 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_258 5 (8, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_273 4 (1, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_275 1 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_415 0 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_518 2 (8, 2)).mono (by decide +kernel) + +theorem finite_row_works_538_i7 : FiniteTemplate HasSnaky 9 required_538_i7 envelope_538_i7 := by + refine finite_compose HasSnaky 8 childrenC_538_i7 childrenD_538_i7 finite_children_work_538_i7 (5, 7) + required_538_i7 envelope_538_i7 pivot_mem_538_i7 child_required_sub_538_i7 child_envelope_sub_538_i7 ?_ + intro b hb + exact common_sub_538_i7 (mem_commonEnvelope childrenD_538_i7 b hb) + +theorem finite_children_work_538_i8 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_538_i8 j) (childrenD_538_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_527 4 (3, 9)).mono (by decide +kernel) + +theorem finite_row_works_538_i8 : FiniteTemplate HasSnaky 12 required_538_i8 envelope_538_i8 := by + refine finite_compose HasSnaky 11 childrenC_538_i8 childrenD_538_i8 finite_children_work_538_i8 (4, 6) + required_538_i8 envelope_538_i8 pivot_mem_538_i8 child_required_sub_538_i8 child_envelope_sub_538_i8 ?_ + intro b hb + exact common_sub_538_i8 (mem_commonEnvelope childrenD_538_i8 b hb) + +theorem finite_children_work_538_i9 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_538_i9 j) (childrenD_538_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_537 4 (3, 9)).mono (by decide +kernel) + +theorem finite_row_works_538_i9 : FiniteTemplate HasSnaky 10 required_538_i9 envelope_538_i9 := by + refine finite_compose HasSnaky 9 childrenC_538_i9 childrenD_538_i9 finite_children_work_538_i9 (4, 6) + required_538_i9 envelope_538_i9 pivot_mem_538_i9 child_required_sub_538_i9 child_envelope_sub_538_i9 ?_ + intro b hb + exact common_sub_538_i9 (mem_commonEnvelope childrenD_538_i9 b hb) + +theorem finite_children_work_538 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_538 j) (childrenD_538 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_459 0 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_538_i0.mono (by decide +kernel) + · exact finite_row_works_538_i1.mono (by decide +kernel) + · exact finite_row_works_538_i2.mono (by decide +kernel) + · exact finite_row_works_538_i6.mono (by decide +kernel) + · exact finite_row_works_538_i7.mono (by decide +kernel) + · exact finite_row_works_538_i8.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_529 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_535 4 (3, 10)).mono (by decide +kernel) + · exact finite_row_works_538_i9.mono (by decide +kernel) + +theorem finite_row_works_538 : FiniteTemplate HasSnaky 13 required_538 envelope_538 := by + refine finite_compose HasSnaky 12 childrenC_538 childrenD_538 finite_children_work_538 (5, 6) + required_538 envelope_538 pivot_mem_538 child_required_sub_538 child_envelope_sub_538 ?_ + intro b hb + exact common_sub_538 (mem_commonEnvelope childrenD_538 b hb) + +theorem finite_children_work_552_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_552_i1 j) (childrenD_552_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 2 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_389 1 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_552_i1 : FiniteTemplate HasSnaky 6 required_552_i1 envelope_552_i1 := by + refine finite_compose HasSnaky 5 childrenC_552_i1 childrenD_552_i1 finite_children_work_552_i1 (5, 6) + required_552_i1 envelope_552_i1 pivot_mem_552_i1 child_required_sub_552_i1 child_envelope_sub_552_i1 ?_ + intro b hb + exact common_sub_552_i1 (mem_commonEnvelope childrenD_552_i1 b hb) + +theorem finite_children_work_552_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_552_i0 j) (childrenD_552_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_544 1 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_545 4 (6, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_546 0 (6, 2)).mono (by decide +kernel) + · exact finite_row_works_552_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_548 0 (6, 1)).mono (by decide +kernel) + +theorem finite_row_works_552_i0 : FiniteTemplate HasSnaky 11 required_552_i0 envelope_552_i0 := by + refine finite_compose HasSnaky 10 childrenC_552_i0 childrenD_552_i0 finite_children_work_552_i0 (7, 7) + required_552_i0 envelope_552_i0 pivot_mem_552_i0 child_required_sub_552_i0 child_envelope_sub_552_i0 ?_ + intro b hb + exact common_sub_552_i0 (mem_commonEnvelope childrenD_552_i0 b hb) + +theorem finite_children_work_552 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_552 j) (childrenD_552 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_188 1 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_258 0 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_326 4 (3, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_543 3 (0, 8)).mono (by decide +kernel) + · exact finite_row_works_552_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_551 0 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_552 : FiniteTemplate HasSnaky 13 required_552 envelope_552 := by + refine finite_compose HasSnaky 12 childrenC_552 childrenD_552 finite_children_work_552 (8, 6) + required_552 envelope_552 pivot_mem_552 child_required_sub_552 child_envelope_sub_552 ?_ + intro b hb + exact common_sub_552 (mem_commonEnvelope childrenD_552 b hb) + +theorem finite_children_work_555_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_555_i0 j) (childrenD_555_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_61 6 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_194 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_224 0 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_555_i0 : FiniteTemplate HasSnaky 5 required_555_i0 envelope_555_i0 := by + refine finite_compose HasSnaky 4 childrenC_555_i0 childrenD_555_i0 finite_children_work_555_i0 (2, 2) + required_555_i0 envelope_555_i0 pivot_mem_555_i0 child_required_sub_555_i0 child_envelope_sub_555_i0 ?_ + intro b hb + exact common_sub_555_i0 (mem_commonEnvelope childrenD_555_i0 b hb) + +theorem finite_children_work_555 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_555 j) (childrenD_555 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_31 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_230 7 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_367 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_428 0 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_555_i0.mono (by decide +kernel) + +theorem finite_row_works_555 : FiniteTemplate HasSnaky 13 required_555 envelope_555 := by + refine finite_compose HasSnaky 12 childrenC_555 childrenD_555 finite_children_work_555 (3, 3) + required_555 envelope_555 pivot_mem_555 child_required_sub_555 child_envelope_sub_555 ?_ + intro b hb + exact common_sub_555 (mem_commonEnvelope childrenD_555 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height13Part02.lean b/lean/snaky/FiniteCards/Height13Part02.lean new file mode 100644 index 0000000..a25213c --- /dev/null +++ b/lean/snaky/FiniteCards/Height13Part02.lean @@ -0,0 +1,323 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part05 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part05 +import FiniteCards.Height07Part03 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part01 +import FiniteCards.Height10Part03 +import FiniteCards.Height11Part02 +import FiniteCards.Height12Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_564_i2 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_564_i2 j) (childrenD_564_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_453 2 (5, 3)).mono (by decide +kernel) + +theorem finite_row_works_564_i2 : FiniteTemplate HasSnaky 8 required_564_i2 envelope_564_i2 := by + refine finite_compose HasSnaky 7 childrenC_564_i2 childrenD_564_i2 finite_children_work_564_i2 (2, 4) + required_564_i2 envelope_564_i2 pivot_mem_564_i2 child_required_sub_564_i2 child_envelope_sub_564_i2 ?_ + intro b hb + exact common_sub_564_i2 (mem_commonEnvelope childrenD_564_i2 b hb) + +theorem finite_children_work_564_i7 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_564_i7 j) (childrenD_564_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_55 2 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_564_i7 : FiniteTemplate HasSnaky 5 required_564_i7 envelope_564_i7 := by + refine finite_compose HasSnaky 4 childrenC_564_i7 childrenD_564_i7 finite_children_work_564_i7 (3, 5) + required_564_i7 envelope_564_i7 pivot_mem_564_i7 child_required_sub_564_i7 child_envelope_sub_564_i7 ?_ + intro b hb + exact common_sub_564_i7 (mem_commonEnvelope childrenD_564_i7 b hb) + +theorem finite_children_work_564_i8 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_564_i8 j) (childrenD_564_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_342 2 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_564_i8 : FiniteTemplate HasSnaky 6 required_564_i8 envelope_564_i8 := by + refine finite_compose HasSnaky 5 childrenC_564_i8 childrenD_564_i8 finite_children_work_564_i8 (2, 4) + required_564_i8 envelope_564_i8 pivot_mem_564_i8 child_required_sub_564_i8 child_envelope_sub_564_i8 ?_ + intro b hb + exact common_sub_564_i8 (mem_commonEnvelope childrenD_564_i8 b hb) + +theorem finite_children_work_564_i6 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_564_i6 j) (childrenD_564_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_102 5 (6, 4)).mono (by decide +kernel) + · exact finite_row_works_564_i7.mono (by decide +kernel) + · exact finite_row_works_564_i8.mono (by decide +kernel) + +theorem finite_row_works_564_i6 : FiniteTemplate HasSnaky 7 required_564_i6 envelope_564_i6 := by + refine finite_compose HasSnaky 6 childrenC_564_i6 childrenD_564_i6 finite_children_work_564_i6 (2, 5) + required_564_i6 envelope_564_i6 pivot_mem_564_i6 child_required_sub_564_i6 child_envelope_sub_564_i6 ?_ + intro b hb + exact common_sub_564_i6 (mem_commonEnvelope childrenD_564_i6 b hb) + +theorem finite_children_work_564_i5 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_564_i5 j) (childrenD_564_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (5, 8)).mono (by decide +kernel) + · exact finite_row_works_564_i6.mono (by decide +kernel) + +theorem finite_row_works_564_i5 : FiniteTemplate HasSnaky 8 required_564_i5 envelope_564_i5 := by + refine finite_compose HasSnaky 7 childrenC_564_i5 childrenD_564_i5 finite_children_work_564_i5 (4, 5) + required_564_i5 envelope_564_i5 pivot_mem_564_i5 child_required_sub_564_i5 child_envelope_sub_564_i5 ?_ + intro b hb + exact common_sub_564_i5 (mem_commonEnvelope childrenD_564_i5 b hb) + +theorem finite_children_work_564_i4 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_564_i4 j) (childrenD_564_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_16 2 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_235 6 (6, 8)).mono (by decide +kernel) + · exact finite_row_works_564_i5.mono (by decide +kernel) + +theorem finite_row_works_564_i4 : FiniteTemplate HasSnaky 9 required_564_i4 envelope_564_i4 := by + refine finite_compose HasSnaky 8 childrenC_564_i4 childrenD_564_i4 finite_children_work_564_i4 (5, 7) + required_564_i4 envelope_564_i4 pivot_mem_564_i4 child_required_sub_564_i4 child_envelope_sub_564_i4 ?_ + intro b hb + exact common_sub_564_i4 (mem_commonEnvelope childrenD_564_i4 b hb) + +theorem finite_children_work_564_i3 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_564_i3 j) (childrenD_564_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_67 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_134 5 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 5 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_327 7 (9, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_504 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_558 5 (7, 4)).mono (by decide +kernel) + · exact finite_row_works_564_i4.mono (by decide +kernel) + +theorem finite_row_works_564_i3 : FiniteTemplate HasSnaky 10 required_564_i3 envelope_564_i3 := by + refine finite_compose HasSnaky 9 childrenC_564_i3 childrenD_564_i3 finite_children_work_564_i3 (5, 6) + required_564_i3 envelope_564_i3 pivot_mem_564_i3 child_required_sub_564_i3 child_envelope_sub_564_i3 ?_ + intro b hb + exact common_sub_564_i3 (mem_commonEnvelope childrenD_564_i3 b hb) + +theorem finite_children_work_564_i1 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_564_i1 j) (childrenD_564_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 1 (2, 4)).mono (by decide +kernel) + · exact finite_row_works_564_i2.mono (by decide +kernel) + · exact finite_row_works_564_i3.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_560 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_563 1 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_564_i1 : FiniteTemplate HasSnaky 11 required_564_i1 envelope_564_i1 := by + refine finite_compose HasSnaky 10 childrenC_564_i1 childrenD_564_i1 finite_children_work_564_i1 (5, 5) + required_564_i1 envelope_564_i1 pivot_mem_564_i1 child_required_sub_564_i1 child_envelope_sub_564_i1 ?_ + intro b hb + exact common_sub_564_i1 (mem_commonEnvelope childrenD_564_i1 b hb) + +theorem finite_children_work_564_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_564_i0 j) (childrenD_564_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_79 1 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_135 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_182 3 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_564_i1.mono (by decide +kernel) + +theorem finite_row_works_564_i0 : FiniteTemplate HasSnaky 12 required_564_i0 envelope_564_i0 := by + refine finite_compose HasSnaky 11 childrenC_564_i0 childrenD_564_i0 finite_children_work_564_i0 (5, 4) + required_564_i0 envelope_564_i0 pivot_mem_564_i0 child_required_sub_564_i0 child_envelope_sub_564_i0 ?_ + intro b hb + exact common_sub_564_i0 (mem_commonEnvelope childrenD_564_i0 b hb) + +theorem finite_children_work_564 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_564 j) (childrenD_564 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_119 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_497 2 (4, 0)).mono (by decide +kernel) + · exact finite_row_works_498.mono (by decide +kernel) + · exact finite_row_works_564_i0.mono (by decide +kernel) + +theorem finite_row_works_564 : FiniteTemplate HasSnaky 13 required_564 envelope_564 := by + refine finite_compose HasSnaky 12 childrenC_564 childrenD_564 finite_children_work_564 (4, 4) + required_564 envelope_564 pivot_mem_564 child_required_sub_564 child_envelope_sub_564 ?_ + intro b hb + exact common_sub_564 (mem_commonEnvelope childrenD_564 b hb) + +theorem finite_children_work_568_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_568_i0 j) (childrenD_568_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_255 5 (7, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_496 2 (4, 0)).mono (by decide +kernel) + +theorem finite_row_works_568_i0 : FiniteTemplate HasSnaky 7 required_568_i0 envelope_568_i0 := by + refine finite_compose HasSnaky 6 childrenC_568_i0 childrenD_568_i0 finite_children_work_568_i0 (4, 3) + required_568_i0 envelope_568_i0 pivot_mem_568_i0 child_required_sub_568_i0 child_envelope_sub_568_i0 ?_ + intro b hb + exact common_sub_568_i0 (mem_commonEnvelope childrenD_568_i0 b hb) + +theorem finite_children_work_568_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_568_i3 j) (childrenD_568_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_24 4 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_77 3 (2, 5)).mono (by decide +kernel) + +theorem finite_row_works_568_i3 : FiniteTemplate HasSnaky 4 required_568_i3 envelope_568_i3 := by + refine finite_compose HasSnaky 3 childrenC_568_i3 childrenD_568_i3 finite_children_work_568_i3 (6, 4) + required_568_i3 envelope_568_i3 pivot_mem_568_i3 child_required_sub_568_i3 child_envelope_sub_568_i3 ?_ + intro b hb + exact common_sub_568_i3 (mem_commonEnvelope childrenD_568_i3 b hb) + +theorem finite_children_work_568_i6 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_568_i6 j) (childrenD_568_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_132 5 (5, 3)).mono (by decide +kernel) + +theorem finite_row_works_568_i6 : FiniteTemplate HasSnaky 5 required_568_i6 envelope_568_i6 := by + refine finite_compose HasSnaky 4 childrenC_568_i6 childrenD_568_i6 finite_children_work_568_i6 (3, 7) + required_568_i6 envelope_568_i6 pivot_mem_568_i6 child_required_sub_568_i6 child_envelope_sub_568_i6 ?_ + intro b hb + exact common_sub_568_i6 (mem_commonEnvelope childrenD_568_i6 b hb) + +theorem finite_children_work_568_i7 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_568_i7 j) (childrenD_568_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 2 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_124 2 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_568_i7 : FiniteTemplate HasSnaky 4 required_568_i7 envelope_568_i7 := by + refine finite_compose HasSnaky 3 childrenC_568_i7 childrenD_568_i7 finite_children_work_568_i7 (3, 7) + required_568_i7 envelope_568_i7 pivot_mem_568_i7 child_required_sub_568_i7 child_envelope_sub_568_i7 ?_ + intro b hb + exact common_sub_568_i7 (mem_commonEnvelope childrenD_568_i7 b hb) + +theorem finite_children_work_568_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_568_i5 j) (childrenD_568_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 5 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_387 2 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_568_i6.mono (by decide +kernel) + · exact finite_row_works_568_i7.mono (by decide +kernel) + +theorem finite_row_works_568_i5 : FiniteTemplate HasSnaky 7 required_568_i5 envelope_568_i5 := by + refine finite_compose HasSnaky 6 childrenC_568_i5 childrenD_568_i5 finite_children_work_568_i5 (3, 6) + required_568_i5 envelope_568_i5 pivot_mem_568_i5 child_required_sub_568_i5 child_envelope_sub_568_i5 ?_ + intro b hb + exact common_sub_568_i5 (mem_commonEnvelope childrenD_568_i5 b hb) + +theorem finite_children_work_568_i4 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_568_i4 j) (childrenD_568_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 3 (3, 5)).mono (by decide +kernel) + · exact finite_row_works_568_i5.mono (by decide +kernel) + +theorem finite_row_works_568_i4 : FiniteTemplate HasSnaky 8 required_568_i4 envelope_568_i4 := by + refine finite_compose HasSnaky 7 childrenC_568_i4 childrenD_568_i4 finite_children_work_568_i4 (3, 3) + required_568_i4 envelope_568_i4 pivot_mem_568_i4 child_required_sub_568_i4 child_envelope_sub_568_i4 ?_ + intro b hb + exact common_sub_568_i4 (mem_commonEnvelope childrenD_568_i4 b hb) + +theorem finite_children_work_568_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_568_i2 j) (childrenD_568_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 5 (6, 4)).mono (by decide +kernel) + · exact finite_row_works_568_i3.mono (by decide +kernel) + · exact finite_row_works_568_i4.mono (by decide +kernel) + +theorem finite_row_works_568_i2 : FiniteTemplate HasSnaky 9 required_568_i2 envelope_568_i2 := by + refine finite_compose HasSnaky 8 childrenC_568_i2 childrenD_568_i2 finite_children_work_568_i2 (3, 5) + required_568_i2 envelope_568_i2 pivot_mem_568_i2 child_required_sub_568_i2 child_envelope_sub_568_i2 ?_ + intro b hb + exact common_sub_568_i2 (mem_commonEnvelope childrenD_568_i2 b hb) + +theorem finite_children_work_568_i1 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_568_i1 j) (childrenD_568_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_79 1 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_189 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_518 3 (0, 7)).mono (by decide +kernel) + · exact finite_row_works_568_i2.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_565 4 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_567 1 (0, 1)).mono (by decide +kernel) + +theorem finite_row_works_568_i1 : FiniteTemplate HasSnaky 12 required_568_i1 envelope_568_i1 := by + refine finite_compose HasSnaky 11 childrenC_568_i1 childrenD_568_i1 finite_children_work_568_i1 (5, 4) + required_568_i1 envelope_568_i1 pivot_mem_568_i1 child_required_sub_568_i1 child_envelope_sub_568_i1 ?_ + intro b hb + exact common_sub_568_i1 (mem_commonEnvelope childrenD_568_i1 b hb) + +theorem finite_children_work_568 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_568 j) (childrenD_568 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_110 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_497 2 (4, 0)).mono (by decide +kernel) + · exact finite_row_works_568_i0.mono (by decide +kernel) + · exact finite_row_works_568_i1.mono (by decide +kernel) + +theorem finite_row_works_568 : FiniteTemplate HasSnaky 13 required_568 envelope_568 := by + refine finite_compose HasSnaky 12 childrenC_568 childrenD_568 finite_children_work_568 (4, 4) + required_568 envelope_568 pivot_mem_568 child_required_sub_568 child_envelope_sub_568 ?_ + intro b hb + exact common_sub_568 (mem_commonEnvelope childrenD_568 b hb) + +theorem finite_children_work_572_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_572_i0 j) (childrenD_572_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_78 4 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_572_i0 : FiniteTemplate HasSnaky 4 required_572_i0 envelope_572_i0 := by + refine finite_compose HasSnaky 3 childrenC_572_i0 childrenD_572_i0 finite_children_work_572_i0 (2, 6) + required_572_i0 envelope_572_i0 pivot_mem_572_i0 child_required_sub_572_i0 child_envelope_sub_572_i0 ?_ + intro b hb + exact common_sub_572_i0 (mem_commonEnvelope childrenD_572_i0 b hb) + +theorem finite_children_work_572 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_572 j) (childrenD_572 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_97 3 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_98 1 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_572_i0.mono (by decide +kernel) + · exact finite_row_works_571.mono (by decide +kernel) + +theorem finite_row_works_572 : FiniteTemplate HasSnaky 13 required_572 envelope_572 := by + refine finite_compose HasSnaky 12 childrenC_572 childrenD_572 finite_children_work_572 (4, 6) + required_572 envelope_572 pivot_mem_572 child_required_sub_572 child_envelope_sub_572 ?_ + intro b hb + exact common_sub_572 (mem_commonEnvelope childrenD_572 b hb) + +theorem finite_children_work_590 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_590 j) (childrenD_590 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_588.mono (by decide +kernel) + +theorem finite_row_works_590 : FiniteTemplate HasSnaky 13 required_590 envelope_590 := by + refine finite_compose HasSnaky 12 childrenC_590 childrenD_590 finite_children_work_590 (2, 3) + required_590 envelope_590 pivot_mem_590 child_required_sub_590 child_envelope_sub_590 ?_ + intro b hb + exact common_sub_590 (mem_commonEnvelope childrenD_590 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height13Part03.lean b/lean/snaky/FiniteCards/Height13Part03.lean new file mode 100644 index 0000000..3c6fbb5 --- /dev/null +++ b/lean/snaky/FiniteCards/Height13Part03.lean @@ -0,0 +1,362 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part05 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height09Part02 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part03 +import FiniteCards.Height11Part01 +import FiniteCards.Height11Part02 +import FiniteCards.Height11Part03 +import FiniteCards.Height11Part05 +import FiniteCards.Height12Part02 +import FiniteCards.Height12Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_591_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_591_i0 j) (childrenD_591_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_265 1 (1, 5)).mono (by decide +kernel) + +theorem finite_row_works_591_i0 : FiniteTemplate HasSnaky 6 required_591_i0 envelope_591_i0 := by + refine finite_compose HasSnaky 5 childrenC_591_i0 childrenD_591_i0 finite_children_work_591_i0 (3, 6) + required_591_i0 envelope_591_i0 pivot_mem_591_i0 child_required_sub_591_i0 child_envelope_sub_591_i0 ?_ + intro b hb + exact common_sub_591_i0 (mem_commonEnvelope childrenD_591_i0 b hb) + +theorem finite_children_work_591_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_591_i1 j) (childrenD_591_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_13 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_289 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 3 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_591_i1 : FiniteTemplate HasSnaky 7 required_591_i1 envelope_591_i1 := by + refine finite_compose HasSnaky 6 childrenC_591_i1 childrenD_591_i1 finite_children_work_591_i1 (4, 4) + required_591_i1 envelope_591_i1 pivot_mem_591_i1 child_required_sub_591_i1 child_envelope_sub_591_i1 ?_ + intro b hb + exact common_sub_591_i1 (mem_commonEnvelope childrenD_591_i1 b hb) + +theorem finite_children_work_591_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_591_i4 j) (childrenD_591_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_17 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_80 7 (5, 6)).mono (by decide +kernel) + +theorem finite_row_works_591_i4 : FiniteTemplate HasSnaky 5 required_591_i4 envelope_591_i4 := by + refine finite_compose HasSnaky 4 childrenC_591_i4 childrenD_591_i4 finite_children_work_591_i4 (3, 5) + required_591_i4 envelope_591_i4 pivot_mem_591_i4 child_required_sub_591_i4 child_envelope_sub_591_i4 ?_ + intro b hb + exact common_sub_591_i4 (mem_commonEnvelope childrenD_591_i4 b hb) + +theorem finite_children_work_591_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_591_i3 j) (childrenD_591_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_109 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_157 7 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_591_i4.mono (by decide +kernel) + +theorem finite_row_works_591_i3 : FiniteTemplate HasSnaky 6 required_591_i3 envelope_591_i3 := by + refine finite_compose HasSnaky 5 childrenC_591_i3 childrenD_591_i3 finite_children_work_591_i3 (4, 3) + required_591_i3 envelope_591_i3 pivot_mem_591_i3 child_required_sub_591_i3 child_envelope_sub_591_i3 ?_ + intro b hb + exact common_sub_591_i3 (mem_commonEnvelope childrenD_591_i3 b hb) + +theorem finite_children_work_591_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_591_i5 j) (childrenD_591_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 3 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_19 2 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_271 4 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_591_i5 : FiniteTemplate HasSnaky 6 required_591_i5 envelope_591_i5 := by + refine finite_compose HasSnaky 5 childrenC_591_i5 childrenD_591_i5 finite_children_work_591_i5 (4, 3) + required_591_i5 envelope_591_i5 pivot_mem_591_i5 child_required_sub_591_i5 child_envelope_sub_591_i5 ?_ + intro b hb + exact common_sub_591_i5 (mem_commonEnvelope childrenD_591_i5 b hb) + +theorem finite_children_work_591_i2 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_591_i2 j) (childrenD_591_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_356 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_591_i3.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_586 1 (2, 3)).mono (by decide +kernel) + · exact finite_row_works_591_i5.mono (by decide +kernel) + +theorem finite_row_works_591_i2 : FiniteTemplate HasSnaky 12 required_591_i2 envelope_591_i2 := by + refine finite_compose HasSnaky 11 childrenC_591_i2 childrenD_591_i2 finite_children_work_591_i2 (4, 4) + required_591_i2 envelope_591_i2 pivot_mem_591_i2 child_required_sub_591_i2 child_envelope_sub_591_i2 ?_ + intro b hb + exact common_sub_591_i2 (mem_commonEnvelope childrenD_591_i2 b hb) + +theorem finite_children_work_591 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_591 j) (childrenD_591 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_42 1 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_430 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_591_i0.mono (by decide +kernel) + · exact finite_row_works_591_i1.mono (by decide +kernel) + · exact finite_row_works_591_i2.mono (by decide +kernel) + +theorem finite_row_works_591 : FiniteTemplate HasSnaky 13 required_591 envelope_591 := by + refine finite_compose HasSnaky 12 childrenC_591 childrenD_591 finite_children_work_591 (4, 6) + required_591 envelope_591 pivot_mem_591 child_required_sub_591 child_envelope_sub_591 ?_ + intro b hb + exact common_sub_591 (mem_commonEnvelope childrenD_591 b hb) + +theorem finite_children_work_597_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_597_i0 j) (childrenD_597_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 6 (6, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_109 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_291 0 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_597_i0 : FiniteTemplate HasSnaky 5 required_597_i0 envelope_597_i0 := by + refine finite_compose HasSnaky 4 childrenC_597_i0 childrenD_597_i0 finite_children_work_597_i0 (5, 4) + required_597_i0 envelope_597_i0 pivot_mem_597_i0 child_required_sub_597_i0 child_envelope_sub_597_i0 ?_ + intro b hb + exact common_sub_597_i0 (mem_commonEnvelope childrenD_597_i0 b hb) + +theorem finite_children_work_597_i3 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_597_i3 j) (childrenD_597_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (5, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 2 (5, 2)).mono (by decide +kernel) + +theorem finite_row_works_597_i3 : FiniteTemplate HasSnaky 2 required_597_i3 envelope_597_i3 := by + refine finite_compose HasSnaky 1 childrenC_597_i3 childrenD_597_i3 finite_children_work_597_i3 (4, 2) + required_597_i3 envelope_597_i3 pivot_mem_597_i3 child_required_sub_597_i3 child_envelope_sub_597_i3 ?_ + intro b hb + exact common_sub_597_i3 (mem_commonEnvelope childrenD_597_i3 b hb) + +theorem finite_children_work_597_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_597_i2 j) (childrenD_597_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_597_i3.mono (by decide +kernel) + +theorem finite_row_works_597_i2 : FiniteTemplate HasSnaky 4 required_597_i2 envelope_597_i2 := by + refine finite_compose HasSnaky 3 childrenC_597_i2 childrenD_597_i2 finite_children_work_597_i2 (5, 2) + required_597_i2 envelope_597_i2 pivot_mem_597_i2 child_required_sub_597_i2 child_envelope_sub_597_i2 ?_ + intro b hb + exact common_sub_597_i2 (mem_commonEnvelope childrenD_597_i2 b hb) + +theorem finite_children_work_597_i6 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_597_i6 j) (childrenD_597_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_4 3 (5, 5)).mono (by decide +kernel) + +theorem finite_row_works_597_i6 : FiniteTemplate HasSnaky 2 required_597_i6 envelope_597_i6 := by + refine finite_compose HasSnaky 1 childrenC_597_i6 childrenD_597_i6 finite_children_work_597_i6 (6, 1) + required_597_i6 envelope_597_i6 pivot_mem_597_i6 child_required_sub_597_i6 child_envelope_sub_597_i6 ?_ + intro b hb + exact common_sub_597_i6 (mem_commonEnvelope childrenD_597_i6 b hb) + +theorem finite_children_work_597_i5 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_597_i5 j) (childrenD_597_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (5, 2)).mono (by decide +kernel) + · exact finite_row_works_597_i6.mono (by decide +kernel) + +theorem finite_row_works_597_i5 : FiniteTemplate HasSnaky 3 required_597_i5 envelope_597_i5 := by + refine finite_compose HasSnaky 2 childrenC_597_i5 childrenD_597_i5 finite_children_work_597_i5 (5, 2) + required_597_i5 envelope_597_i5 pivot_mem_597_i5 child_required_sub_597_i5 child_envelope_sub_597_i5 ?_ + intro b hb + exact common_sub_597_i5 (mem_commonEnvelope childrenD_597_i5 b hb) + +theorem finite_children_work_597_i4 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_597_i4 j) (childrenD_597_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_140 6 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_597_i5.mono (by decide +kernel) + +theorem finite_row_works_597_i4 : FiniteTemplate HasSnaky 4 required_597_i4 envelope_597_i4 := by + refine finite_compose HasSnaky 3 childrenC_597_i4 childrenD_597_i4 finite_children_work_597_i4 (4, 2) + required_597_i4 envelope_597_i4 pivot_mem_597_i4 child_required_sub_597_i4 child_envelope_sub_597_i4 ?_ + intro b hb + exact common_sub_597_i4 (mem_commonEnvelope childrenD_597_i4 b hb) + +theorem finite_children_work_597_i1 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_597_i1 j) (childrenD_597_i1 j) := by + intro j + fin_cases j + · exact finite_row_works_597_i2.mono (by decide +kernel) + · exact finite_row_works_597_i4.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_596 1 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_597_i1 : FiniteTemplate HasSnaky 12 required_597_i1 envelope_597_i1 := by + refine finite_compose HasSnaky 11 childrenC_597_i1 childrenD_597_i1 finite_children_work_597_i1 (5, 4) + required_597_i1 envelope_597_i1 pivot_mem_597_i1 child_required_sub_597_i1 child_envelope_sub_597_i1 ?_ + intro b hb + exact common_sub_597_i1 (mem_commonEnvelope childrenD_597_i1 b hb) + +theorem finite_children_work_597 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_597 j) (childrenD_597 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_272 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_290 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_593 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_597_i0.mono (by decide +kernel) + · exact finite_row_works_597_i1.mono (by decide +kernel) + +theorem finite_row_works_597 : FiniteTemplate HasSnaky 13 required_597 envelope_597 := by + refine finite_compose HasSnaky 12 childrenC_597 childrenD_597 finite_children_work_597 (5, 5) + required_597 envelope_597 pivot_mem_597 child_required_sub_597 child_envelope_sub_597 ?_ + intro b hb + exact common_sub_597 (mem_commonEnvelope childrenD_597 b hb) + +theorem finite_children_work_603_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_603_i0 j) (childrenD_603_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 6 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_427 4 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_603_i0 : FiniteTemplate HasSnaky 12 required_603_i0 envelope_603_i0 := by + refine finite_compose HasSnaky 11 childrenC_603_i0 childrenD_603_i0 finite_children_work_603_i0 (1, 2) + required_603_i0 envelope_603_i0 pivot_mem_603_i0 child_required_sub_603_i0 child_envelope_sub_603_i0 ?_ + intro b hb + exact common_sub_603_i0 (mem_commonEnvelope childrenD_603_i0 b hb) + +theorem finite_children_work_603 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_603 j) (childrenD_603 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 2 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 6 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_31 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_189 2 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_367 4 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_457 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_603_i0.mono (by decide +kernel) + +theorem finite_row_works_603 : FiniteTemplate HasSnaky 13 required_603 envelope_603 := by + refine finite_compose HasSnaky 12 childrenC_603 childrenD_603 finite_children_work_603 (1, 5) + required_603 envelope_603 pivot_mem_603 child_required_sub_603 child_envelope_sub_603 ?_ + intro b hb + exact common_sub_603 (mem_commonEnvelope childrenD_603 b hb) + +theorem finite_children_work_634 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_634 j) (childrenD_634 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_438 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_452 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_612 7 (6, 5)).mono (by decide +kernel) + · exact finite_row_works_633.mono (by decide +kernel) + +theorem finite_row_works_634 : FiniteTemplate HasSnaky 13 required_634 envelope_634 := by + refine finite_compose HasSnaky 12 childrenC_634 childrenD_634 finite_children_work_634 (5, 5) + required_634 envelope_634 pivot_mem_634 child_required_sub_634 child_envelope_sub_634 ?_ + intro b hb + exact common_sub_634 (mem_commonEnvelope childrenD_634 b hb) + +theorem finite_children_work_642 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_642 j) (childrenD_642 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_299 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_349 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_476 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 4 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_612 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_641 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_642 : FiniteTemplate HasSnaky 13 required_642 envelope_642 := by + refine finite_compose HasSnaky 12 childrenC_642 childrenD_642 finite_children_work_642 (3, 5) + required_642 envelope_642 pivot_mem_642 child_required_sub_642 child_envelope_sub_642 ?_ + intro b hb + exact common_sub_642 (mem_commonEnvelope childrenD_642 b hb) + +theorem finite_children_work_643 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_643 j) (childrenD_643 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_299 4 (0, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_349 4 (0, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_476 4 (0, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 4 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_612 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_641 4 (0, 7)).mono (by decide +kernel) + +theorem finite_row_works_643 : FiniteTemplate HasSnaky 13 required_643 envelope_643 := by + refine finite_compose HasSnaky 12 childrenC_643 childrenD_643 finite_children_work_643 (3, 5) + required_643 envelope_643 pivot_mem_643 child_required_sub_643 child_envelope_sub_643 ?_ + intro b hb + exact common_sub_643 (mem_commonEnvelope childrenD_643 b hb) + +theorem finite_children_work_647_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_647_i1 j) (childrenD_647_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 7 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_65 5 (8, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_282 6 (6, 7)).mono (by decide +kernel) + +theorem finite_row_works_647_i1 : FiniteTemplate HasSnaky 6 required_647_i1 envelope_647_i1 := by + refine finite_compose HasSnaky 5 childrenC_647_i1 childrenD_647_i1 finite_children_work_647_i1 (6, 5) + required_647_i1 envelope_647_i1 pivot_mem_647_i1 child_required_sub_647_i1 child_envelope_sub_647_i1 ?_ + intro b hb + exact common_sub_647_i1 (mem_commonEnvelope childrenD_647_i1 b hb) + +theorem finite_children_work_647_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_647_i0 j) (childrenD_647_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_600 5 (8, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_600 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_621 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_647_i1.mono (by decide +kernel) + +theorem finite_row_works_647_i0 : FiniteTemplate HasSnaky 8 required_647_i0 envelope_647_i0 := by + refine finite_compose HasSnaky 7 childrenC_647_i0 childrenD_647_i0 finite_children_work_647_i0 (5, 5) + required_647_i0 envelope_647_i0 pivot_mem_647_i0 child_required_sub_647_i0 child_envelope_sub_647_i0 ?_ + intro b hb + exact common_sub_647_i0 (mem_commonEnvelope childrenD_647_i0 b hb) + +theorem finite_children_work_647 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_647 j) (childrenD_647 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_399 7 (8, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_408 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_410 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_480 5 (9, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_546 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_635 7 (9, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_646 1 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_647_i0.mono (by decide +kernel) + +theorem finite_row_works_647 : FiniteTemplate HasSnaky 13 required_647 envelope_647 := by + refine finite_compose HasSnaky 12 childrenC_647 childrenD_647 finite_children_work_647 (5, 4) + required_647 envelope_647 pivot_mem_647 child_required_sub_647 child_envelope_sub_647 ?_ + intro b hb + exact common_sub_647 (mem_commonEnvelope childrenD_647 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height13Part04.lean b/lean/snaky/FiniteCards/Height13Part04.lean new file mode 100644 index 0000000..97a0f48 --- /dev/null +++ b/lean/snaky/FiniteCards/Height13Part04.lean @@ -0,0 +1,249 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part05 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part03 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part03 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part02 +import FiniteCards.Height10Part05 +import FiniteCards.Height11Part02 +import FiniteCards.Height11Part05 +import FiniteCards.Height12Part02 +import FiniteCards.Height12Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_650_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_650_i0 j) (childrenD_650_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 3 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_545 2 (6, 0)).mono (by decide +kernel) + +theorem finite_row_works_650_i0 : FiniteTemplate HasSnaky 11 required_650_i0 envelope_650_i0 := by + refine finite_compose HasSnaky 10 childrenC_650_i0 childrenD_650_i0 finite_children_work_650_i0 (5, 4) + required_650_i0 envelope_650_i0 pivot_mem_650_i0 child_required_sub_650_i0 child_envelope_sub_650_i0 ?_ + intro b hb + exact common_sub_650_i0 (mem_commonEnvelope childrenD_650_i0 b hb) + +theorem finite_children_work_650 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_650 j) (childrenD_650 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_257 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_507 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_649 4 (1, 10)).mono (by decide +kernel) + · exact finite_row_works_650_i0.mono (by decide +kernel) + +theorem finite_row_works_650 : FiniteTemplate HasSnaky 13 required_650 envelope_650 := by + refine finite_compose HasSnaky 12 childrenC_650 childrenD_650 finite_children_work_650 (5, 5) + required_650 envelope_650 pivot_mem_650 child_required_sub_650 child_envelope_sub_650 ?_ + intro b hb + exact common_sub_650 (mem_commonEnvelope childrenD_650 b hb) + +theorem finite_children_work_657_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_657_i1 j) (childrenD_657_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 3 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_79 2 (5, 1)).mono (by decide +kernel) + +theorem finite_row_works_657_i1 : FiniteTemplate HasSnaky 5 required_657_i1 envelope_657_i1 := by + refine finite_compose HasSnaky 4 childrenC_657_i1 childrenD_657_i1 finite_children_work_657_i1 (2, 4) + required_657_i1 envelope_657_i1 pivot_mem_657_i1 child_required_sub_657_i1 child_envelope_sub_657_i1 ?_ + intro b hb + exact common_sub_657_i1 (mem_commonEnvelope childrenD_657_i1 b hb) + +theorem finite_children_work_657_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_657_i2 j) (childrenD_657_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_71 2 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_345 1 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_657_i2 : FiniteTemplate HasSnaky 9 required_657_i2 envelope_657_i2 := by + refine finite_compose HasSnaky 8 childrenC_657_i2 childrenD_657_i2 finite_children_work_657_i2 (4, 2) + required_657_i2 envelope_657_i2 pivot_mem_657_i2 child_required_sub_657_i2 child_envelope_sub_657_i2 ?_ + intro b hb + exact common_sub_657_i2 (mem_commonEnvelope childrenD_657_i2 b hb) + +theorem finite_children_work_657_i6 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_657_i6 j) (childrenD_657_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_445 4 (3, 5)).mono (by decide +kernel) + +theorem finite_row_works_657_i6 : FiniteTemplate HasSnaky 6 required_657_i6 envelope_657_i6 := by + refine finite_compose HasSnaky 5 childrenC_657_i6 childrenD_657_i6 finite_children_work_657_i6 (6, 3) + required_657_i6 envelope_657_i6 pivot_mem_657_i6 child_required_sub_657_i6 child_envelope_sub_657_i6 ?_ + intro b hb + exact common_sub_657_i6 (mem_commonEnvelope childrenD_657_i6 b hb) + +theorem finite_children_work_657_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_657_i5 j) (childrenD_657_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_20 1 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_29 3 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_657_i6.mono (by decide +kernel) + +theorem finite_row_works_657_i5 : FiniteTemplate HasSnaky 7 required_657_i5 envelope_657_i5 := by + refine finite_compose HasSnaky 6 childrenC_657_i5 childrenD_657_i5 finite_children_work_657_i5 (6, 4) + required_657_i5 envelope_657_i5 pivot_mem_657_i5 child_required_sub_657_i5 child_envelope_sub_657_i5 ?_ + intro b hb + exact common_sub_657_i5 (mem_commonEnvelope childrenD_657_i5 b hb) + +theorem finite_children_work_657_i4 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_657_i4 j) (childrenD_657_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 3 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_65 1 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_657_i5.mono (by decide +kernel) + +theorem finite_row_works_657_i4 : FiniteTemplate HasSnaky 8 required_657_i4 envelope_657_i4 := by + refine finite_compose HasSnaky 7 childrenC_657_i4 childrenD_657_i4 finite_children_work_657_i4 (3, 4) + required_657_i4 envelope_657_i4 pivot_mem_657_i4 child_required_sub_657_i4 child_envelope_sub_657_i4 ?_ + intro b hb + exact common_sub_657_i4 (mem_commonEnvelope childrenD_657_i4 b hb) + +theorem finite_children_work_657_i3 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_657_i3 j) (childrenD_657_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_85 5 (8, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_85 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_411 4 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_537 5 (8, 2)).mono (by decide +kernel) + · exact finite_row_works_657_i4.mono (by decide +kernel) + +theorem finite_row_works_657_i3 : FiniteTemplate HasSnaky 11 required_657_i3 envelope_657_i3 := by + refine finite_compose HasSnaky 10 childrenC_657_i3 childrenD_657_i3 finite_children_work_657_i3 (5, 4) + required_657_i3 envelope_657_i3 pivot_mem_657_i3 child_required_sub_657_i3 child_envelope_sub_657_i3 ?_ + intro b hb + exact common_sub_657_i3 (mem_commonEnvelope childrenD_657_i3 b hb) + +theorem finite_children_work_657_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_657_i0 j) (childrenD_657_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_510 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_631 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_653 1 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_657_i1.mono (by decide +kernel) + · exact finite_row_works_657_i2.mono (by decide +kernel) + · exact finite_row_works_657_i3.mono (by decide +kernel) + +theorem finite_row_works_657_i0 : FiniteTemplate HasSnaky 12 required_657_i0 envelope_657_i0 := by + refine finite_compose HasSnaky 11 childrenC_657_i0 childrenD_657_i0 finite_children_work_657_i0 (4, 4) + required_657_i0 envelope_657_i0 pivot_mem_657_i0 child_required_sub_657_i0 child_envelope_sub_657_i0 ?_ + intro b hb + exact common_sub_657_i0 (mem_commonEnvelope childrenD_657_i0 b hb) + +theorem finite_children_work_657 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_657 j) (childrenD_657 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_50 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_125 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_478 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_482 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_657_i0.mono (by decide +kernel) + +theorem finite_row_works_657 : FiniteTemplate HasSnaky 13 required_657 envelope_657 := by + refine finite_compose HasSnaky 12 childrenC_657 childrenD_657 finite_children_work_657 (4, 3) + required_657 envelope_657 pivot_mem_657 child_required_sub_657 child_envelope_sub_657 ?_ + intro b hb + exact common_sub_657 (mem_commonEnvelope childrenD_657 b hb) + +theorem finite_children_work_665_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_665_i0 j) (childrenD_665_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_70 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_106 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_269 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_322 1 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_665_i0 : FiniteTemplate HasSnaky 10 required_665_i0 envelope_665_i0 := by + refine finite_compose HasSnaky 9 childrenC_665_i0 childrenD_665_i0 finite_children_work_665_i0 (4, 7) + required_665_i0 envelope_665_i0 pivot_mem_665_i0 child_required_sub_665_i0 child_envelope_sub_665_i0 ?_ + intro b hb + exact common_sub_665_i0 (mem_commonEnvelope childrenD_665_i0 b hb) + +theorem finite_children_work_665_i1 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_665_i1 j) (childrenD_665_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_70 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_257 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (7, 4)).mono (by decide +kernel) + +theorem finite_row_works_665_i1 : FiniteTemplate HasSnaky 9 required_665_i1 envelope_665_i1 := by + refine finite_compose HasSnaky 8 childrenC_665_i1 childrenD_665_i1 finite_children_work_665_i1 (4, 7) + required_665_i1 envelope_665_i1 pivot_mem_665_i1 child_required_sub_665_i1 child_envelope_sub_665_i1 ?_ + intro b hb + exact common_sub_665_i1 (mem_commonEnvelope childrenD_665_i1 b hb) + +theorem finite_children_work_665_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_665_i4 j) (childrenD_665_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 7 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_93 5 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_665_i4 : FiniteTemplate HasSnaky 5 required_665_i4 envelope_665_i4 := by + refine finite_compose HasSnaky 4 childrenC_665_i4 childrenD_665_i4 finite_children_work_665_i4 (3, 7) + required_665_i4 envelope_665_i4 pivot_mem_665_i4 child_required_sub_665_i4 child_envelope_sub_665_i4 ?_ + intro b hb + exact common_sub_665_i4 (mem_commonEnvelope childrenD_665_i4 b hb) + +theorem finite_children_work_665_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_665_i3 j) (childrenD_665_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (3, 6)).mono (by decide +kernel) + · exact finite_row_works_665_i4.mono (by decide +kernel) + +theorem finite_row_works_665_i3 : FiniteTemplate HasSnaky 6 required_665_i3 envelope_665_i3 := by + refine finite_compose HasSnaky 5 childrenC_665_i3 childrenD_665_i3 finite_children_work_665_i3 (3, 4) + required_665_i3 envelope_665_i3 pivot_mem_665_i3 child_required_sub_665_i3 child_envelope_sub_665_i3 ?_ + intro b hb + exact common_sub_665_i3 (mem_commonEnvelope childrenD_665_i3 b hb) + +theorem finite_children_work_665_i2 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_665_i2 j) (childrenD_665_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_40 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_517 1 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_665_i3.mono (by decide +kernel) + +theorem finite_row_works_665_i2 : FiniteTemplate HasSnaky 12 required_665_i2 envelope_665_i2 := by + refine finite_compose HasSnaky 11 childrenC_665_i2 childrenD_665_i2 finite_children_work_665_i2 (3, 5) + required_665_i2 envelope_665_i2 pivot_mem_665_i2 child_required_sub_665_i2 child_envelope_sub_665_i2 ?_ + intro b hb + exact common_sub_665_i2 (mem_commonEnvelope childrenD_665_i2 b hb) + +theorem finite_children_work_665 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_665 j) (childrenD_665 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_459 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_588 3 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_665_i0.mono (by decide +kernel) + · exact finite_row_works_665_i1.mono (by decide +kernel) + · exact finite_row_works_665_i2.mono (by decide +kernel) + +theorem finite_row_works_665 : FiniteTemplate HasSnaky 13 required_665 envelope_665 := by + refine finite_compose HasSnaky 12 childrenC_665 childrenD_665 finite_children_work_665 (4, 5) + required_665 envelope_665 pivot_mem_665 child_required_sub_665 child_envelope_sub_665 ?_ + intro b hb + exact common_sub_665 (mem_commonEnvelope childrenD_665 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height13Part05.lean b/lean/snaky/FiniteCards/Height13Part05.lean new file mode 100644 index 0000000..0ad1655 --- /dev/null +++ b/lean/snaky/FiniteCards/Height13Part05.lean @@ -0,0 +1,293 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part05 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part05 +import FiniteCards.Height08Part01 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part03 +import FiniteCards.Height09Part07 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part02 +import FiniteCards.Height10Part06 +import FiniteCards.Height11Part01 +import FiniteCards.Height12Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_675_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_675_i0 j) (childrenD_675_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 2 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_356 0 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_364 0 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_367 2 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_671 6 (8, 9)).mono (by decide +kernel) + +theorem finite_row_works_675_i0 : FiniteTemplate HasSnaky 8 required_675_i0 envelope_675_i0 := by + refine finite_compose HasSnaky 7 childrenC_675_i0 childrenD_675_i0 finite_children_work_675_i0 (7, 7) + required_675_i0 envelope_675_i0 pivot_mem_675_i0 child_required_sub_675_i0 child_envelope_sub_675_i0 ?_ + intro b hb + exact common_sub_675_i0 (mem_commonEnvelope childrenD_675_i0 b hb) + +theorem finite_children_work_675_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_675_i1 j) (childrenD_675_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_188 0 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_190 6 (9, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_441 2 (8, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_442 2 (8, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_514 6 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_667 0 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_675_i1 : FiniteTemplate HasSnaky 10 required_675_i1 envelope_675_i1 := by + refine finite_compose HasSnaky 9 childrenC_675_i1 childrenD_675_i1 finite_children_work_675_i1 (7, 4) + required_675_i1 envelope_675_i1 pivot_mem_675_i1 child_required_sub_675_i1 child_envelope_sub_675_i1 ?_ + intro b hb + exact common_sub_675_i1 (mem_commonEnvelope childrenD_675_i1 b hb) + +theorem finite_children_work_675_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_675_i3 j) (childrenD_675_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 3 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 7 (8, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_133 1 (5, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_186 0 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_187 4 (7, 8)).mono (by decide +kernel) + +theorem finite_row_works_675_i3 : FiniteTemplate HasSnaky 6 required_675_i3 envelope_675_i3 := by + refine finite_compose HasSnaky 5 childrenC_675_i3 childrenD_675_i3 finite_children_work_675_i3 (7, 4) + required_675_i3 envelope_675_i3 pivot_mem_675_i3 child_required_sub_675_i3 child_envelope_sub_675_i3 ?_ + intro b hb + exact common_sub_675_i3 (mem_commonEnvelope childrenD_675_i3 b hb) + +theorem finite_children_work_675_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_675_i5 j) (childrenD_675_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 5 (9, 2)).mono (by decide +kernel) + +theorem finite_row_works_675_i5 : FiniteTemplate HasSnaky 6 required_675_i5 envelope_675_i5 := by + refine finite_compose HasSnaky 5 childrenC_675_i5 childrenD_675_i5 finite_children_work_675_i5 (7, 4) + required_675_i5 envelope_675_i5 pivot_mem_675_i5 child_required_sub_675_i5 child_envelope_sub_675_i5 ?_ + intro b hb + exact common_sub_675_i5 (mem_commonEnvelope childrenD_675_i5 b hb) + +theorem finite_children_work_675_i6 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_675_i6 j) (childrenD_675_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 7 (8, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_34 5 (8, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_305 7 (8, 6)).mono (by decide +kernel) + +theorem finite_row_works_675_i6 : FiniteTemplate HasSnaky 5 required_675_i6 envelope_675_i6 := by + refine finite_compose HasSnaky 4 childrenC_675_i6 childrenD_675_i6 finite_children_work_675_i6 (6, 5) + required_675_i6 envelope_675_i6 pivot_mem_675_i6 child_required_sub_675_i6 child_envelope_sub_675_i6 ?_ + intro b hb + exact common_sub_675_i6 (mem_commonEnvelope childrenD_675_i6 b hb) + +theorem finite_children_work_675_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_675_i4 j) (childrenD_675_i4 j) := by + intro j + fin_cases j + · exact finite_row_works_675_i5.mono (by decide +kernel) + · exact finite_row_works_675_i6.mono (by decide +kernel) + +theorem finite_row_works_675_i4 : FiniteTemplate HasSnaky 7 required_675_i4 envelope_675_i4 := by + refine finite_compose HasSnaky 6 childrenC_675_i4 childrenD_675_i4 finite_children_work_675_i4 (6, 6) + required_675_i4 envelope_675_i4 pivot_mem_675_i4 child_required_sub_675_i4 child_envelope_sub_675_i4 ?_ + intro b hb + exact common_sub_675_i4 (mem_commonEnvelope childrenD_675_i4 b hb) + +theorem finite_children_work_675_i2 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_675_i2 j) (childrenD_675_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_304 4 (6, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_672 6 (8, 7)).mono (by decide +kernel) + · exact finite_row_works_675_i3.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_674 3 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_675_i4.mono (by decide +kernel) + +theorem finite_row_works_675_i2 : FiniteTemplate HasSnaky 11 required_675_i2 envelope_675_i2 := by + refine finite_compose HasSnaky 10 childrenC_675_i2 childrenD_675_i2 finite_children_work_675_i2 (7, 3) + required_675_i2 envelope_675_i2 pivot_mem_675_i2 child_required_sub_675_i2 child_envelope_sub_675_i2 ?_ + intro b hb + exact common_sub_675_i2 (mem_commonEnvelope childrenD_675_i2 b hb) + +theorem finite_children_work_675_i7 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_675_i7 j) (childrenD_675_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_190 0 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_190 2 (9, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_363 0 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_671 6 (8, 9)).mono (by decide +kernel) + +theorem finite_row_works_675_i7 : FiniteTemplate HasSnaky 8 required_675_i7 envelope_675_i7 := by + refine finite_compose HasSnaky 7 childrenC_675_i7 childrenD_675_i7 finite_children_work_675_i7 (7, 7) + required_675_i7 envelope_675_i7 pivot_mem_675_i7 child_required_sub_675_i7 child_envelope_sub_675_i7 ?_ + intro b hb + exact common_sub_675_i7 (mem_commonEnvelope childrenD_675_i7 b hb) + +theorem finite_children_work_675_i8 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_675_i8 j) (childrenD_675_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_34 5 (8, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_97 3 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_535 4 (5, 10)).mono (by decide +kernel) + +theorem finite_row_works_675_i8 : FiniteTemplate HasSnaky 11 required_675_i8 envelope_675_i8 := by + refine finite_compose HasSnaky 10 childrenC_675_i8 childrenD_675_i8 finite_children_work_675_i8 (6, 5) + required_675_i8 envelope_675_i8 pivot_mem_675_i8 child_required_sub_675_i8 child_envelope_sub_675_i8 ?_ + intro b hb + exact common_sub_675_i8 (mem_commonEnvelope childrenD_675_i8 b hb) + +theorem finite_children_work_675_i10 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_675_i10 j) (childrenD_675_i10 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_321 3 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_354 5 (8, 3)).mono (by decide +kernel) + +theorem finite_row_works_675_i10 : FiniteTemplate HasSnaky 9 required_675_i10 envelope_675_i10 := by + refine finite_compose HasSnaky 8 childrenC_675_i10 childrenD_675_i10 finite_children_work_675_i10 (7, 4) + required_675_i10 envelope_675_i10 pivot_mem_675_i10 child_required_sub_675_i10 child_envelope_sub_675_i10 ?_ + intro b hb + exact common_sub_675_i10 (mem_commonEnvelope childrenD_675_i10 b hb) + +theorem finite_children_work_675_i9 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_675_i9 j) (childrenD_675_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_328 3 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_330 3 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_384 4 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_672 6 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_674 3 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_675_i10.mono (by decide +kernel) + +theorem finite_row_works_675_i9 : FiniteTemplate HasSnaky 11 required_675_i9 envelope_675_i9 := by + refine finite_compose HasSnaky 10 childrenC_675_i9 childrenD_675_i9 finite_children_work_675_i9 (7, 3) + required_675_i9 envelope_675_i9 pivot_mem_675_i9 child_required_sub_675_i9 child_envelope_sub_675_i9 ?_ + intro b hb + exact common_sub_675_i9 (mem_commonEnvelope childrenD_675_i9 b hb) + +theorem finite_children_work_675 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_675 j) (childrenD_675 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_459 0 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_618 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_629 2 (10, 2)).mono (by decide +kernel) + · exact finite_row_works_675_i0.mono (by decide +kernel) + · exact finite_row_works_675_i1.mono (by decide +kernel) + · exact finite_row_works_675_i2.mono (by decide +kernel) + · exact finite_row_works_675_i7.mono (by decide +kernel) + · exact finite_row_works_675_i8.mono (by decide +kernel) + · exact finite_row_works_675_i9.mono (by decide +kernel) + +theorem finite_row_works_675 : FiniteTemplate HasSnaky 13 required_675 envelope_675 := by + refine finite_compose HasSnaky 12 childrenC_675 childrenD_675 finite_children_work_675 (7, 6) + required_675 envelope_675 pivot_mem_675 child_required_sub_675 child_envelope_sub_675 ?_ + intro b hb + exact common_sub_675 (mem_commonEnvelope childrenD_675 b hb) + +theorem finite_children_work_690_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_690_i0 j) (childrenD_690_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_39 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_80 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_463 1 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_690_i0 : FiniteTemplate HasSnaky 12 required_690_i0 envelope_690_i0 := by + refine finite_compose HasSnaky 11 childrenC_690_i0 childrenD_690_i0 finite_children_work_690_i0 (3, 6) + required_690_i0 envelope_690_i0 pivot_mem_690_i0 child_required_sub_690_i0 child_envelope_sub_690_i0 ?_ + intro b hb + exact common_sub_690_i0 (mem_commonEnvelope childrenD_690_i0 b hb) + +theorem finite_children_work_690 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_690 j) (childrenD_690 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_56 6 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_690_i0.mono (by decide +kernel) + +theorem finite_row_works_690 : FiniteTemplate HasSnaky 13 required_690 envelope_690 := by + refine finite_compose HasSnaky 12 childrenC_690 childrenD_690 finite_children_work_690 (3, 4) + required_690 envelope_690 pivot_mem_690 child_required_sub_690 child_envelope_sub_690 ?_ + intro b hb + exact common_sub_690 (mem_commonEnvelope childrenD_690 b hb) + +theorem finite_children_work_692_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_692_i1 j) (childrenD_692_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_118 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_192 2 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_193 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_396 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 7 (6, 6)).mono (by decide +kernel) + +theorem finite_row_works_692_i1 : FiniteTemplate HasSnaky 10 required_692_i1 envelope_692_i1 := by + refine finite_compose HasSnaky 9 childrenC_692_i1 childrenD_692_i1 finite_children_work_692_i1 (3, 3) + required_692_i1 envelope_692_i1 pivot_mem_692_i1 child_required_sub_692_i1 child_envelope_sub_692_i1 ?_ + intro b hb + exact common_sub_692_i1 (mem_commonEnvelope childrenD_692_i1 b hb) + +theorem finite_children_work_692_i2 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_692_i2 j) (childrenD_692_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_509 4 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_692_i2 : FiniteTemplate HasSnaky 11 required_692_i2 envelope_692_i2 := by + refine finite_compose HasSnaky 10 childrenC_692_i2 childrenD_692_i2 finite_children_work_692_i2 (4, 4) + required_692_i2 envelope_692_i2 pivot_mem_692_i2 child_required_sub_692_i2 child_envelope_sub_692_i2 ?_ + intro b hb + exact common_sub_692_i2 (mem_commonEnvelope childrenD_692_i2 b hb) + +theorem finite_children_work_692_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_692_i0 j) (childrenD_692_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_110 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_119 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_399 4 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_430 0 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_461 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_475 4 (1, 8)).mono (by decide +kernel) + · exact finite_row_works_692_i1.mono (by decide +kernel) + · exact finite_row_works_692_i2.mono (by decide +kernel) + +theorem finite_row_works_692_i0 : FiniteTemplate HasSnaky 12 required_692_i0 envelope_692_i0 := by + refine finite_compose HasSnaky 11 childrenC_692_i0 childrenD_692_i0 finite_children_work_692_i0 (3, 4) + required_692_i0 envelope_692_i0 pivot_mem_692_i0 child_required_sub_692_i0 child_envelope_sub_692_i0 ?_ + intro b hb + exact common_sub_692_i0 (mem_commonEnvelope childrenD_692_i0 b hb) + +theorem finite_children_work_692 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_692 j) (childrenD_692 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_692_i0.mono (by decide +kernel) + +theorem finite_row_works_692 : FiniteTemplate HasSnaky 13 required_692 envelope_692 := by + refine finite_compose HasSnaky 12 childrenC_692 childrenD_692 finite_children_work_692 (1, 5) + required_692 envelope_692 pivot_mem_692 child_required_sub_692 child_envelope_sub_692 ?_ + intro b hb + exact common_sub_692 (mem_commonEnvelope childrenD_692 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height13Part06.lean b/lean/snaky/FiniteCards/Height13Part06.lean new file mode 100644 index 0000000..2de1210 --- /dev/null +++ b/lean/snaky/FiniteCards/Height13Part06.lean @@ -0,0 +1,278 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part06 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part03 +import FiniteCards.Height09Part07 +import FiniteCards.Height09Part08 +import FiniteCards.Height10Part02 +import FiniteCards.Height11Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_695_i6 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_695_i6 j) (childrenD_695_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 0 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_75 2 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_103 4 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_695_i6 : FiniteTemplate HasSnaky 5 required_695_i6 envelope_695_i6 := by + refine finite_compose HasSnaky 4 childrenC_695_i6 childrenD_695_i6 finite_children_work_695_i6 (1, 6) + required_695_i6 envelope_695_i6 pivot_mem_695_i6 child_required_sub_695_i6 child_envelope_sub_695_i6 ?_ + intro b hb + exact common_sub_695_i6 (mem_commonEnvelope childrenD_695_i6 b hb) + +theorem finite_children_work_695_i7 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_695_i7 j) (childrenD_695_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 0 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_17 2 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_90 7 (2, 7)).mono (by decide +kernel) + +theorem finite_row_works_695_i7 : FiniteTemplate HasSnaky 5 required_695_i7 envelope_695_i7 := by + refine finite_compose HasSnaky 4 childrenC_695_i7 childrenD_695_i7 finite_children_work_695_i7 (1, 6) + required_695_i7 envelope_695_i7 pivot_mem_695_i7 child_required_sub_695_i7 child_envelope_sub_695_i7 ?_ + intro b hb + exact common_sub_695_i7 (mem_commonEnvelope childrenD_695_i7 b hb) + +theorem finite_children_work_695_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_695_i5 j) (childrenD_695_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_308 6 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_348 5 (5, 5)).mono (by decide +kernel) + · exact finite_row_works_695_i6.mono (by decide +kernel) + · exact finite_row_works_695_i7.mono (by decide +kernel) + +theorem finite_row_works_695_i5 : FiniteTemplate HasSnaky 7 required_695_i5 envelope_695_i5 := by + refine finite_compose HasSnaky 6 childrenC_695_i5 childrenD_695_i5 finite_children_work_695_i5 (1, 7) + required_695_i5 envelope_695_i5 pivot_mem_695_i5 child_required_sub_695_i5 child_envelope_sub_695_i5 ?_ + intro b hb + exact common_sub_695_i5 (mem_commonEnvelope childrenD_695_i5 b hb) + +theorem finite_children_work_695_i4 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_695_i4 j) (childrenD_695_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 5)).mono (by decide +kernel) + · exact finite_row_works_695_i5.mono (by decide +kernel) + +theorem finite_row_works_695_i4 : FiniteTemplate HasSnaky 8 required_695_i4 envelope_695_i4 := by + refine finite_compose HasSnaky 7 childrenC_695_i4 childrenD_695_i4 finite_children_work_695_i4 (1, 4) + required_695_i4 envelope_695_i4 pivot_mem_695_i4 child_required_sub_695_i4 child_envelope_sub_695_i4 ?_ + intro b hb + exact common_sub_695_i4 (mem_commonEnvelope childrenD_695_i4 b hb) + +theorem finite_children_work_695_i3 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_695_i3 j) (childrenD_695_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_96 0 (1, 4)).mono (by decide +kernel) + · exact finite_row_works_695_i4.mono (by decide +kernel) + +theorem finite_row_works_695_i3 : FiniteTemplate HasSnaky 9 required_695_i3 envelope_695_i3 := by + refine finite_compose HasSnaky 8 childrenC_695_i3 childrenD_695_i3 finite_children_work_695_i3 (3, 8) + required_695_i3 envelope_695_i3 pivot_mem_695_i3 child_required_sub_695_i3 child_envelope_sub_695_i3 ?_ + intro b hb + exact common_sub_695_i3 (mem_commonEnvelope childrenD_695_i3 b hb) + +theorem finite_children_work_695_i2 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_695_i2 j) (childrenD_695_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 0 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_695_i3.mono (by decide +kernel) + +theorem finite_row_works_695_i2 : FiniteTemplate HasSnaky 10 required_695_i2 envelope_695_i2 := by + refine finite_compose HasSnaky 9 childrenC_695_i2 childrenD_695_i2 finite_children_work_695_i2 (1, 5) + required_695_i2 envelope_695_i2 pivot_mem_695_i2 child_required_sub_695_i2 child_envelope_sub_695_i2 ?_ + intro b hb + exact common_sub_695_i2 (mem_commonEnvelope childrenD_695_i2 b hb) + +theorem finite_children_work_695_i1 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_695_i1 j) (childrenD_695_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_67 2 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_175 6 (5, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_228 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_688 1 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_695_i2.mono (by decide +kernel) + +theorem finite_row_works_695_i1 : FiniteTemplate HasSnaky 11 required_695_i1 envelope_695_i1 := by + refine finite_compose HasSnaky 10 childrenC_695_i1 childrenD_695_i1 finite_children_work_695_i1 (4, 7) + required_695_i1 envelope_695_i1 pivot_mem_695_i1 child_required_sub_695_i1 child_envelope_sub_695_i1 ?_ + intro b hb + exact common_sub_695_i1 (mem_commonEnvelope childrenD_695_i1 b hb) + +theorem finite_children_work_695_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_695_i0 j) (childrenD_695_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 1 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_324 2 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_686 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_695_i1.mono (by decide +kernel) + +theorem finite_row_works_695_i0 : FiniteTemplate HasSnaky 12 required_695_i0 envelope_695_i0 := by + refine finite_compose HasSnaky 11 childrenC_695_i0 childrenD_695_i0 finite_children_work_695_i0 (4, 6) + required_695_i0 envelope_695_i0 pivot_mem_695_i0 child_required_sub_695_i0 child_envelope_sub_695_i0 ?_ + intro b hb + exact common_sub_695_i0 (mem_commonEnvelope childrenD_695_i0 b hb) + +theorem finite_children_work_695 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_695 j) (childrenD_695 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_118 4 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_135 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_182 3 (0, 7)).mono (by decide +kernel) + · exact finite_row_works_695_i0.mono (by decide +kernel) + +theorem finite_row_works_695 : FiniteTemplate HasSnaky 13 required_695 envelope_695 := by + refine finite_compose HasSnaky 12 childrenC_695 childrenD_695 finite_children_work_695 (4, 5) + required_695 envelope_695 pivot_mem_695 child_required_sub_695 child_envelope_sub_695 ?_ + intro b hb + exact common_sub_695 (mem_commonEnvelope childrenD_695 b hb) + +theorem finite_children_work_696_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_696_i1 j) (childrenD_696_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 7 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 5 (6, 4)).mono (by decide +kernel) + +theorem finite_row_works_696_i1 : FiniteTemplate HasSnaky 6 required_696_i1 envelope_696_i1 := by + refine finite_compose HasSnaky 5 childrenC_696_i1 childrenD_696_i1 finite_children_work_696_i1 (5, 7) + required_696_i1 envelope_696_i1 pivot_mem_696_i1 child_required_sub_696_i1 child_envelope_sub_696_i1 ?_ + intro b hb + exact common_sub_696_i1 (mem_commonEnvelope childrenD_696_i1 b hb) + +theorem finite_children_work_696_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_696_i0 j) (childrenD_696_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_317 3 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_696_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_436 7 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_685 6 (8, 9)).mono (by decide +kernel) + +theorem finite_row_works_696_i0 : FiniteTemplate HasSnaky 12 required_696_i0 envelope_696_i0 := by + refine finite_compose HasSnaky 11 childrenC_696_i0 childrenD_696_i0 finite_children_work_696_i0 (4, 4) + required_696_i0 envelope_696_i0 pivot_mem_696_i0 child_required_sub_696_i0 child_envelope_sub_696_i0 ?_ + intro b hb + exact common_sub_696_i0 (mem_commonEnvelope childrenD_696_i0 b hb) + +theorem finite_children_work_696 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_696 j) (childrenD_696 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 6 (6, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_322 7 (9, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_369 2 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 7 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_622 0 (2, 1)).mono (by decide +kernel) + · exact finite_row_works_696_i0.mono (by decide +kernel) + +theorem finite_row_works_696 : FiniteTemplate HasSnaky 13 required_696 envelope_696 := by + refine finite_compose HasSnaky 12 childrenC_696 childrenD_696 finite_children_work_696 (5, 4) + required_696 envelope_696 pivot_mem_696 child_required_sub_696 child_envelope_sub_696 ?_ + intro b hb + exact common_sub_696 (mem_commonEnvelope childrenD_696 b hb) + +theorem finite_children_work_709_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_709_i2 j) (childrenD_709_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 1 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_56 3 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_392 0 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_709_i2 : FiniteTemplate HasSnaky 7 required_709_i2 envelope_709_i2 := by + refine finite_compose HasSnaky 6 childrenC_709_i2 childrenD_709_i2 finite_children_work_709_i2 (4, 5) + required_709_i2 envelope_709_i2 pivot_mem_709_i2 child_required_sub_709_i2 child_envelope_sub_709_i2 ?_ + intro b hb + exact common_sub_709_i2 (mem_commonEnvelope childrenD_709_i2 b hb) + +theorem finite_children_work_709_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_709_i1 j) (childrenD_709_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 4 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_253 7 (8, 7)).mono (by decide +kernel) + · exact finite_row_works_709_i2.mono (by decide +kernel) + +theorem finite_row_works_709_i1 : FiniteTemplate HasSnaky 8 required_709_i1 envelope_709_i1 := by + refine finite_compose HasSnaky 7 childrenC_709_i1 childrenD_709_i1 finite_children_work_709_i1 (5, 4) + required_709_i1 envelope_709_i1 pivot_mem_709_i1 child_required_sub_709_i1 child_envelope_sub_709_i1 ?_ + intro b hb + exact common_sub_709_i1 (mem_commonEnvelope childrenD_709_i1 b hb) + +theorem finite_children_work_709_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_709_i4 j) (childrenD_709_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 4 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_89 6 (6, 6)).mono (by decide +kernel) + +theorem finite_row_works_709_i4 : FiniteTemplate HasSnaky 5 required_709_i4 envelope_709_i4 := by + refine finite_compose HasSnaky 4 childrenC_709_i4 childrenD_709_i4 finite_children_work_709_i4 (5, 3) + required_709_i4 envelope_709_i4 pivot_mem_709_i4 child_required_sub_709_i4 child_envelope_sub_709_i4 ?_ + intro b hb + exact common_sub_709_i4 (mem_commonEnvelope childrenD_709_i4 b hb) + +theorem finite_children_work_709_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_709_i3 j) (childrenD_709_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 4 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_521 4 (4, 8)).mono (by decide +kernel) + · exact finite_row_works_709_i4.mono (by decide +kernel) + +theorem finite_row_works_709_i3 : FiniteTemplate HasSnaky 7 required_709_i3 envelope_709_i3 := by + refine finite_compose HasSnaky 6 childrenC_709_i3 childrenD_709_i3 finite_children_work_709_i3 (5, 4) + required_709_i3 envelope_709_i3 pivot_mem_709_i3 child_required_sub_709_i3 child_envelope_sub_709_i3 ?_ + intro b hb + exact common_sub_709_i3 (mem_commonEnvelope childrenD_709_i3 b hb) + +theorem finite_children_work_709_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_709_i0 j) (childrenD_709_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_524 5 (9, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_536 7 (9, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_545 7 (10, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_655 5 (10, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_664 4 (1, 11)).mono (by decide +kernel) + · exact finite_row_works_709_i1.mono (by decide +kernel) + · exact finite_row_works_709_i3.mono (by decide +kernel) + +theorem finite_row_works_709_i0 : FiniteTemplate HasSnaky 12 required_709_i0 envelope_709_i0 := by + refine finite_compose HasSnaky 11 childrenC_709_i0 childrenD_709_i0 finite_children_work_709_i0 (6, 6) + required_709_i0 envelope_709_i0 pivot_mem_709_i0 child_required_sub_709_i0 child_envelope_sub_709_i0 ?_ + intro b hb + exact common_sub_709_i0 (mem_commonEnvelope childrenD_709_i0 b hb) + +theorem finite_children_work_709 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_709 j) (childrenD_709 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_116 5 (8, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 5 (7, 4)).mono (by decide +kernel) + · exact finite_row_works_709_i0.mono (by decide +kernel) + +theorem finite_row_works_709 : FiniteTemplate HasSnaky 13 required_709 envelope_709 := by + refine finite_compose HasSnaky 12 childrenC_709 childrenD_709 finite_children_work_709 (5, 7) + required_709 envelope_709 pivot_mem_709 child_required_sub_709 child_envelope_sub_709 ?_ + intro b hb + exact common_sub_709 (mem_commonEnvelope childrenD_709 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height13Part07.lean b/lean/snaky/FiniteCards/Height13Part07.lean new file mode 100644 index 0000000..610cad3 --- /dev/null +++ b/lean/snaky/FiniteCards/Height13Part07.lean @@ -0,0 +1,114 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part07 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height09Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_720_i0 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_720_i0 j) (childrenD_720_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 7 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_200 1 (3, 5)).mono (by decide +kernel) + +theorem finite_row_works_720_i0 : FiniteTemplate HasSnaky 7 required_720_i0 envelope_720_i0 := by + refine finite_compose HasSnaky 6 childrenC_720_i0 childrenD_720_i0 finite_children_work_720_i0 (3, 5) + required_720_i0 envelope_720_i0 pivot_mem_720_i0 child_required_sub_720_i0 child_envelope_sub_720_i0 ?_ + intro b hb + exact common_sub_720_i0 (mem_commonEnvelope childrenD_720_i0 b hb) + +theorem finite_children_work_720_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_720_i4 j) (childrenD_720_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 2 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_315 1 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_720_i4 : FiniteTemplate HasSnaky 7 required_720_i4 envelope_720_i4 := by + refine finite_compose HasSnaky 6 childrenC_720_i4 childrenD_720_i4 finite_children_work_720_i4 (6, 7) + required_720_i4 envelope_720_i4 pivot_mem_720_i4 child_required_sub_720_i4 child_envelope_sub_720_i4 ?_ + intro b hb + exact common_sub_720_i4 (mem_commonEnvelope childrenD_720_i4 b hb) + +theorem finite_children_work_720_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_720_i5 j) (childrenD_720_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_197 7 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_201 5 (8, 4)).mono (by decide +kernel) + +theorem finite_row_works_720_i5 : FiniteTemplate HasSnaky 6 required_720_i5 envelope_720_i5 := by + refine finite_compose HasSnaky 5 childrenC_720_i5 childrenD_720_i5 finite_children_work_720_i5 (7, 4) + required_720_i5 envelope_720_i5 pivot_mem_720_i5 child_required_sub_720_i5 child_envelope_sub_720_i5 ?_ + intro b hb + exact common_sub_720_i5 (mem_commonEnvelope childrenD_720_i5 b hb) + +theorem finite_children_work_720_i3 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_720_i3 j) (childrenD_720_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 2 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_13 2 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_369 6 (8, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 1 (5, 4)).mono (by decide +kernel) + · exact finite_row_works_720_i4.mono (by decide +kernel) + · exact finite_row_works_720_i5.mono (by decide +kernel) + +theorem finite_row_works_720_i3 : FiniteTemplate HasSnaky 10 required_720_i3 envelope_720_i3 := by + refine finite_compose HasSnaky 9 childrenC_720_i3 childrenD_720_i3 finite_children_work_720_i3 (7, 7) + required_720_i3 envelope_720_i3 pivot_mem_720_i3 child_required_sub_720_i3 child_envelope_sub_720_i3 ?_ + intro b hb + exact common_sub_720_i3 (mem_commonEnvelope childrenD_720_i3 b hb) + +theorem finite_children_work_720_i2 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_720_i2 j) (childrenD_720_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (5, 8)).mono (by decide +kernel) + · exact finite_row_works_720_i3.mono (by decide +kernel) + +theorem finite_row_works_720_i2 : FiniteTemplate HasSnaky 11 required_720_i2 envelope_720_i2 := by + refine finite_compose HasSnaky 10 childrenC_720_i2 childrenD_720_i2 finite_children_work_720_i2 (5, 7) + required_720_i2 envelope_720_i2 pivot_mem_720_i2 child_required_sub_720_i2 child_envelope_sub_720_i2 ?_ + intro b hb + exact common_sub_720_i2 (mem_commonEnvelope childrenD_720_i2 b hb) + +theorem finite_children_work_720_i1 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_720_i1 j) (childrenD_720_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_40 1 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_310 1 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_720_i2.mono (by decide +kernel) + +theorem finite_row_works_720_i1 : FiniteTemplate HasSnaky 12 required_720_i1 envelope_720_i1 := by + refine finite_compose HasSnaky 11 childrenC_720_i1 childrenD_720_i1 finite_children_work_720_i1 (7, 5) + required_720_i1 envelope_720_i1 pivot_mem_720_i1 child_required_sub_720_i1 child_envelope_sub_720_i1 ?_ + intro b hb + exact common_sub_720_i1 (mem_commonEnvelope childrenD_720_i1 b hb) + +theorem finite_children_work_720 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_720 j) (childrenD_720 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 7 (8, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_64 7 (8, 6)).mono (by decide +kernel) + · exact finite_row_works_720_i0.mono (by decide +kernel) + · exact finite_row_works_720_i1.mono (by decide +kernel) + +theorem finite_row_works_720 : FiniteTemplate HasSnaky 13 required_720 envelope_720 := by + refine finite_compose HasSnaky 12 childrenC_720 childrenD_720 finite_children_work_720 (7, 6) + required_720 envelope_720 pivot_mem_720 child_required_sub_720 child_envelope_sub_720 ?_ + intro b hb + exact common_sub_720 (mem_commonEnvelope childrenD_720 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height14Part01.lean b/lean/snaky/FiniteCards/Height14Part01.lean new file mode 100644 index 0000000..a816fda --- /dev/null +++ b/lean/snaky/FiniteCards/Height14Part01.lean @@ -0,0 +1,325 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part05 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part02 +import FiniteCards.Height10Part01 +import FiniteCards.Height13Part01 +import FiniteCards.Height13Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_553_i3 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_553_i3 j) (childrenD_553_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 7 (5, 7)).mono (by decide +kernel) + +theorem finite_row_works_553_i3 : FiniteTemplate HasSnaky 2 required_553_i3 envelope_553_i3 := by + refine finite_compose HasSnaky 1 childrenC_553_i3 childrenD_553_i3 finite_children_work_553_i3 (5, 7) + required_553_i3 envelope_553_i3 pivot_mem_553_i3 child_required_sub_553_i3 child_envelope_sub_553_i3 ?_ + intro b hb + exact common_sub_553_i3 (mem_commonEnvelope childrenD_553_i3 b hb) + +theorem finite_children_work_553_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_553_i2 j) (childrenD_553_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 6 (6, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_553_i3.mono (by decide +kernel) + +theorem finite_row_works_553_i2 : FiniteTemplate HasSnaky 5 required_553_i2 envelope_553_i2 := by + refine finite_compose HasSnaky 4 childrenC_553_i2 childrenD_553_i2 finite_children_work_553_i2 (5, 5) + required_553_i2 envelope_553_i2 pivot_mem_553_i2 child_required_sub_553_i2 child_envelope_sub_553_i2 ?_ + intro b hb + exact common_sub_553_i2 (mem_commonEnvelope childrenD_553_i2 b hb) + +theorem finite_children_work_553_i1 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_553_i1 j) (childrenD_553_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 2 (7, 6)).mono (by decide +kernel) + · exact finite_row_works_553_i2.mono (by decide +kernel) + +theorem finite_row_works_553_i1 : FiniteTemplate HasSnaky 6 required_553_i1 envelope_553_i1 := by + refine finite_compose HasSnaky 5 childrenC_553_i1 childrenD_553_i1 finite_children_work_553_i1 (5, 6) + required_553_i1 envelope_553_i1 pivot_mem_553_i1 child_required_sub_553_i1 child_envelope_sub_553_i1 ?_ + intro b hb + exact common_sub_553_i1 (mem_commonEnvelope childrenD_553_i1 b hb) + +theorem finite_children_work_553_i6 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_553_i6 j) (childrenD_553_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 7 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_145 0 (4, 3)).mono (by decide +kernel) + +theorem finite_row_works_553_i6 : FiniteTemplate HasSnaky 6 required_553_i6 envelope_553_i6 := by + refine finite_compose HasSnaky 5 childrenC_553_i6 childrenD_553_i6 finite_children_work_553_i6 (6, 4) + required_553_i6 envelope_553_i6 pivot_mem_553_i6 child_required_sub_553_i6 child_envelope_sub_553_i6 ?_ + intro b hb + exact common_sub_553_i6 (mem_commonEnvelope childrenD_553_i6 b hb) + +theorem finite_children_work_553_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_553_i5 j) (childrenD_553_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_158 3 (2, 4)).mono (by decide +kernel) + · exact finite_row_works_553_i6.mono (by decide +kernel) + +theorem finite_row_works_553_i5 : FiniteTemplate HasSnaky 7 required_553_i5 envelope_553_i5 := by + refine finite_compose HasSnaky 6 childrenC_553_i5 childrenD_553_i5 finite_children_work_553_i5 (7, 4) + required_553_i5 envelope_553_i5 pivot_mem_553_i5 child_required_sub_553_i5 child_envelope_sub_553_i5 ?_ + intro b hb + exact common_sub_553_i5 (mem_commonEnvelope childrenD_553_i5 b hb) + +theorem finite_children_work_553_i4 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_553_i4 j) (childrenD_553_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (3, 7)).mono (by decide +kernel) + · exact finite_row_works_553_i5.mono (by decide +kernel) + +theorem finite_row_works_553_i4 : FiniteTemplate HasSnaky 8 required_553_i4 envelope_553_i4 := by + refine finite_compose HasSnaky 7 childrenC_553_i4 childrenD_553_i4 finite_children_work_553_i4 (6, 7) + required_553_i4 envelope_553_i4 pivot_mem_553_i4 child_required_sub_553_i4 child_envelope_sub_553_i4 ?_ + intro b hb + exact common_sub_553_i4 (mem_commonEnvelope childrenD_553_i4 b hb) + +theorem finite_children_work_553_i8 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_553_i8 j) (childrenD_553_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_54 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_247 3 (2, 7)).mono (by decide +kernel) + +theorem finite_row_works_553_i8 : FiniteTemplate HasSnaky 4 required_553_i8 envelope_553_i8 := by + refine finite_compose HasSnaky 3 childrenC_553_i8 childrenD_553_i8 finite_children_work_553_i8 (4, 3) + required_553_i8 envelope_553_i8 pivot_mem_553_i8 child_required_sub_553_i8 child_envelope_sub_553_i8 ?_ + intro b hb + exact common_sub_553_i8 (mem_commonEnvelope childrenD_553_i8 b hb) + +theorem finite_children_work_553_i7 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_553_i7 j) (childrenD_553_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 2 (7, 6)).mono (by decide +kernel) + · exact finite_row_works_553_i8.mono (by decide +kernel) + +theorem finite_row_works_553_i7 : FiniteTemplate HasSnaky 5 required_553_i7 envelope_553_i7 := by + refine finite_compose HasSnaky 4 childrenC_553_i7 childrenD_553_i7 finite_children_work_553_i7 (5, 6) + required_553_i7 envelope_553_i7 pivot_mem_553_i7 child_required_sub_553_i7 child_envelope_sub_553_i7 ?_ + intro b hb + exact common_sub_553_i7 (mem_commonEnvelope childrenD_553_i7 b hb) + +theorem finite_children_work_553_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_553_i0 j) (childrenD_553_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_433 3 (2, 7)).mono (by decide +kernel) + · exact finite_row_works_553_i1.mono (by decide +kernel) + · exact finite_row_works_553_i4.mono (by decide +kernel) + · exact finite_row_works_553_i7.mono (by decide +kernel) + +theorem finite_row_works_553_i0 : FiniteTemplate HasSnaky 9 required_553_i0 envelope_553_i0 := by + refine finite_compose HasSnaky 8 childrenC_553_i0 childrenD_553_i0 finite_children_work_553_i0 (5, 4) + required_553_i0 envelope_553_i0 pivot_mem_553_i0 child_required_sub_553_i0 child_envelope_sub_553_i0 ?_ + intro b hb + exact common_sub_553_i0 (mem_commonEnvelope childrenD_553_i0 b hb) + +theorem finite_children_work_553 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_553 j) (childrenD_553 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_107 3 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_163 3 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_538 0 (2, 1)).mono (by decide +kernel) + · exact finite_row_works_552.mono (by decide +kernel) + · exact finite_row_works_553_i0.mono (by decide +kernel) + +theorem finite_row_works_553 : FiniteTemplate HasSnaky 14 required_553 envelope_553 := by + refine finite_compose HasSnaky 13 childrenC_553 childrenD_553 finite_children_work_553 (7, 6) + required_553 envelope_553 pivot_mem_553 child_required_sub_553 child_envelope_sub_553 ?_ + intro b hb + exact common_sub_553 (mem_commonEnvelope childrenD_553 b hb) + +theorem finite_children_work_557_i0 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_557_i0 j) (childrenD_557_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 6 (5, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_28 7 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_58 4 (1, 8)).mono (by decide +kernel) + +theorem finite_row_works_557_i0 : FiniteTemplate HasSnaky 5 required_557_i0 envelope_557_i0 := by + refine finite_compose HasSnaky 4 childrenC_557_i0 childrenD_557_i0 finite_children_work_557_i0 (4, 7) + required_557_i0 envelope_557_i0 pivot_mem_557_i0 child_required_sub_557_i0 child_envelope_sub_557_i0 ?_ + intro b hb + exact common_sub_557_i0 (mem_commonEnvelope childrenD_557_i0 b hb) + +theorem finite_children_work_557_i4 : ∀ j, FiniteTemplate HasSnaky 1 (childrenC_557_i4 j) (childrenD_557_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_5 6 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_557_i4 : FiniteTemplate HasSnaky 2 required_557_i4 envelope_557_i4 := by + refine finite_compose HasSnaky 1 childrenC_557_i4 childrenD_557_i4 finite_children_work_557_i4 (1, 5) + required_557_i4 envelope_557_i4 pivot_mem_557_i4 child_required_sub_557_i4 child_envelope_sub_557_i4 ?_ + intro b hb + exact common_sub_557_i4 (mem_commonEnvelope childrenD_557_i4 b hb) + +theorem finite_children_work_557_i6 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_557_i6 j) (childrenD_557_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 7 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_392 7 (5, 4)).mono (by decide +kernel) + +theorem finite_row_works_557_i6 : FiniteTemplate HasSnaky 7 required_557_i6 envelope_557_i6 := by + refine finite_compose HasSnaky 6 childrenC_557_i6 childrenD_557_i6 finite_children_work_557_i6 (3, 4) + required_557_i6 envelope_557_i6 pivot_mem_557_i6 child_required_sub_557_i6 child_envelope_sub_557_i6 ?_ + intro b hb + exact common_sub_557_i6 (mem_commonEnvelope childrenD_557_i6 b hb) + +theorem finite_children_work_557_i5 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_557_i5 j) (childrenD_557_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_11 3 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_41 1 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_557_i6.mono (by decide +kernel) + +theorem finite_row_works_557_i5 : FiniteTemplate HasSnaky 8 required_557_i5 envelope_557_i5 := by + refine finite_compose HasSnaky 7 childrenC_557_i5 childrenD_557_i5 finite_children_work_557_i5 (3, 3) + required_557_i5 envelope_557_i5 pivot_mem_557_i5 child_required_sub_557_i5 child_envelope_sub_557_i5 ?_ + intro b hb + exact common_sub_557_i5 (mem_commonEnvelope childrenD_557_i5 b hb) + +theorem finite_children_work_557_i3 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_557_i3 j) (childrenD_557_i3 j) := by + intro j + fin_cases j + · exact finite_row_works_557_i4.mono (by decide +kernel) + · exact finite_row_works_557_i5.mono (by decide +kernel) + +theorem finite_row_works_557_i3 : FiniteTemplate HasSnaky 9 required_557_i3 envelope_557_i3 := by + refine finite_compose HasSnaky 8 childrenC_557_i3 childrenD_557_i3 finite_children_work_557_i3 (2, 2) + required_557_i3 envelope_557_i3 pivot_mem_557_i3 child_required_sub_557_i3 child_envelope_sub_557_i3 ?_ + intro b hb + exact common_sub_557_i3 (mem_commonEnvelope childrenD_557_i3 b hb) + +theorem finite_children_work_557_i2 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_557_i2 j) (childrenD_557_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_42 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_152 1 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_557_i3.mono (by decide +kernel) + +theorem finite_row_works_557_i2 : FiniteTemplate HasSnaky 10 required_557_i2 envelope_557_i2 := by + refine finite_compose HasSnaky 9 childrenC_557_i2 childrenD_557_i2 finite_children_work_557_i2 (4, 3) + required_557_i2 envelope_557_i2 pivot_mem_557_i2 child_required_sub_557_i2 child_envelope_sub_557_i2 ?_ + intro b hb + exact common_sub_557_i2 (mem_commonEnvelope childrenD_557_i2 b hb) + +theorem finite_children_work_557_i1 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_557_i1 j) (childrenD_557_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (1, 6)).mono (by decide +kernel) + · exact finite_row_works_557_i2.mono (by decide +kernel) + +theorem finite_row_works_557_i1 : FiniteTemplate HasSnaky 11 required_557_i1 envelope_557_i1 := by + refine finite_compose HasSnaky 10 childrenC_557_i1 childrenD_557_i1 finite_children_work_557_i1 (3, 6) + required_557_i1 envelope_557_i1 pivot_mem_557_i1 child_required_sub_557_i1 child_envelope_sub_557_i1 ?_ + intro b hb + exact common_sub_557_i1 (mem_commonEnvelope childrenD_557_i1 b hb) + +theorem finite_children_work_557 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_557 j) (childrenD_557 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_110 0 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_119 0 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_430 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_461 0 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_555 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_557_i0.mono (by decide +kernel) + · exact finite_row_works_557_i1.mono (by decide +kernel) + +theorem finite_row_works_557 : FiniteTemplate HasSnaky 14 required_557 envelope_557 := by + refine finite_compose HasSnaky 13 childrenC_557 childrenD_557 finite_children_work_557 (4, 6) + required_557 envelope_557 pivot_mem_557 child_required_sub_557 child_envelope_sub_557 ?_ + intro b hb + exact common_sub_557 (mem_commonEnvelope childrenD_557 b hb) + +theorem finite_children_work_582_i1 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_582_i1 j) (childrenD_582_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_160 3 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_582_i1 : FiniteTemplate HasSnaky 4 required_582_i1 envelope_582_i1 := by + refine finite_compose HasSnaky 3 childrenC_582_i1 childrenD_582_i1 finite_children_work_582_i1 (5, 6) + required_582_i1 envelope_582_i1 pivot_mem_582_i1 child_required_sub_582_i1 child_envelope_sub_582_i1 ?_ + intro b hb + exact common_sub_582_i1 (mem_commonEnvelope childrenD_582_i1 b hb) + +theorem finite_children_work_582_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_582_i0 j) (childrenD_582_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_133 1 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_582_i1.mono (by decide +kernel) + +theorem finite_row_works_582_i0 : FiniteTemplate HasSnaky 6 required_582_i0 envelope_582_i0 := by + refine finite_compose HasSnaky 5 childrenC_582_i0 childrenD_582_i0 finite_children_work_582_i0 (4, 5) + required_582_i0 envelope_582_i0 pivot_mem_582_i0 child_required_sub_582_i0 child_envelope_sub_582_i0 ?_ + intro b hb + exact common_sub_582_i0 (mem_commonEnvelope childrenD_582_i0 b hb) + +theorem finite_children_work_582_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_582_i2 j) (childrenD_582_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 3 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 3 (0, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_109 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_424 1 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_582_i2 : FiniteTemplate HasSnaky 5 required_582_i2 envelope_582_i2 := by + refine finite_compose HasSnaky 4 childrenC_582_i2 childrenD_582_i2 finite_children_work_582_i2 (3, 6) + required_582_i2 envelope_582_i2 pivot_mem_582_i2 child_required_sub_582_i2 child_envelope_sub_582_i2 ?_ + intro b hb + exact common_sub_582_i2 (mem_commonEnvelope childrenD_582_i2 b hb) + +theorem finite_children_work_582_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_582_i3 j) (childrenD_582_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_383 7 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_432 5 (5, 3)).mono (by decide +kernel) + +theorem finite_row_works_582_i3 : FiniteTemplate HasSnaky 6 required_582_i3 envelope_582_i3 := by + refine finite_compose HasSnaky 5 childrenC_582_i3 childrenD_582_i3 finite_children_work_582_i3 (4, 5) + required_582_i3 envelope_582_i3 pivot_mem_582_i3 child_required_sub_582_i3 child_envelope_sub_582_i3 ?_ + intro b hb + exact common_sub_582_i3 (mem_commonEnvelope childrenD_582_i3 b hb) + +theorem finite_children_work_582 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_582 j) (childrenD_582 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_184 3 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_423 3 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_572 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_582_i0.mono (by decide +kernel) + · exact finite_row_works_582_i2.mono (by decide +kernel) + · exact finite_row_works_582_i3.mono (by decide +kernel) + +theorem finite_row_works_582 : FiniteTemplate HasSnaky 14 required_582 envelope_582 := by + refine finite_compose HasSnaky 13 childrenC_582 childrenD_582 finite_children_work_582 (4, 6) + required_582 envelope_582 pivot_mem_582 child_required_sub_582 child_envelope_sub_582 ?_ + intro b hb + exact common_sub_582 (mem_commonEnvelope childrenD_582 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height14Part02.lean b/lean/snaky/FiniteCards/Height14Part02.lean new file mode 100644 index 0000000..ac5026a --- /dev/null +++ b/lean/snaky/FiniteCards/Height14Part02.lean @@ -0,0 +1,341 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part03 +import FiniteCards.Height09Part05 +import FiniteCards.Height09Part07 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part05 +import FiniteCards.Height11Part03 +import FiniteCards.Height12Part02 +import FiniteCards.Height12Part04 +import FiniteCards.Height13Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_598_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_598_i2 j) (childrenD_598_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (6, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_133 2 (7, 3)).mono (by decide +kernel) + +theorem finite_row_works_598_i2 : FiniteTemplate HasSnaky 6 required_598_i2 envelope_598_i2 := by + refine finite_compose HasSnaky 5 childrenC_598_i2 childrenD_598_i2 finite_children_work_598_i2 (5, 5) + required_598_i2 envelope_598_i2 pivot_mem_598_i2 child_required_sub_598_i2 child_envelope_sub_598_i2 ?_ + intro b hb + exact common_sub_598_i2 (mem_commonEnvelope childrenD_598_i2 b hb) + +theorem finite_children_work_598_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_598_i1 j) (childrenD_598_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (3, 8)).mono (by decide +kernel) + · exact finite_row_works_598_i2.mono (by decide +kernel) + +theorem finite_row_works_598_i1 : FiniteTemplate HasSnaky 7 required_598_i1 envelope_598_i1 := by + refine finite_compose HasSnaky 6 childrenC_598_i1 childrenD_598_i1 finite_children_work_598_i1 (4, 5) + required_598_i1 envelope_598_i1 pivot_mem_598_i1 child_required_sub_598_i1 child_envelope_sub_598_i1 ?_ + intro b hb + exact common_sub_598_i1 (mem_commonEnvelope childrenD_598_i1 b hb) + +theorem finite_children_work_598_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_598_i0 j) (childrenD_598_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_598_i1.mono (by decide +kernel) + +theorem finite_row_works_598_i0 : FiniteTemplate HasSnaky 8 required_598_i0 envelope_598_i0 := by + refine finite_compose HasSnaky 7 childrenC_598_i0 childrenD_598_i0 finite_children_work_598_i0 (3, 6) + required_598_i0 envelope_598_i0 pivot_mem_598_i0 child_required_sub_598_i0 child_envelope_sub_598_i0 ?_ + intro b hb + exact common_sub_598_i0 (mem_commonEnvelope childrenD_598_i0 b hb) + +theorem finite_children_work_598_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_598_i5 j) (childrenD_598_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (6, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_133 6 (7, 7)).mono (by decide +kernel) + +theorem finite_row_works_598_i5 : FiniteTemplate HasSnaky 6 required_598_i5 envelope_598_i5 := by + refine finite_compose HasSnaky 5 childrenC_598_i5 childrenD_598_i5 finite_children_work_598_i5 (5, 5) + required_598_i5 envelope_598_i5 pivot_mem_598_i5 child_required_sub_598_i5 child_envelope_sub_598_i5 ?_ + intro b hb + exact common_sub_598_i5 (mem_commonEnvelope childrenD_598_i5 b hb) + +theorem finite_children_work_598_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_598_i4 j) (childrenD_598_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (3, 8)).mono (by decide +kernel) + · exact finite_row_works_598_i5.mono (by decide +kernel) + +theorem finite_row_works_598_i4 : FiniteTemplate HasSnaky 7 required_598_i4 envelope_598_i4 := by + refine finite_compose HasSnaky 6 childrenC_598_i4 childrenD_598_i4 finite_children_work_598_i4 (4, 5) + required_598_i4 envelope_598_i4 pivot_mem_598_i4 child_required_sub_598_i4 child_envelope_sub_598_i4 ?_ + intro b hb + exact common_sub_598_i4 (mem_commonEnvelope childrenD_598_i4 b hb) + +theorem finite_children_work_598_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_598_i3 j) (childrenD_598_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_598_i4.mono (by decide +kernel) + +theorem finite_row_works_598_i3 : FiniteTemplate HasSnaky 8 required_598_i3 envelope_598_i3 := by + refine finite_compose HasSnaky 7 childrenC_598_i3 childrenD_598_i3 finite_children_work_598_i3 (3, 6) + required_598_i3 envelope_598_i3 pivot_mem_598_i3 child_required_sub_598_i3 child_envelope_sub_598_i3 ?_ + intro b hb + exact common_sub_598_i3 (mem_commonEnvelope childrenD_598_i3 b hb) + +theorem finite_children_work_598_i8 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_598_i8 j) (childrenD_598_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 2 (6, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_413 3 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_598_i8 : FiniteTemplate HasSnaky 6 required_598_i8 envelope_598_i8 := by + refine finite_compose HasSnaky 5 childrenC_598_i8 childrenD_598_i8 finite_children_work_598_i8 (5, 5) + required_598_i8 envelope_598_i8 pivot_mem_598_i8 child_required_sub_598_i8 child_envelope_sub_598_i8 ?_ + intro b hb + exact common_sub_598_i8 (mem_commonEnvelope childrenD_598_i8 b hb) + +theorem finite_children_work_598_i7 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_598_i7 j) (childrenD_598_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (3, 8)).mono (by decide +kernel) + · exact finite_row_works_598_i8.mono (by decide +kernel) + +theorem finite_row_works_598_i7 : FiniteTemplate HasSnaky 7 required_598_i7 envelope_598_i7 := by + refine finite_compose HasSnaky 6 childrenC_598_i7 childrenD_598_i7 finite_children_work_598_i7 (4, 5) + required_598_i7 envelope_598_i7 pivot_mem_598_i7 child_required_sub_598_i7 child_envelope_sub_598_i7 ?_ + intro b hb + exact common_sub_598_i7 (mem_commonEnvelope childrenD_598_i7 b hb) + +theorem finite_children_work_598_i6 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_598_i6 j) (childrenD_598_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_598_i7.mono (by decide +kernel) + +theorem finite_row_works_598_i6 : FiniteTemplate HasSnaky 8 required_598_i6 envelope_598_i6 := by + refine finite_compose HasSnaky 7 childrenC_598_i6 childrenD_598_i6 finite_children_work_598_i6 (3, 6) + required_598_i6 envelope_598_i6 pivot_mem_598_i6 child_required_sub_598_i6 child_envelope_sub_598_i6 ?_ + intro b hb + exact common_sub_598_i6 (mem_commonEnvelope childrenD_598_i6 b hb) + +theorem finite_children_work_598 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_598 j) (childrenD_598 j) := by + intro j + fin_cases j + · exact finite_row_works_598_i0.mono (by decide +kernel) + · exact finite_row_works_598_i3.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_584 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_591 4 (2, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_594 2 (8, 1)).mono (by decide +kernel) + · exact finite_row_works_598_i6.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_597 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_598 : FiniteTemplate HasSnaky 14 required_598 envelope_598 := by + refine finite_compose HasSnaky 13 childrenC_598 childrenD_598 finite_children_work_598 (3, 5) + required_598 envelope_598 pivot_mem_598 child_required_sub_598 child_envelope_sub_598 ?_ + intro b hb + exact common_sub_598 (mem_commonEnvelope childrenD_598 b hb) + +theorem finite_children_work_636_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_636_i1 j) (childrenD_636_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 7 (5, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_108 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_512 0 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_636_i1 : FiniteTemplate HasSnaky 10 required_636_i1 envelope_636_i1 := by + refine finite_compose HasSnaky 9 childrenC_636_i1 childrenD_636_i1 finite_children_work_636_i1 (3, 5) + required_636_i1 envelope_636_i1 pivot_mem_636_i1 child_required_sub_636_i1 child_envelope_sub_636_i1 ?_ + intro b hb + exact common_sub_636_i1 (mem_commonEnvelope childrenD_636_i1 b hb) + +theorem finite_children_work_636_i2 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_636_i2 j) (childrenD_636_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_44 6 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_63 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_117 3 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_636_i2 : FiniteTemplate HasSnaky 8 required_636_i2 envelope_636_i2 := by + refine finite_compose HasSnaky 7 childrenC_636_i2 childrenD_636_i2 finite_children_work_636_i2 (4, 6) + required_636_i2 envelope_636_i2 pivot_mem_636_i2 child_required_sub_636_i2 child_envelope_sub_636_i2 ?_ + intro b hb + exact common_sub_636_i2 (mem_commonEnvelope childrenD_636_i2 b hb) + +theorem finite_children_work_636_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_636_i5 j) (childrenD_636_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_85 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_164 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_262 4 (2, 7)).mono (by decide +kernel) + +theorem finite_row_works_636_i5 : FiniteTemplate HasSnaky 7 required_636_i5 envelope_636_i5 := by + refine finite_compose HasSnaky 6 childrenC_636_i5 childrenD_636_i5 finite_children_work_636_i5 (5, 5) + required_636_i5 envelope_636_i5 pivot_mem_636_i5 child_required_sub_636_i5 child_envelope_sub_636_i5 ?_ + intro b hb + exact common_sub_636_i5 (mem_commonEnvelope childrenD_636_i5 b hb) + +theorem finite_children_work_636_i4 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_636_i4 j) (childrenD_636_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 4 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_636_i5.mono (by decide +kernel) + +theorem finite_row_works_636_i4 : FiniteTemplate HasSnaky 8 required_636_i4 envelope_636_i4 := by + refine finite_compose HasSnaky 7 childrenC_636_i4 childrenD_636_i4 finite_children_work_636_i4 (3, 5) + required_636_i4 envelope_636_i4 pivot_mem_636_i4 child_required_sub_636_i4 child_envelope_sub_636_i4 ?_ + intro b hb + exact common_sub_636_i4 (mem_commonEnvelope childrenD_636_i4 b hb) + +theorem finite_children_work_636_i6 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_636_i6 j) (childrenD_636_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 3 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_11 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_331 2 (6, 1)).mono (by decide +kernel) + +theorem finite_row_works_636_i6 : FiniteTemplate HasSnaky 7 required_636_i6 envelope_636_i6 := by + refine finite_compose HasSnaky 6 childrenC_636_i6 childrenD_636_i6 finite_children_work_636_i6 (6, 4) + required_636_i6 envelope_636_i6 pivot_mem_636_i6 child_required_sub_636_i6 child_envelope_sub_636_i6 ?_ + intro b hb + exact common_sub_636_i6 (mem_commonEnvelope childrenD_636_i6 b hb) + +theorem finite_children_work_636_i3 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_636_i3 j) (childrenD_636_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_332 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 4 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_522 0 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_636_i4.mono (by decide +kernel) + · exact finite_row_works_636_i6.mono (by decide +kernel) + +theorem finite_row_works_636_i3 : FiniteTemplate HasSnaky 10 required_636_i3 envelope_636_i3 := by + refine finite_compose HasSnaky 9 childrenC_636_i3 childrenD_636_i3 finite_children_work_636_i3 (5, 4) + required_636_i3 envelope_636_i3 pivot_mem_636_i3 child_required_sub_636_i3 child_envelope_sub_636_i3 ?_ + intro b hb + exact common_sub_636_i3 (mem_commonEnvelope childrenD_636_i3 b hb) + +theorem finite_children_work_636_i0 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_636_i0 j) (childrenD_636_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_399 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_408 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_475 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_509 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 0 (2, 1)).mono (by decide +kernel) + · exact finite_row_works_636_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_635 4 (2, 9)).mono (by decide +kernel) + · exact finite_row_works_636_i2.mono (by decide +kernel) + · exact finite_row_works_636_i3.mono (by decide +kernel) + +theorem finite_row_works_636_i0 : FiniteTemplate HasSnaky 13 required_636_i0 envelope_636_i0 := by + refine finite_compose HasSnaky 12 childrenC_636_i0 childrenD_636_i0 finite_children_work_636_i0 (4, 5) + required_636_i0 envelope_636_i0 pivot_mem_636_i0 child_required_sub_636_i0 child_envelope_sub_636_i0 ?_ + intro b hb + exact common_sub_636_i0 (mem_commonEnvelope childrenD_636_i0 b hb) + +theorem finite_children_work_636_i7 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_636_i7 j) (childrenD_636_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_118 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_188 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_188 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_192 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_193 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_396 5 (8, 2)).mono (by decide +kernel) + +theorem finite_row_works_636_i7 : FiniteTemplate HasSnaky 10 required_636_i7 envelope_636_i7 := by + refine finite_compose HasSnaky 9 childrenC_636_i7 childrenD_636_i7 finite_children_work_636_i7 (5, 4) + required_636_i7 envelope_636_i7 pivot_mem_636_i7 child_required_sub_636_i7 child_envelope_sub_636_i7 ?_ + intro b hb + exact common_sub_636_i7 (mem_commonEnvelope childrenD_636_i7 b hb) + +theorem finite_children_work_636 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_636 j) (childrenD_636 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_125 3 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_454 5 (5, 3)).mono (by decide +kernel) + · exact finite_row_works_636_i0.mono (by decide +kernel) + · exact finite_row_works_636_i7.mono (by decide +kernel) + +theorem finite_row_works_636 : FiniteTemplate HasSnaky 14 required_636 envelope_636 := by + refine finite_compose HasSnaky 13 childrenC_636 childrenD_636 finite_children_work_636 (3, 4) + required_636 envelope_636 pivot_mem_636 child_required_sub_636 child_envelope_sub_636 ?_ + intro b hb + exact common_sub_636 (mem_commonEnvelope childrenD_636 b hb) + +theorem finite_children_work_644_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_644_i1 j) (childrenD_644_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_317 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_640 4 (2, 8)).mono (by decide +kernel) + +theorem finite_row_works_644_i1 : FiniteTemplate HasSnaky 10 required_644_i1 envelope_644_i1 := by + refine finite_compose HasSnaky 9 childrenC_644_i1 childrenD_644_i1 finite_children_work_644_i1 (5, 5) + required_644_i1 envelope_644_i1 pivot_mem_644_i1 child_required_sub_644_i1 child_envelope_sub_644_i1 ?_ + intro b hb + exact common_sub_644_i1 (mem_commonEnvelope childrenD_644_i1 b hb) + +theorem finite_children_work_644_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_644_i0 j) (childrenD_644_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_104 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_359 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_452 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_476 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_479 0 (3, 1)).mono (by decide +kernel) + · exact finite_row_works_644_i1.mono (by decide +kernel) + +theorem finite_row_works_644_i0 : FiniteTemplate HasSnaky 11 required_644_i0 envelope_644_i0 := by + refine finite_compose HasSnaky 10 childrenC_644_i0 childrenD_644_i0 finite_children_work_644_i0 (6, 5) + required_644_i0 envelope_644_i0 pivot_mem_644_i0 child_required_sub_644_i0 child_envelope_sub_644_i0 ?_ + intro b hb + exact common_sub_644_i0 (mem_commonEnvelope childrenD_644_i0 b hb) + +theorem finite_children_work_644 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_644 j) (childrenD_644 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_120 6 (7, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_338 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_437 3 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_611 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_613 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_634 0 (1, 0)).mono (by decide +kernel) + · exact finite_row_works_644_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_642 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_643 0 (3, 0)).mono (by decide +kernel) + +theorem finite_row_works_644 : FiniteTemplate HasSnaky 14 required_644 envelope_644 := by + refine finite_compose HasSnaky 13 childrenC_644 childrenD_644 finite_children_work_644 (6, 4) + required_644 envelope_644 pivot_mem_644 child_required_sub_644 child_envelope_sub_644 ?_ + intro b hb + exact common_sub_644 (mem_commonEnvelope childrenD_644 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height14Part03.lean b/lean/snaky/FiniteCards/Height14Part03.lean new file mode 100644 index 0000000..b005079 --- /dev/null +++ b/lean/snaky/FiniteCards/Height14Part03.lean @@ -0,0 +1,301 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height09Part07 +import FiniteCards.Height10Part01 +import FiniteCards.Height13Part02 +import FiniteCards.Height13Part03 +import FiniteCards.Height13Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_645_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_645_i0 j) (childrenD_645_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_128 3 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_144 6 (6, 6)).mono (by decide +kernel) + +theorem finite_row_works_645_i0 : FiniteTemplate HasSnaky 6 required_645_i0 envelope_645_i0 := by + refine finite_compose HasSnaky 5 childrenC_645_i0 childrenD_645_i0 finite_children_work_645_i0 (5, 4) + required_645_i0 envelope_645_i0 pivot_mem_645_i0 child_required_sub_645_i0 child_envelope_sub_645_i0 ?_ + intro b hb + exact common_sub_645_i0 (mem_commonEnvelope childrenD_645_i0 b hb) + +theorem finite_children_work_645_i1 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_645_i1 j) (childrenD_645_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_104 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_359 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_438 4 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_452 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_476 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_479 0 (3, 1)).mono (by decide +kernel) + +theorem finite_row_works_645_i1 : FiniteTemplate HasSnaky 11 required_645_i1 envelope_645_i1 := by + refine finite_compose HasSnaky 10 childrenC_645_i1 childrenD_645_i1 finite_children_work_645_i1 (6, 5) + required_645_i1 envelope_645_i1 pivot_mem_645_i1 child_required_sub_645_i1 child_envelope_sub_645_i1 ?_ + intro b hb + exact common_sub_645_i1 (mem_commonEnvelope childrenD_645_i1 b hb) + +theorem finite_children_work_645 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_645 j) (childrenD_645 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_120 6 (7, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_276 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_338 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_437 3 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_611 3 (0, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_634 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_642 0 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_643 0 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_645_i0.mono (by decide +kernel) + · exact finite_row_works_645_i1.mono (by decide +kernel) + +theorem finite_row_works_645 : FiniteTemplate HasSnaky 14 required_645 envelope_645 := by + refine finite_compose HasSnaky 13 childrenC_645 childrenD_645 finite_children_work_645 (6, 4) + required_645 envelope_645 pivot_mem_645 child_required_sub_645 child_envelope_sub_645 ?_ + intro b hb + exact common_sub_645 (mem_commonEnvelope childrenD_645 b hb) + +theorem finite_children_work_669_i5 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_669_i5 j) (childrenD_669_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_66 7 (7, 7)).mono (by decide +kernel) + +theorem finite_row_works_669_i5 : FiniteTemplate HasSnaky 3 required_669_i5 envelope_669_i5 := by + refine finite_compose HasSnaky 2 childrenC_669_i5 childrenD_669_i5 finite_children_work_669_i5 (5, 6) + required_669_i5 envelope_669_i5 pivot_mem_669_i5 child_required_sub_669_i5 child_envelope_sub_669_i5 ?_ + intro b hb + exact common_sub_669_i5 (mem_commonEnvelope childrenD_669_i5 b hb) + +theorem finite_children_work_669_i4 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_669_i4 j) (childrenD_669_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (4, 8)).mono (by decide +kernel) + · exact finite_row_works_669_i5.mono (by decide +kernel) + +theorem finite_row_works_669_i4 : FiniteTemplate HasSnaky 4 required_669_i4 envelope_669_i4 := by + refine finite_compose HasSnaky 3 childrenC_669_i4 childrenD_669_i4 finite_children_work_669_i4 (4, 6) + required_669_i4 envelope_669_i4 pivot_mem_669_i4 child_required_sub_669_i4 child_envelope_sub_669_i4 ?_ + intro b hb + exact common_sub_669_i4 (mem_commonEnvelope childrenD_669_i4 b hb) + +theorem finite_children_work_669_i6 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_669_i6 j) (childrenD_669_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_36 0 (3, 4)).mono (by decide +kernel) + +theorem finite_row_works_669_i6 : FiniteTemplate HasSnaky 3 required_669_i6 envelope_669_i6 := by + refine finite_compose HasSnaky 2 childrenC_669_i6 childrenD_669_i6 finite_children_work_669_i6 (3, 7) + required_669_i6 envelope_669_i6 pivot_mem_669_i6 child_required_sub_669_i6 child_envelope_sub_669_i6 ?_ + intro b hb + exact common_sub_669_i6 (mem_commonEnvelope childrenD_669_i6 b hb) + +theorem finite_children_work_669_i7 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_669_i7 j) (childrenD_669_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_24 2 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_36 0 (3, 4)).mono (by decide +kernel) + +theorem finite_row_works_669_i7 : FiniteTemplate HasSnaky 4 required_669_i7 envelope_669_i7 := by + refine finite_compose HasSnaky 3 childrenC_669_i7 childrenD_669_i7 finite_children_work_669_i7 (3, 7) + required_669_i7 envelope_669_i7 pivot_mem_669_i7 child_required_sub_669_i7 child_envelope_sub_669_i7 ?_ + intro b hb + exact common_sub_669_i7 (mem_commonEnvelope childrenD_669_i7 b hb) + +theorem finite_children_work_669_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_669_i3 j) (childrenD_669_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_48 5 (7, 6)).mono (by decide +kernel) + · exact finite_row_works_669_i4.mono (by decide +kernel) + · exact finite_row_works_669_i6.mono (by decide +kernel) + · exact finite_row_works_669_i7.mono (by decide +kernel) + +theorem finite_row_works_669_i3 : FiniteTemplate HasSnaky 5 required_669_i3 envelope_669_i3 := by + refine finite_compose HasSnaky 4 childrenC_669_i3 childrenD_669_i3 finite_children_work_669_i3 (4, 7) + required_669_i3 envelope_669_i3 pivot_mem_669_i3 child_required_sub_669_i3 child_envelope_sub_669_i3 ?_ + intro b hb + exact common_sub_669_i3 (mem_commonEnvelope childrenD_669_i3 b hb) + +theorem finite_children_work_669_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_669_i2 j) (childrenD_669_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (6, 4)).mono (by decide +kernel) + · exact finite_row_works_669_i3.mono (by decide +kernel) + +theorem finite_row_works_669_i2 : FiniteTemplate HasSnaky 6 required_669_i2 envelope_669_i2 := by + refine finite_compose HasSnaky 5 childrenC_669_i2 childrenD_669_i2 finite_children_work_669_i2 (5, 7) + required_669_i2 envelope_669_i2 pivot_mem_669_i2 child_required_sub_669_i2 child_envelope_sub_669_i2 ?_ + intro b hb + exact common_sub_669_i2 (mem_commonEnvelope childrenD_669_i2 b hb) + +theorem finite_children_work_669_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_669_i1 j) (childrenD_669_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_25 7 (7, 7)).mono (by decide +kernel) + · exact finite_row_works_669_i2.mono (by decide +kernel) + +theorem finite_row_works_669_i1 : FiniteTemplate HasSnaky 7 required_669_i1 envelope_669_i1 := by + refine finite_compose HasSnaky 6 childrenC_669_i1 childrenD_669_i1 finite_children_work_669_i1 (4, 5) + required_669_i1 envelope_669_i1 pivot_mem_669_i1 child_required_sub_669_i1 child_envelope_sub_669_i1 ?_ + intro b hb + exact common_sub_669_i1 (mem_commonEnvelope childrenD_669_i1 b hb) + +theorem finite_children_work_669_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_669_i0 j) (childrenD_669_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 1 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_225 2 (7, 3)).mono (by decide +kernel) + · exact finite_row_works_669_i1.mono (by decide +kernel) + +theorem finite_row_works_669_i0 : FiniteTemplate HasSnaky 8 required_669_i0 envelope_669_i0 := by + refine finite_compose HasSnaky 7 childrenC_669_i0 childrenD_669_i0 finite_children_work_669_i0 (6, 7) + required_669_i0 envelope_669_i0 pivot_mem_669_i0 child_required_sub_669_i0 child_envelope_sub_669_i0 ?_ + intro b hb + exact common_sub_669_i0 (mem_commonEnvelope childrenD_669_i0 b hb) + +theorem finite_children_work_669 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_669 j) (childrenD_669 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_188 4 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_590 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_668 4 (3, 7)).mono (by decide +kernel) + · exact finite_row_works_669_i0.mono (by decide +kernel) + +theorem finite_row_works_669 : FiniteTemplate HasSnaky 14 required_669 envelope_669 := by + refine finite_compose HasSnaky 13 childrenC_669 childrenD_669 finite_children_work_669 (6, 4) + required_669 envelope_669 pivot_mem_669 child_required_sub_669 child_envelope_sub_669 ?_ + intro b hb + exact common_sub_669 (mem_commonEnvelope childrenD_669 b hb) + +theorem finite_children_work_693_i1 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_693_i1 j) (childrenD_693_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_28 0 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_409 1 (2, 7)).mono (by decide +kernel) + +theorem finite_row_works_693_i1 : FiniteTemplate HasSnaky 11 required_693_i1 envelope_693_i1 := by + refine finite_compose HasSnaky 10 childrenC_693_i1 childrenD_693_i1 finite_children_work_693_i1 (5, 8) + required_693_i1 envelope_693_i1 pivot_mem_693_i1 child_required_sub_693_i1 child_envelope_sub_693_i1 ?_ + intro b hb + exact common_sub_693_i1 (mem_commonEnvelope childrenD_693_i1 b hb) + +theorem finite_children_work_693_i2 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_693_i2 j) (childrenD_693_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_168 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_409 1 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_611 1 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_693_i2 : FiniteTemplate HasSnaky 11 required_693_i2 envelope_693_i2 := by + refine finite_compose HasSnaky 10 childrenC_693_i2 childrenD_693_i2 finite_children_work_693_i2 (5, 8) + required_693_i2 envelope_693_i2 pivot_mem_693_i2 child_required_sub_693_i2 child_envelope_sub_693_i2 ?_ + intro b hb + exact common_sub_693_i2 (mem_commonEnvelope childrenD_693_i2 b hb) + +theorem finite_children_work_693_i4 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_693_i4 j) (childrenD_693_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 5 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_308 4 (4, 8)).mono (by decide +kernel) + +theorem finite_row_works_693_i4 : FiniteTemplate HasSnaky 6 required_693_i4 envelope_693_i4 := by + refine finite_compose HasSnaky 5 childrenC_693_i4 childrenD_693_i4 finite_children_work_693_i4 (5, 4) + required_693_i4 envelope_693_i4 pivot_mem_693_i4 child_required_sub_693_i4 child_envelope_sub_693_i4 ?_ + intro b hb + exact common_sub_693_i4 (mem_commonEnvelope childrenD_693_i4 b hb) + +theorem finite_children_work_693_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_693_i3 j) (childrenD_693_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 5 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 2 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_214 2 (7, 2)).mono (by decide +kernel) + · exact finite_row_works_693_i4.mono (by decide +kernel) + +theorem finite_row_works_693_i3 : FiniteTemplate HasSnaky 7 required_693_i3 envelope_693_i3 := by + refine finite_compose HasSnaky 6 childrenC_693_i3 childrenD_693_i3 finite_children_work_693_i3 (3, 5) + required_693_i3 envelope_693_i3 pivot_mem_693_i3 child_required_sub_693_i3 child_envelope_sub_693_i3 ?_ + intro b hb + exact common_sub_693_i3 (mem_commonEnvelope childrenD_693_i3 b hb) + +theorem finite_children_work_693_i6 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_693_i6 j) (childrenD_693_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_233 2 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 7 (6, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_314 3 (4, 7)).mono (by decide +kernel) + +theorem finite_row_works_693_i6 : FiniteTemplate HasSnaky 6 required_693_i6 envelope_693_i6 := by + refine finite_compose HasSnaky 5 childrenC_693_i6 childrenD_693_i6 finite_children_work_693_i6 (5, 4) + required_693_i6 envelope_693_i6 pivot_mem_693_i6 child_required_sub_693_i6 child_envelope_sub_693_i6 ?_ + intro b hb + exact common_sub_693_i6 (mem_commonEnvelope childrenD_693_i6 b hb) + +theorem finite_children_work_693_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_693_i5 j) (childrenD_693_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 6 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 4 (5, 8)).mono (by decide +kernel) + · exact finite_row_works_693_i6.mono (by decide +kernel) + +theorem finite_row_works_693_i5 : FiniteTemplate HasSnaky 7 required_693_i5 envelope_693_i5 := by + refine finite_compose HasSnaky 6 childrenC_693_i5 childrenD_693_i5 finite_children_work_693_i5 (5, 6) + required_693_i5 envelope_693_i5 pivot_mem_693_i5 child_required_sub_693_i5 child_envelope_sub_693_i5 ?_ + intro b hb + exact common_sub_693_i5 (mem_commonEnvelope childrenD_693_i5 b hb) + +theorem finite_children_work_693_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_693_i0 j) (childrenD_693_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_319 6 (7, 10)).mono (by decide +kernel) + · exact finite_row_works_693_i1.mono (by decide +kernel) + · exact finite_row_works_693_i2.mono (by decide +kernel) + · exact finite_row_works_693_i3.mono (by decide +kernel) + · exact finite_row_works_693_i5.mono (by decide +kernel) + +theorem finite_row_works_693_i0 : FiniteTemplate HasSnaky 12 required_693_i0 envelope_693_i0 := by + refine finite_compose HasSnaky 11 childrenC_693_i0 childrenD_693_i0 finite_children_work_693_i0 (5, 7) + required_693_i0 envelope_693_i0 pivot_mem_693_i0 child_required_sub_693_i0 child_envelope_sub_693_i0 ?_ + intro b hb + exact common_sub_693_i0 (mem_commonEnvelope childrenD_693_i0 b hb) + +theorem finite_children_work_693 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_693 j) (childrenD_693 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_147 0 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_339 7 (8, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_692 1 (2, 5)).mono (by decide +kernel) + · exact finite_row_works_693_i0.mono (by decide +kernel) + +theorem finite_row_works_693 : FiniteTemplate HasSnaky 14 required_693 envelope_693 := by + refine finite_compose HasSnaky 13 childrenC_693 childrenD_693 finite_children_work_693 (7, 8) + required_693 envelope_693 pivot_mem_693 child_required_sub_693 child_envelope_sub_693 ?_ + intro b hb + exact common_sub_693 (mem_commonEnvelope childrenD_693 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height14Part04.lean b/lean/snaky/FiniteCards/Height14Part04.lean new file mode 100644 index 0000000..1e93d06 --- /dev/null +++ b/lean/snaky/FiniteCards/Height14Part04.lean @@ -0,0 +1,236 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part04 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part05 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part05 +import FiniteCards.Height07Part06 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part02 +import FiniteCards.Height10Part01 +import FiniteCards.Height11Part03 +import FiniteCards.Height13Part03 +import FiniteCards.Height13Part05 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_697_i4 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_697_i4 j) (childrenD_697_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_16 7 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_374 0 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_697_i4 : FiniteTemplate HasSnaky 4 required_697_i4 envelope_697_i4 := by + refine finite_compose HasSnaky 3 childrenC_697_i4 childrenD_697_i4 finite_children_work_697_i4 (5, 2) + required_697_i4 envelope_697_i4 pivot_mem_697_i4 child_required_sub_697_i4 child_envelope_sub_697_i4 ?_ + intro b hb + exact common_sub_697_i4 (mem_commonEnvelope childrenD_697_i4 b hb) + +theorem finite_children_work_697_i3 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_697_i3 j) (childrenD_697_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_95 7 (9, 7)).mono (by decide +kernel) + · exact finite_row_works_697_i4.mono (by decide +kernel) + +theorem finite_row_works_697_i3 : FiniteTemplate HasSnaky 7 required_697_i3 envelope_697_i3 := by + refine finite_compose HasSnaky 6 childrenC_697_i3 childrenD_697_i3 finite_children_work_697_i3 (6, 6) + required_697_i3 envelope_697_i3 pivot_mem_697_i3 child_required_sub_697_i3 child_envelope_sub_697_i3 ?_ + intro b hb + exact common_sub_697_i3 (mem_commonEnvelope childrenD_697_i3 b hb) + +theorem finite_children_work_697_i2 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_697_i2 j) (childrenD_697_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_151 7 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_460 5 (8, 5)).mono (by decide +kernel) + · exact finite_row_works_697_i3.mono (by decide +kernel) + +theorem finite_row_works_697_i2 : FiniteTemplate HasSnaky 11 required_697_i2 envelope_697_i2 := by + refine finite_compose HasSnaky 10 childrenC_697_i2 childrenD_697_i2 finite_children_work_697_i2 (5, 6) + required_697_i2 envelope_697_i2 pivot_mem_697_i2 child_required_sub_697_i2 child_envelope_sub_697_i2 ?_ + intro b hb + exact common_sub_697_i2 (mem_commonEnvelope childrenD_697_i2 b hb) + +theorem finite_children_work_697_i1 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_697_i1 j) (childrenD_697_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_39 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_121 2 (5, 2)).mono (by decide +kernel) + · exact finite_row_works_697_i2.mono (by decide +kernel) + +theorem finite_row_works_697_i1 : FiniteTemplate HasSnaky 12 required_697_i1 envelope_697_i1 := by + refine finite_compose HasSnaky 11 childrenC_697_i1 childrenD_697_i1 finite_children_work_697_i1 (3, 6) + required_697_i1 envelope_697_i1 pivot_mem_697_i1 child_required_sub_697_i1 child_envelope_sub_697_i1 ?_ + intro b hb + exact common_sub_697_i1 (mem_commonEnvelope childrenD_697_i1 b hb) + +theorem finite_children_work_697_i0 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_697_i0 j) (childrenD_697_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_56 6 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_697_i1.mono (by decide +kernel) + +theorem finite_row_works_697_i0 : FiniteTemplate HasSnaky 13 required_697_i0 envelope_697_i0 := by + refine finite_compose HasSnaky 12 childrenC_697_i0 childrenD_697_i0 finite_children_work_697_i0 (3, 4) + required_697_i0 envelope_697_i0 pivot_mem_697_i0 child_required_sub_697_i0 child_envelope_sub_697_i0 ?_ + intro b hb + exact common_sub_697_i0 (mem_commonEnvelope childrenD_697_i0 b hb) + +theorem finite_children_work_697 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_697 j) (childrenD_697 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 7 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 0 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_690.mono (by decide +kernel) + · exact finite_row_works_697_i0.mono (by decide +kernel) + +theorem finite_row_works_697 : FiniteTemplate HasSnaky 14 required_697 envelope_697 := by + refine finite_compose HasSnaky 13 childrenC_697 childrenD_697 finite_children_work_697 (5, 3) + required_697 envelope_697 pivot_mem_697 child_required_sub_697 child_envelope_sub_697 ?_ + intro b hb + exact common_sub_697 (mem_commonEnvelope childrenD_697 b hb) + +theorem finite_children_work_705_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_705_i1 j) (childrenD_705_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 6 (6, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_79 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 1 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_189 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_367 4 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 1 (3, 3)).mono (by decide +kernel) + +theorem finite_row_works_705_i1 : FiniteTemplate HasSnaky 10 required_705_i1 envelope_705_i1 := by + refine finite_compose HasSnaky 9 childrenC_705_i1 childrenD_705_i1 finite_children_work_705_i1 (5, 6) + required_705_i1 envelope_705_i1 pivot_mem_705_i1 child_required_sub_705_i1 child_envelope_sub_705_i1 ?_ + intro b hb + exact common_sub_705_i1 (mem_commonEnvelope childrenD_705_i1 b hb) + +theorem finite_children_work_705_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_705_i0 j) (childrenD_705_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_59 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_105 3 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_323 2 (6, 1)).mono (by decide +kernel) + · exact finite_row_works_705_i1.mono (by decide +kernel) + +theorem finite_row_works_705_i0 : FiniteTemplate HasSnaky 11 required_705_i0 envelope_705_i0 := by + refine finite_compose HasSnaky 10 childrenC_705_i0 childrenD_705_i0 finite_children_work_705_i0 (5, 5) + required_705_i0 envelope_705_i0 pivot_mem_705_i0 child_required_sub_705_i0 child_envelope_sub_705_i0 ?_ + intro b hb + exact common_sub_705_i0 (mem_commonEnvelope childrenD_705_i0 b hb) + +theorem finite_children_work_705_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_705_i4 j) (childrenD_705_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 6 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_242 2 (6, 2)).mono (by decide +kernel) + +theorem finite_row_works_705_i4 : FiniteTemplate HasSnaky 5 required_705_i4 envelope_705_i4 := by + refine finite_compose HasSnaky 4 childrenC_705_i4 childrenD_705_i4 finite_children_work_705_i4 (4, 4) + required_705_i4 envelope_705_i4 pivot_mem_705_i4 child_required_sub_705_i4 child_envelope_sub_705_i4 ?_ + intro b hb + exact common_sub_705_i4 (mem_commonEnvelope childrenD_705_i4 b hb) + +theorem finite_children_work_705_i3 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_705_i3 j) (childrenD_705_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_79 4 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_243 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_518 2 (8, 1)).mono (by decide +kernel) + · exact finite_row_works_705_i4.mono (by decide +kernel) + +theorem finite_row_works_705_i3 : FiniteTemplate HasSnaky 9 required_705_i3 envelope_705_i3 := by + refine finite_compose HasSnaky 8 childrenC_705_i3 childrenD_705_i3 finite_children_work_705_i3 (5, 6) + required_705_i3 envelope_705_i3 pivot_mem_705_i3 child_required_sub_705_i3 child_envelope_sub_705_i3 ?_ + intro b hb + exact common_sub_705_i3 (mem_commonEnvelope childrenD_705_i3 b hb) + +theorem finite_children_work_705_i2 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_705_i2 j) (childrenD_705_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_323 2 (6, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_430 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_431 0 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_592 7 (6, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_681 4 (1, 9)).mono (by decide +kernel) + · exact finite_row_works_705_i3.mono (by decide +kernel) + +theorem finite_row_works_705_i2 : FiniteTemplate HasSnaky 10 required_705_i2 envelope_705_i2 := by + refine finite_compose HasSnaky 9 childrenC_705_i2 childrenD_705_i2 finite_children_work_705_i2 (5, 5) + required_705_i2 envelope_705_i2 pivot_mem_705_i2 child_required_sub_705_i2 child_envelope_sub_705_i2 ?_ + intro b hb + exact common_sub_705_i2 (mem_commonEnvelope childrenD_705_i2 b hb) + +theorem finite_children_work_705 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_705 j) (childrenD_705 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_422 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_450 4 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_503 6 (6, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_642 0 (2, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_680 4 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_705_i0.mono (by decide +kernel) + · exact finite_row_works_705_i2.mono (by decide +kernel) + +theorem finite_row_works_705 : FiniteTemplate HasSnaky 14 required_705 envelope_705 := by + refine finite_compose HasSnaky 13 childrenC_705 childrenD_705 finite_children_work_705 (5, 4) + required_705 envelope_705 pivot_mem_705 child_required_sub_705 child_envelope_sub_705 ?_ + intro b hb + exact common_sub_705 (mem_commonEnvelope childrenD_705 b hb) + +theorem finite_children_work_711_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_711_i0 j) (childrenD_711_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_104 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_359 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_452 4 (1, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_476 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_479 4 (3, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_520 2 (9, 0)).mono (by decide +kernel) + +theorem finite_row_works_711_i0 : FiniteTemplate HasSnaky 11 required_711_i0 envelope_711_i0 := by + refine finite_compose HasSnaky 10 childrenC_711_i0 childrenD_711_i0 finite_children_work_711_i0 (6, 5) + required_711_i0 envelope_711_i0 pivot_mem_711_i0 child_required_sub_711_i0 child_envelope_sub_711_i0 ?_ + intro b hb + exact common_sub_711_i0 (mem_commonEnvelope childrenD_711_i0 b hb) + +theorem finite_children_work_711 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_711 j) (childrenD_711 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_120 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_338 1 (1, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_437 1 (1, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_611 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_613 3 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_634 4 (1, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_642 4 (3, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_643 4 (3, 10)).mono (by decide +kernel) + · exact finite_row_works_711_i0.mono (by decide +kernel) + +theorem finite_row_works_711 : FiniteTemplate HasSnaky 14 required_711 envelope_711 := by + refine finite_compose HasSnaky 13 childrenC_711 childrenD_711 finite_children_work_711 (6, 6) + required_711 envelope_711 pivot_mem_711 child_required_sub_711 child_envelope_sub_711 ?_ + intro b hb + exact common_sub_711 (mem_commonEnvelope childrenD_711 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height15Part01.lean b/lean/snaky/FiniteCards/Height15Part01.lean new file mode 100644 index 0000000..628684d --- /dev/null +++ b/lean/snaky/FiniteCards/Height15Part01.lean @@ -0,0 +1,360 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part05 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part03 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height08Part03 +import FiniteCards.Height08Part04 +import FiniteCards.Height09Part02 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part03 +import FiniteCards.Height10Part04 +import FiniteCards.Height10Part06 +import FiniteCards.Height11Part02 +import FiniteCards.Height12Part02 +import FiniteCards.Height12Part03 +import FiniteCards.Height12Part04 +import FiniteCards.Height13Part01 +import FiniteCards.Height13Part02 +import FiniteCards.Height13Part03 +import FiniteCards.Height13Part04 +import FiniteCards.Height14Part01 +import FiniteCards.Height14Part02 +import FiniteCards.Height14Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_573_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_573_i0 j) (childrenD_573_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_115 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 5 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_286 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_339 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_573_i0 : FiniteTemplate HasSnaky 8 required_573_i0 envelope_573_i0 := by + refine finite_compose HasSnaky 7 childrenC_573_i0 childrenD_573_i0 finite_children_work_573_i0 (3, 5) + required_573_i0 envelope_573_i0 pivot_mem_573_i0 child_required_sub_573_i0 child_envelope_sub_573_i0 ?_ + intro b hb + exact common_sub_573_i0 (mem_commonEnvelope childrenD_573_i0 b hb) + +theorem finite_children_work_573_i1 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_573_i1 j) (childrenD_573_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_473 3 (1, 7)).mono (by decide +kernel) + +theorem finite_row_works_573_i1 : FiniteTemplate HasSnaky 9 required_573_i1 envelope_573_i1 := by + refine finite_compose HasSnaky 8 childrenC_573_i1 childrenD_573_i1 finite_children_work_573_i1 (3, 5) + required_573_i1 envelope_573_i1 pivot_mem_573_i1 child_required_sub_573_i1 child_envelope_sub_573_i1 ?_ + intro b hb + exact common_sub_573_i1 (mem_commonEnvelope childrenD_573_i1 b hb) + +theorem finite_children_work_573_i2 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_573_i2 j) (childrenD_573_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_403 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_487 0 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_492 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_573_i2 : FiniteTemplate HasSnaky 8 required_573_i2 envelope_573_i2 := by + refine finite_compose HasSnaky 7 childrenC_573_i2 childrenD_573_i2 finite_children_work_573_i2 (3, 5) + required_573_i2 envelope_573_i2 pivot_mem_573_i2 child_required_sub_573_i2 child_envelope_sub_573_i2 ?_ + intro b hb + exact common_sub_573_i2 (mem_commonEnvelope childrenD_573_i2 b hb) + +theorem finite_children_work_573_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_573_i3 j) (childrenD_573_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_87 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_487 0 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_573_i3 : FiniteTemplate HasSnaky 8 required_573_i3 envelope_573_i3 := by + refine finite_compose HasSnaky 7 childrenC_573_i3 childrenD_573_i3 finite_children_work_573_i3 (3, 5) + required_573_i3 envelope_573_i3 pivot_mem_573_i3 child_required_sub_573_i3 child_envelope_sub_573_i3 ?_ + intro b hb + exact common_sub_573_i3 (mem_commonEnvelope childrenD_573_i3 b hb) + +theorem finite_children_work_573_i4 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_573_i4 j) (childrenD_573_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_107 0 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_572.mono (by decide +kernel) + +theorem finite_row_works_573_i4 : FiniteTemplate HasSnaky 14 required_573_i4 envelope_573_i4 := by + refine finite_compose HasSnaky 13 childrenC_573_i4 childrenD_573_i4 finite_children_work_573_i4 (1, 7) + required_573_i4 envelope_573_i4 pivot_mem_573_i4 child_required_sub_573_i4 child_envelope_sub_573_i4 ?_ + intro b hb + exact common_sub_573_i4 (mem_commonEnvelope childrenD_573_i4 b hb) + +theorem finite_children_work_573_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_573_i5 j) (childrenD_573_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_249 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_383 7 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_403 0 (0, 2)).mono (by decide +kernel) + +theorem finite_row_works_573_i5 : FiniteTemplate HasSnaky 7 required_573_i5 envelope_573_i5 := by + refine finite_compose HasSnaky 6 childrenC_573_i5 childrenD_573_i5 finite_children_work_573_i5 (3, 5) + required_573_i5 envelope_573_i5 pivot_mem_573_i5 child_required_sub_573_i5 child_envelope_sub_573_i5 ?_ + intro b hb + exact common_sub_573_i5 (mem_commonEnvelope childrenD_573_i5 b hb) + +theorem finite_children_work_573 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_573 j) (childrenD_573 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_384 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_385 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_493 0 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_494 0 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_573_i0.mono (by decide +kernel) + · exact finite_row_works_573_i1.mono (by decide +kernel) + · exact finite_row_works_573_i2.mono (by decide +kernel) + · exact finite_row_works_573_i3.mono (by decide +kernel) + · exact finite_row_works_573_i4.mono (by decide +kernel) + · exact finite_row_works_573_i5.mono (by decide +kernel) + +theorem finite_row_works_573 : FiniteTemplate HasSnaky 15 required_573 envelope_573 := by + refine finite_compose HasSnaky 14 childrenC_573 childrenD_573 finite_children_work_573 (3, 6) + required_573 envelope_573 pivot_mem_573 child_required_sub_573 child_envelope_sub_573 ?_ + intro b hb + exact common_sub_573 (mem_commonEnvelope childrenD_573 b hb) + +theorem finite_children_work_583_i2 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_583_i2 j) (childrenD_583_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 1 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_576 4 (2, 10)).mono (by decide +kernel) + +theorem finite_row_works_583_i2 : FiniteTemplate HasSnaky 8 required_583_i2 envelope_583_i2 := by + refine finite_compose HasSnaky 7 childrenC_583_i2 childrenD_583_i2 finite_children_work_583_i2 (9, 6) + required_583_i2 envelope_583_i2 pivot_mem_583_i2 child_required_sub_583_i2 child_envelope_sub_583_i2 ?_ + intro b hb + exact common_sub_583_i2 (mem_commonEnvelope childrenD_583_i2 b hb) + +theorem finite_children_work_583_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_583_i3 j) (childrenD_583_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 3 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_576 4 (2, 10)).mono (by decide +kernel) + +theorem finite_row_works_583_i3 : FiniteTemplate HasSnaky 8 required_583_i3 envelope_583_i3 := by + refine finite_compose HasSnaky 7 childrenC_583_i3 childrenD_583_i3 finite_children_work_583_i3 (9, 6) + required_583_i3 envelope_583_i3 pivot_mem_583_i3 child_required_sub_583_i3 child_envelope_sub_583_i3 ?_ + intro b hb + exact common_sub_583_i3 (mem_commonEnvelope childrenD_583_i3 b hb) + +theorem finite_children_work_583_i1 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_583_i1 j) (childrenD_583_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 4 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_321 4 (5, 10)).mono (by decide +kernel) + · exact finite_row_works_583_i2.mono (by decide +kernel) + · exact finite_row_works_583_i3.mono (by decide +kernel) + +theorem finite_row_works_583_i1 : FiniteTemplate HasSnaky 9 required_583_i1 envelope_583_i1 := by + refine finite_compose HasSnaky 8 childrenC_583_i1 childrenD_583_i1 finite_children_work_583_i1 (8, 6) + required_583_i1 envelope_583_i1 pivot_mem_583_i1 child_required_sub_583_i1 child_envelope_sub_583_i1 ?_ + intro b hb + exact common_sub_583_i1 (mem_commonEnvelope childrenD_583_i1 b hb) + +theorem finite_children_work_583_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_583_i0 j) (childrenD_583_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_3 6 (7, 6)).mono (by decide +kernel) + · exact finite_row_works_583_i1.mono (by decide +kernel) + +theorem finite_row_works_583_i0 : FiniteTemplate HasSnaky 10 required_583_i0 envelope_583_i0 := by + refine finite_compose HasSnaky 9 childrenC_583_i0 childrenD_583_i0 finite_children_work_583_i0 (5, 6) + required_583_i0 envelope_583_i0 pivot_mem_583_i0 child_required_sub_583_i0 child_envelope_sub_583_i0 ?_ + intro b hb + exact common_sub_583_i0 (mem_commonEnvelope childrenD_583_i0 b hb) + +theorem finite_children_work_583_i5 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_583_i5 j) (childrenD_583_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 1 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_86 1 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_542 1 (2, 5)).mono (by decide +kernel) + +theorem finite_row_works_583_i5 : FiniteTemplate HasSnaky 8 required_583_i5 envelope_583_i5 := by + refine finite_compose HasSnaky 7 childrenC_583_i5 childrenD_583_i5 finite_children_work_583_i5 (5, 8) + required_583_i5 envelope_583_i5 pivot_mem_583_i5 child_required_sub_583_i5 child_envelope_sub_583_i5 ?_ + intro b hb + exact common_sub_583_i5 (mem_commonEnvelope childrenD_583_i5 b hb) + +theorem finite_children_work_583_i6 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_583_i6 j) (childrenD_583_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_48 2 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_109 0 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_246 2 (7, 5)).mono (by decide +kernel) + +theorem finite_row_works_583_i6 : FiniteTemplate HasSnaky 5 required_583_i6 envelope_583_i6 := by + refine finite_compose HasSnaky 4 childrenC_583_i6 childrenD_583_i6 finite_children_work_583_i6 (6, 7) + required_583_i6 envelope_583_i6 pivot_mem_583_i6 child_required_sub_583_i6 child_envelope_sub_583_i6 ?_ + intro b hb + exact common_sub_583_i6 (mem_commonEnvelope childrenD_583_i6 b hb) + +theorem finite_children_work_583_i4 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_583_i4 j) (childrenD_583_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_184 2 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_423 2 (7, 5)).mono (by decide +kernel) + · exact finite_row_works_583_i5.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_572 1 (0, 5)).mono (by decide +kernel) + · exact finite_row_works_583_i6.mono (by decide +kernel) + +theorem finite_row_works_583_i4 : FiniteTemplate HasSnaky 14 required_583_i4 envelope_583_i4 := by + refine finite_compose HasSnaky 13 childrenC_583_i4 childrenD_583_i4 finite_children_work_583_i4 (6, 8) + required_583_i4 envelope_583_i4 pivot_mem_583_i4 child_required_sub_583_i4 child_envelope_sub_583_i4 ?_ + intro b hb + exact common_sub_583_i4 (mem_commonEnvelope childrenD_583_i4 b hb) + +theorem finite_children_work_583 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_583 j) (childrenD_583 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_401 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_552 4 (0, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_556 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_575 0 (3, 2)).mono (by decide +kernel) + · exact finite_row_works_583_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_579 4 (5, 10)).mono (by decide +kernel) + · exact finite_row_works_583_i4.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_582 1 (0, 4)).mono (by decide +kernel) + +theorem finite_row_works_583 : FiniteTemplate HasSnaky 15 required_583 envelope_583 := by + refine finite_compose HasSnaky 14 childrenC_583 childrenD_583 finite_children_work_583 (7, 6) + required_583 envelope_583 pivot_mem_583 child_required_sub_583 child_envelope_sub_583 ?_ + intro b hb + exact common_sub_583 (mem_commonEnvelope childrenD_583 b hb) + +theorem finite_children_work_648 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_648 j) (childrenD_648 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_174 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_475 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_480 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_480 2 (7, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_483 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_566 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_605 1 (1, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_635 0 (2, 0)).mono (by decide +kernel) + · exact finite_row_works_644.mono (by decide +kernel) + · exact finite_row_works_647.mono (by decide +kernel) + +theorem finite_row_works_648 : FiniteTemplate HasSnaky 15 required_648 envelope_648 := by + refine finite_compose HasSnaky 14 childrenC_648 childrenD_648 finite_children_work_648 (4, 4) + required_648 envelope_648 pivot_mem_648 child_required_sub_648 child_envelope_sub_648 ?_ + intro b hb + exact common_sub_648 (mem_commonEnvelope childrenD_648 b hb) + +theorem finite_children_work_656_i1 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_656_i1 j) (childrenD_656_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_117 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_134 3 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 3 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_337 6 (6, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_341 6 (8, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 3 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_558 3 (3, 6)).mono (by decide +kernel) + +theorem finite_row_works_656_i1 : FiniteTemplate HasSnaky 9 required_656_i1 envelope_656_i1 := by + refine finite_compose HasSnaky 8 childrenC_656_i1 childrenD_656_i1 finite_children_work_656_i1 (5, 4) + required_656_i1 envelope_656_i1 pivot_mem_656_i1 child_required_sub_656_i1 child_envelope_sub_656_i1 ?_ + intro b hb + exact common_sub_656_i1 (mem_commonEnvelope childrenD_656_i1 b hb) + +theorem finite_children_work_656_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_656_i2 j) (childrenD_656_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_651 1 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_656_i2 : FiniteTemplate HasSnaky 9 required_656_i2 envelope_656_i2 := by + refine finite_compose HasSnaky 8 childrenC_656_i2 childrenD_656_i2 finite_children_work_656_i2 (4, 5) + required_656_i2 envelope_656_i2 pivot_mem_656_i2 child_required_sub_656_i2 child_envelope_sub_656_i2 ?_ + intro b hb + exact common_sub_656_i2 (mem_commonEnvelope childrenD_656_i2 b hb) + +theorem finite_children_work_656_i3 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_656_i3 j) (childrenD_656_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 0 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_652 4 (3, 9)).mono (by decide +kernel) + +theorem finite_row_works_656_i3 : FiniteTemplate HasSnaky 11 required_656_i3 envelope_656_i3 := by + refine finite_compose HasSnaky 10 childrenC_656_i3 childrenD_656_i3 finite_children_work_656_i3 (4, 5) + required_656_i3 envelope_656_i3 pivot_mem_656_i3 child_required_sub_656_i3 child_envelope_sub_656_i3 ?_ + intro b hb + exact common_sub_656_i3 (mem_commonEnvelope childrenD_656_i3 b hb) + +theorem finite_children_work_656_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_656_i0 j) (childrenD_656_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_248 6 (7, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_300 6 (7, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_436 6 (8, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_449 3 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_510 3 (2, 8)).mono (by decide +kernel) + · exact finite_row_works_656_i1.mono (by decide +kernel) + · exact finite_row_works_656_i2.mono (by decide +kernel) + · exact finite_row_works_656_i3.mono (by decide +kernel) + +theorem finite_row_works_656_i0 : FiniteTemplate HasSnaky 12 required_656_i0 envelope_656_i0 := by + refine finite_compose HasSnaky 11 childrenC_656_i0 childrenD_656_i0 finite_children_work_656_i0 (5, 5) + required_656_i0 envelope_656_i0 pivot_mem_656_i0 child_required_sub_656_i0 child_envelope_sub_656_i0 ?_ + intro b hb + exact common_sub_656_i0 (mem_commonEnvelope childrenD_656_i0 b hb) + +theorem finite_children_work_656 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_656 j) (childrenD_656 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_508 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_508 4 (3, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_605 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_605 4 (3, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_644 5 (10, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_645 5 (10, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_647 5 (10, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_650 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_650 4 (2, 11)).mono (by decide +kernel) + · exact finite_row_works_656_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_654 5 (9, 3)).mono (by decide +kernel) + +theorem finite_row_works_656 : FiniteTemplate HasSnaky 15 required_656 envelope_656 := by + refine finite_compose HasSnaky 14 childrenC_656 childrenD_656 finite_children_work_656 (6, 6) + required_656 envelope_656 pivot_mem_656 child_required_sub_656 child_envelope_sub_656 ?_ + intro b hb + exact common_sub_656 (mem_commonEnvelope childrenD_656 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height15Part02.lean b/lean/snaky/FiniteCards/Height15Part02.lean new file mode 100644 index 0000000..8b6702a --- /dev/null +++ b/lean/snaky/FiniteCards/Height15Part02.lean @@ -0,0 +1,370 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height05Part06 +import FiniteCards.Height05Part07 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part05 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part05 +import FiniteCards.Height07Part06 +import FiniteCards.Height08Part02 +import FiniteCards.Height08Part03 +import FiniteCards.Height08Part05 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part03 +import FiniteCards.Height09Part07 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part02 +import FiniteCards.Height11Part04 +import FiniteCards.Height11Part05 +import FiniteCards.Height12Part02 +import FiniteCards.Height13Part02 +import FiniteCards.Height13Part03 +import FiniteCards.Height13Part04 +import FiniteCards.Height14Part03 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_670_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_670_i0 j) (childrenD_670_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_40 7 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_125 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_660 1 (1, 1)).mono (by decide +kernel) + +theorem finite_row_works_670_i0 : FiniteTemplate HasSnaky 12 required_670_i0 envelope_670_i0 := by + refine finite_compose HasSnaky 11 childrenC_670_i0 childrenD_670_i0 finite_children_work_670_i0 (5, 5) + required_670_i0 envelope_670_i0 pivot_mem_670_i0 child_required_sub_670_i0 child_envelope_sub_670_i0 ?_ + intro b hb + exact common_sub_670_i0 (mem_commonEnvelope childrenD_670_i0 b hb) + +theorem finite_children_work_670_i1 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_670_i1 j) (childrenD_670_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_40 7 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_125 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_663 1 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_670_i1 : FiniteTemplate HasSnaky 12 required_670_i1 envelope_670_i1 := by + refine finite_compose HasSnaky 11 childrenC_670_i1 childrenD_670_i1 finite_children_work_670_i1 (5, 5) + required_670_i1 envelope_670_i1 pivot_mem_670_i1 child_required_sub_670_i1 child_envelope_sub_670_i1 ?_ + intro b hb + exact common_sub_670_i1 (mem_commonEnvelope childrenD_670_i1 b hb) + +theorem finite_children_work_670_i3 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_670_i3 j) (childrenD_670_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_106 1 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_219 1 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_530 4 (5, 9)).mono (by decide +kernel) + +theorem finite_row_works_670_i3 : FiniteTemplate HasSnaky 9 required_670_i3 envelope_670_i3 := by + refine finite_compose HasSnaky 8 childrenC_670_i3 childrenD_670_i3 finite_children_work_670_i3 (7, 6) + required_670_i3 envelope_670_i3 pivot_mem_670_i3 child_required_sub_670_i3 child_envelope_sub_670_i3 ?_ + intro b hb + exact common_sub_670_i3 (mem_commonEnvelope childrenD_670_i3 b hb) + +theorem finite_children_work_670_i4 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_670_i4 j) (childrenD_670_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_40 7 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_98 3 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_512 4 (4, 9)).mono (by decide +kernel) + +theorem finite_row_works_670_i4 : FiniteTemplate HasSnaky 10 required_670_i4 envelope_670_i4 := by + refine finite_compose HasSnaky 9 childrenC_670_i4 childrenD_670_i4 finite_children_work_670_i4 (5, 5) + required_670_i4 envelope_670_i4 pivot_mem_670_i4 child_required_sub_670_i4 child_envelope_sub_670_i4 ?_ + intro b hb + exact common_sub_670_i4 (mem_commonEnvelope childrenD_670_i4 b hb) + +theorem finite_children_work_670_i2 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_670_i2 j) (childrenD_670_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_270 0 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_588 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_638 4 (4, 9)).mono (by decide +kernel) + · exact finite_row_works_670_i3.mono (by decide +kernel) + · exact finite_row_works_670_i4.mono (by decide +kernel) + +theorem finite_row_works_670_i2 : FiniteTemplate HasSnaky 13 required_670_i2 envelope_670_i2 := by + refine finite_compose HasSnaky 12 childrenC_670_i2 childrenD_670_i2 finite_children_work_670_i2 (5, 6) + required_670_i2 envelope_670_i2 pivot_mem_670_i2 child_required_sub_670_i2 child_envelope_sub_670_i2 ?_ + intro b hb + exact common_sub_670_i2 (mem_commonEnvelope childrenD_670_i2 b hb) + +theorem finite_children_work_670_i5 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_670_i5 j) (childrenD_670_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_40 7 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_125 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_617 0 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_670_i5 : FiniteTemplate HasSnaky 12 required_670_i5 envelope_670_i5 := by + refine finite_compose HasSnaky 11 childrenC_670_i5 childrenD_670_i5 finite_children_work_670_i5 (5, 5) + required_670_i5 envelope_670_i5 pivot_mem_670_i5 child_required_sub_670_i5 child_envelope_sub_670_i5 ?_ + intro b hb + exact common_sub_670_i5 (mem_commonEnvelope childrenD_670_i5 b hb) + +theorem finite_children_work_670_i6 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_670_i6 j) (childrenD_670_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 4 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_31 4 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_355 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_356 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_434 0 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 1 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_441 6 (7, 8)).mono (by decide +kernel) + +theorem finite_row_works_670_i6 : FiniteTemplate HasSnaky 10 required_670_i6 envelope_670_i6 := by + refine finite_compose HasSnaky 9 childrenC_670_i6 childrenD_670_i6 finite_children_work_670_i6 (6, 4) + required_670_i6 envelope_670_i6 pivot_mem_670_i6 child_required_sub_670_i6 child_envelope_sub_670_i6 ?_ + intro b hb + exact common_sub_670_i6 (mem_commonEnvelope childrenD_670_i6 b hb) + +theorem finite_children_work_670_i7 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_670_i7 j) (childrenD_670_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_40 7 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_125 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_535 4 (4, 10)).mono (by decide +kernel) + +theorem finite_row_works_670_i7 : FiniteTemplate HasSnaky 11 required_670_i7 envelope_670_i7 := by + refine finite_compose HasSnaky 10 childrenC_670_i7 childrenD_670_i7 finite_children_work_670_i7 (5, 5) + required_670_i7 envelope_670_i7 pivot_mem_670_i7 child_required_sub_670_i7 child_envelope_sub_670_i7 ?_ + intro b hb + exact common_sub_670_i7 (mem_commonEnvelope childrenD_670_i7 b hb) + +theorem finite_children_work_670_i8 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_670_i8 j) (childrenD_670_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_188 0 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_188 4 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_441 6 (7, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_442 6 (7, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_514 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_667 4 (3, 7)).mono (by decide +kernel) + +theorem finite_row_works_670_i8 : FiniteTemplate HasSnaky 10 required_670_i8 envelope_670_i8 := by + refine finite_compose HasSnaky 9 childrenC_670_i8 childrenD_670_i8 finite_children_work_670_i8 (6, 4) + required_670_i8 envelope_670_i8 pivot_mem_670_i8 child_required_sub_670_i8 child_envelope_sub_670_i8 ?_ + intro b hb + exact common_sub_670_i8 (mem_commonEnvelope childrenD_670_i8 b hb) + +theorem finite_children_work_670_i10 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_670_i10 j) (childrenD_670_i10 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_125 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_136 4 (4, 7)).mono (by decide +kernel) + +theorem finite_row_works_670_i10 : FiniteTemplate HasSnaky 7 required_670_i10 envelope_670_i10 := by + refine finite_compose HasSnaky 6 childrenC_670_i10 childrenD_670_i10 finite_children_work_670_i10 (5, 5) + required_670_i10 envelope_670_i10 pivot_mem_670_i10 child_required_sub_670_i10 child_envelope_sub_670_i10 ?_ + intro b hb + exact common_sub_670_i10 (mem_commonEnvelope childrenD_670_i10 b hb) + +theorem finite_children_work_670_i9 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_670_i9 j) (childrenD_670_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 2 (7, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_514 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_590 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_668 4 (3, 7)).mono (by decide +kernel) + · exact finite_row_works_670_i10.mono (by decide +kernel) + +theorem finite_row_works_670_i9 : FiniteTemplate HasSnaky 14 required_670_i9 envelope_670_i9 := by + refine finite_compose HasSnaky 13 childrenC_670_i9 childrenD_670_i9 finite_children_work_670_i9 (6, 4) + required_670_i9 envelope_670_i9 pivot_mem_670_i9 child_required_sub_670_i9 child_envelope_sub_670_i9 ?_ + intro b hb + exact common_sub_670_i9 (mem_commonEnvelope childrenD_670_i9 b hb) + +theorem finite_children_work_670 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_670 j) (childrenD_670 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_459 0 (5, 1)).mono (by decide +kernel) + · exact finite_row_works_670_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_661 4 (2, 10)).mono (by decide +kernel) + · exact finite_row_works_670_i1.mono (by decide +kernel) + · exact finite_row_works_670_i2.mono (by decide +kernel) + · exact finite_row_works_670_i5.mono (by decide +kernel) + · exact finite_row_works_670_i6.mono (by decide +kernel) + · exact finite_row_works_670_i7.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_665 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_670_i8.mono (by decide +kernel) + · exact finite_row_works_670_i9.mono (by decide +kernel) + · exact finite_row_works_669.mono (by decide +kernel) + +theorem finite_row_works_670 : FiniteTemplate HasSnaky 15 required_670 envelope_670 := by + refine finite_compose HasSnaky 14 childrenC_670 childrenD_670 finite_children_work_670 (6, 6) + required_670 envelope_670 pivot_mem_670 child_required_sub_670 child_envelope_sub_670 ?_ + intro b hb + exact common_sub_670 (mem_commonEnvelope childrenD_670 b hb) + +theorem finite_children_work_682_i0 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_682_i0 j) (childrenD_682_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 2 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_128 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_676 1 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_682_i0 : FiniteTemplate HasSnaky 12 required_682_i0 envelope_682_i0 := by + refine finite_compose HasSnaky 11 childrenC_682_i0 childrenD_682_i0 finite_children_work_682_i0 (4, 3) + required_682_i0 envelope_682_i0 pivot_mem_682_i0 child_required_sub_682_i0 child_envelope_sub_682_i0 ?_ + intro b hb + exact common_sub_682_i0 (mem_commonEnvelope childrenD_682_i0 b hb) + +theorem finite_children_work_682_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_682_i5 j) (childrenD_682_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_386 5 (8, 4)).mono (by decide +kernel) + +theorem finite_row_works_682_i5 : FiniteTemplate HasSnaky 6 required_682_i5 envelope_682_i5 := by + refine finite_compose HasSnaky 5 childrenC_682_i5 childrenD_682_i5 finite_children_work_682_i5 (6, 7) + required_682_i5 envelope_682_i5 pivot_mem_682_i5 child_required_sub_682_i5 child_envelope_sub_682_i5 ?_ + intro b hb + exact common_sub_682_i5 (mem_commonEnvelope childrenD_682_i5 b hb) + +theorem finite_children_work_682_i6 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_682_i6 j) (childrenD_682_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_222 1 (2, 4)).mono (by decide +kernel) + +theorem finite_row_works_682_i6 : FiniteTemplate HasSnaky 4 required_682_i6 envelope_682_i6 := by + refine finite_compose HasSnaky 3 childrenC_682_i6 childrenD_682_i6 finite_children_work_682_i6 (5, 6) + required_682_i6 envelope_682_i6 pivot_mem_682_i6 child_required_sub_682_i6 child_envelope_sub_682_i6 ?_ + intro b hb + exact common_sub_682_i6 (mem_commonEnvelope childrenD_682_i6 b hb) + +theorem finite_children_work_682_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_682_i4 j) (childrenD_682_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_377 2 (7, 3)).mono (by decide +kernel) + · exact finite_row_works_682_i5.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_426 0 (2, 3)).mono (by decide +kernel) + · exact finite_row_works_682_i6.mono (by decide +kernel) + +theorem finite_row_works_682_i4 : FiniteTemplate HasSnaky 7 required_682_i4 envelope_682_i4 := by + refine finite_compose HasSnaky 6 childrenC_682_i4 childrenD_682_i4 finite_children_work_682_i4 (4, 6) + required_682_i4 envelope_682_i4 pivot_mem_682_i4 child_required_sub_682_i4 child_envelope_sub_682_i4 ?_ + intro b hb + exact common_sub_682_i4 (mem_commonEnvelope childrenD_682_i4 b hb) + +theorem finite_children_work_682_i3 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_682_i3 j) (childrenD_682_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 2 (7, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 6 (7, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_79 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_679 2 (7, 3)).mono (by decide +kernel) + · exact finite_row_works_682_i4.mono (by decide +kernel) + +theorem finite_row_works_682_i3 : FiniteTemplate HasSnaky 8 required_682_i3 envelope_682_i3 := by + refine finite_compose HasSnaky 7 childrenC_682_i3 childrenD_682_i3 finite_children_work_682_i3 (6, 6) + required_682_i3 envelope_682_i3 pivot_mem_682_i3 child_required_sub_682_i3 child_envelope_sub_682_i3 ?_ + intro b hb + exact common_sub_682_i3 (mem_commonEnvelope childrenD_682_i3 b hb) + +theorem finite_children_work_682_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_682_i2 j) (childrenD_682_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_59 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_105 3 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_678 2 (7, 1)).mono (by decide +kernel) + · exact finite_row_works_682_i3.mono (by decide +kernel) + +theorem finite_row_works_682_i2 : FiniteTemplate HasSnaky 9 required_682_i2 envelope_682_i2 := by + refine finite_compose HasSnaky 8 childrenC_682_i2 childrenD_682_i2 finite_children_work_682_i2 (6, 5) + required_682_i2 envelope_682_i2 pivot_mem_682_i2 child_required_sub_682_i2 child_envelope_sub_682_i2 ?_ + intro b hb + exact common_sub_682_i2 (mem_commonEnvelope childrenD_682_i2 b hb) + +theorem finite_children_work_682_i8 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_682_i8 j) (childrenD_682_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 6 (7, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_79 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_243 2 (7, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_679 2 (7, 3)).mono (by decide +kernel) + +theorem finite_row_works_682_i8 : FiniteTemplate HasSnaky 6 required_682_i8 envelope_682_i8 := by + refine finite_compose HasSnaky 5 childrenC_682_i8 childrenD_682_i8 finite_children_work_682_i8 (6, 6) + required_682_i8 envelope_682_i8 pivot_mem_682_i8 child_required_sub_682_i8 child_envelope_sub_682_i8 ?_ + intro b hb + exact common_sub_682_i8 (mem_commonEnvelope childrenD_682_i8 b hb) + +theorem finite_children_work_682_i7 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_682_i7 j) (childrenD_682_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_430 0 (3, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_431 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_592 7 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_678 2 (7, 1)).mono (by decide +kernel) + · exact finite_row_works_682_i8.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_681 4 (2, 9)).mono (by decide +kernel) + +theorem finite_row_works_682_i7 : FiniteTemplate HasSnaky 9 required_682_i7 envelope_682_i7 := by + refine finite_compose HasSnaky 8 childrenC_682_i7 childrenD_682_i7 finite_children_work_682_i7 (6, 5) + required_682_i7 envelope_682_i7 pivot_mem_682_i7 child_required_sub_682_i7 child_envelope_sub_682_i7 ?_ + intro b hb + exact common_sub_682_i7 (mem_commonEnvelope childrenD_682_i7 b hb) + +theorem finite_children_work_682_i1 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_682_i1 j) (childrenD_682_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_422 2 (7, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_450 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_503 6 (7, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_642 0 (3, 0)).mono (by decide +kernel) + · exact finite_row_works_682_i2.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_680 4 (2, 7)).mono (by decide +kernel) + · exact finite_row_works_682_i7.mono (by decide +kernel) + +theorem finite_row_works_682_i1 : FiniteTemplate HasSnaky 14 required_682_i1 envelope_682_i1 := by + refine finite_compose HasSnaky 13 childrenC_682_i1 childrenD_682_i1 finite_children_work_682_i1 (6, 4) + required_682_i1 envelope_682_i1 pivot_mem_682_i1 child_required_sub_682_i1 child_envelope_sub_682_i1 ?_ + intro b hb + exact common_sub_682_i1 (mem_commonEnvelope childrenD_682_i1 b hb) + +theorem finite_children_work_682 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_682 j) (childrenD_682 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_408 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_410 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_475 6 (6, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_509 3 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_510 7 (7, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 4 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_646 6 (7, 8)).mono (by decide +kernel) + · exact finite_row_works_682_i0.mono (by decide +kernel) + · exact finite_row_works_682_i1.mono (by decide +kernel) + +theorem finite_row_works_682 : FiniteTemplate HasSnaky 15 required_682 envelope_682 := by + refine finite_compose HasSnaky 14 childrenC_682 childrenD_682 finite_children_work_682 (4, 4) + required_682 envelope_682 pivot_mem_682 child_required_sub_682 child_envelope_sub_682 ?_ + intro b hb + exact common_sub_682 (mem_commonEnvelope childrenD_682 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height15Part03.lean b/lean/snaky/FiniteCards/Height15Part03.lean new file mode 100644 index 0000000..356ffbe --- /dev/null +++ b/lean/snaky/FiniteCards/Height15Part03.lean @@ -0,0 +1,364 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part03 +import FiniteCards.Height01Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part05 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height08Part04 +import FiniteCards.Height08Part05 +import FiniteCards.Height09Part04 +import FiniteCards.Height09Part07 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part02 +import FiniteCards.Height10Part03 +import FiniteCards.Height11Part06 +import FiniteCards.Height12Part02 +import FiniteCards.Height12Part03 +import FiniteCards.Height12Part04 +import FiniteCards.Height13Part01 +import FiniteCards.Height13Part03 +import FiniteCards.Height13Part04 +import FiniteCards.Height13Part05 +import FiniteCards.Height14Part03 +import FiniteCards.Height14Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_698 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_698 j) (childrenD_698 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_182 6 (6, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_188 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_619 5 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_620 0 (1, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_622 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_687 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_697 1 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_698 : FiniteTemplate HasSnaky 15 required_698 envelope_698 := by + refine finite_compose HasSnaky 14 childrenC_698 childrenD_698 finite_children_work_698 (4, 6) + required_698 envelope_698 pivot_mem_698 child_required_sub_698 child_envelope_sub_698 ?_ + intro b hb + exact common_sub_698 (mem_commonEnvelope childrenD_698 b hb) + +theorem finite_children_work_699_i3 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_699_i3 j) (childrenD_699_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_42 0 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 1 (4, 5)).mono (by decide +kernel) + +theorem finite_row_works_699_i3 : FiniteTemplate HasSnaky 5 required_699_i3 envelope_699_i3 := by + refine finite_compose HasSnaky 4 childrenC_699_i3 childrenD_699_i3 finite_children_work_699_i3 (7, 6) + required_699_i3 envelope_699_i3 pivot_mem_699_i3 child_required_sub_699_i3 child_envelope_sub_699_i3 ?_ + intro b hb + exact common_sub_699_i3 (mem_commonEnvelope childrenD_699_i3 b hb) + +theorem finite_children_work_699_i2 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_699_i2 j) (childrenD_699_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_95 7 (10, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_112 1 (4, 4)).mono (by decide +kernel) + · exact finite_row_works_699_i3.mono (by decide +kernel) + +theorem finite_row_works_699_i2 : FiniteTemplate HasSnaky 7 required_699_i2 envelope_699_i2 := by + refine finite_compose HasSnaky 6 childrenC_699_i2 childrenD_699_i2 finite_children_work_699_i2 (7, 8) + required_699_i2 envelope_699_i2 pivot_mem_699_i2 child_required_sub_699_i2 child_envelope_sub_699_i2 ?_ + intro b hb + exact common_sub_699_i2 (mem_commonEnvelope childrenD_699_i2 b hb) + +theorem finite_children_work_699_i1 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_699_i1 j) (childrenD_699_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_371 0 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_460 5 (9, 7)).mono (by decide +kernel) + · exact finite_row_works_699_i2.mono (by decide +kernel) + +theorem finite_row_works_699_i1 : FiniteTemplate HasSnaky 11 required_699_i1 envelope_699_i1 := by + refine finite_compose HasSnaky 10 childrenC_699_i1 childrenD_699_i1 finite_children_work_699_i1 (6, 8) + required_699_i1 envelope_699_i1 pivot_mem_699_i1 child_required_sub_699_i1 child_envelope_sub_699_i1 ?_ + intro b hb + exact common_sub_699_i1 (mem_commonEnvelope childrenD_699_i1 b hb) + +theorem finite_children_work_699_i0 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_699_i0 j) (childrenD_699_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_147 2 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_249 3 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_692 5 (9, 5)).mono (by decide +kernel) + · exact finite_row_works_699_i1.mono (by decide +kernel) + +theorem finite_row_works_699_i0 : FiniteTemplate HasSnaky 14 required_699_i0 envelope_699_i0 := by + refine finite_compose HasSnaky 13 childrenC_699_i0 childrenD_699_i0 finite_children_work_699_i0 (4, 8) + required_699_i0 envelope_699_i0 pivot_mem_699_i0 child_required_sub_699_i0 child_envelope_sub_699_i0 ?_ + intro b hb + exact common_sub_699_i0 (mem_commonEnvelope childrenD_699_i0 b hb) + +theorem finite_children_work_699_i6 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_699_i6 j) (childrenD_699_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_259 4 (5, 7)).mono (by decide +kernel) + +theorem finite_row_works_699_i6 : FiniteTemplate HasSnaky 5 required_699_i6 envelope_699_i6 := by + refine finite_compose HasSnaky 4 childrenC_699_i6 childrenD_699_i6 finite_children_work_699_i6 (7, 4) + required_699_i6 envelope_699_i6 pivot_mem_699_i6 child_required_sub_699_i6 child_envelope_sub_699_i6 ?_ + intro b hb + exact common_sub_699_i6 (mem_commonEnvelope childrenD_699_i6 b hb) + +theorem finite_children_work_699_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_699_i5 j) (childrenD_699_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 6 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_48 6 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_134 3 (4, 6)).mono (by decide +kernel) + · exact finite_row_works_699_i6.mono (by decide +kernel) + +theorem finite_row_works_699_i5 : FiniteTemplate HasSnaky 7 required_699_i5 envelope_699_i5 := by + refine finite_compose HasSnaky 6 childrenC_699_i5 childrenD_699_i5 finite_children_work_699_i5 (6, 3) + required_699_i5 envelope_699_i5 pivot_mem_699_i5 child_required_sub_699_i5 child_envelope_sub_699_i5 ?_ + intro b hb + exact common_sub_699_i5 (mem_commonEnvelope childrenD_699_i5 b hb) + +theorem finite_children_work_699_i4 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_699_i4 j) (childrenD_699_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_389 3 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_545 0 (5, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_546 4 (5, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_549 0 (5, 0)).mono (by decide +kernel) + · exact finite_row_works_699_i5.mono (by decide +kernel) + +theorem finite_row_works_699_i4 : FiniteTemplate HasSnaky 11 required_699_i4 envelope_699_i4 := by + refine finite_compose HasSnaky 10 childrenC_699_i4 childrenD_699_i4 finite_children_work_699_i4 (6, 4) + required_699_i4 envelope_699_i4 pivot_mem_699_i4 child_required_sub_699_i4 child_envelope_sub_699_i4 ?_ + intro b hb + exact common_sub_699_i4 (mem_commonEnvelope childrenD_699_i4 b hb) + +theorem finite_children_work_699 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_699 j) (childrenD_699 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_197 0 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_321 0 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_693 2 (11, 0)).mono (by decide +kernel) + · exact finite_row_works_699_i0.mono (by decide +kernel) + · exact finite_row_works_699_i4.mono (by decide +kernel) + +theorem finite_row_works_699 : FiniteTemplate HasSnaky 15 required_699 envelope_699 := by + refine finite_compose HasSnaky 14 childrenC_699 childrenD_699 finite_children_work_699 (7, 5) + required_699 envelope_699 pivot_mem_699 child_required_sub_699 child_envelope_sub_699 ?_ + intro b hb + exact common_sub_699 (mem_commonEnvelope childrenD_699 b hb) + +theorem finite_children_work_712_i1 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_712_i1 j) (childrenD_712_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 4 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_545 5 (10, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_655 7 (10, 7)).mono (by decide +kernel) + +theorem finite_row_works_712_i1 : FiniteTemplate HasSnaky 11 required_712_i1 envelope_712_i1 := by + refine finite_compose HasSnaky 10 childrenC_712_i1 childrenD_712_i1 finite_children_work_712_i1 (6, 4) + required_712_i1 envelope_712_i1 pivot_mem_712_i1 child_required_sub_712_i1 child_envelope_sub_712_i1 ?_ + intro b hb + exact common_sub_712_i1 (mem_commonEnvelope childrenD_712_i1 b hb) + +theorem finite_children_work_712_i0 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_712_i0 j) (childrenD_712_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_116 3 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_297 3 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_649 7 (10, 8)).mono (by decide +kernel) + · exact finite_row_works_712_i1.mono (by decide +kernel) + +theorem finite_row_works_712_i0 : FiniteTemplate HasSnaky 13 required_712_i0 envelope_712_i0 := by + refine finite_compose HasSnaky 12 childrenC_712_i0 childrenD_712_i0 finite_children_work_712_i0 (5, 4) + required_712_i0 envelope_712_i0 pivot_mem_712_i0 child_required_sub_712_i0 child_envelope_sub_712_i0 ?_ + intro b hb + exact common_sub_712_i0 (mem_commonEnvelope childrenD_712_i0 b hb) + +theorem finite_children_work_712 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_712 j) (childrenD_712 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_174 4 (2, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_508 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_508 5 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_566 4 (2, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_605 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_605 5 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_647 4 (1, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_650 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_650 5 (10, 2)).mono (by decide +kernel) + · exact finite_row_works_712_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_661 2 (9, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_710 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_711 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_712 : FiniteTemplate HasSnaky 15 required_712 envelope_712 := by + refine finite_compose HasSnaky 14 childrenC_712 childrenD_712 finite_children_work_712 (5, 6) + required_712 envelope_712 pivot_mem_712 child_required_sub_712 child_envelope_sub_712 ?_ + intro b hb + exact common_sub_712 (mem_commonEnvelope childrenD_712 b hb) + +theorem finite_children_work_713 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_713 j) (childrenD_713 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_508 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_508 5 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_605 1 (2, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_605 5 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_645 4 (1, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_647 4 (1, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_650 1 (0, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_650 5 (10, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_654 4 (2, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_654 6 (8, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_711 0 (1, 0)).mono (by decide +kernel) + +theorem finite_row_works_713 : FiniteTemplate HasSnaky 15 required_713 envelope_713 := by + refine finite_compose HasSnaky 14 childrenC_713 childrenD_713 finite_children_work_713 (5, 6) + required_713 envelope_713 pivot_mem_713 child_required_sub_713 child_envelope_sub_713 ?_ + intro b hb + exact common_sub_713 (mem_commonEnvelope childrenD_713 b hb) + +theorem finite_children_work_718_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_718_i0 j) (childrenD_718_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 5 (8, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 5 (8, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_155 6 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_341 3 (2, 8)).mono (by decide +kernel) + +theorem finite_row_works_718_i0 : FiniteTemplate HasSnaky 8 required_718_i0 envelope_718_i0 := by + refine finite_compose HasSnaky 7 childrenC_718_i0 childrenD_718_i0 finite_children_work_718_i0 (6, 5) + required_718_i0 envelope_718_i0 pivot_mem_718_i0 child_required_sub_718_i0 child_envelope_sub_718_i0 ?_ + intro b hb + exact common_sub_718_i0 (mem_commonEnvelope childrenD_718_i0 b hb) + +theorem finite_children_work_718_i1 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_718_i1 j) (childrenD_718_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_452 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_520 2 (10, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 4 (5, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_612 7 (8, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_633 0 (2, 1)).mono (by decide +kernel) + +theorem finite_row_works_718_i1 : FiniteTemplate HasSnaky 13 required_718_i1 envelope_718_i1 := by + refine finite_compose HasSnaky 12 childrenC_718_i1 childrenD_718_i1 finite_children_work_718_i1 (7, 6) + required_718_i1 envelope_718_i1 pivot_mem_718_i1 child_required_sub_718_i1 child_envelope_sub_718_i1 ?_ + intro b hb + exact common_sub_718_i1 (mem_commonEnvelope childrenD_718_i1 b hb) + +theorem finite_children_work_718_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_718_i3 j) (childrenD_718_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 3 (4, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 7 (8, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_232 1 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_232 5 (8, 5)).mono (by decide +kernel) + +theorem finite_row_works_718_i3 : FiniteTemplate HasSnaky 6 required_718_i3 envelope_718_i3 := by + refine finite_compose HasSnaky 5 childrenC_718_i3 childrenD_718_i3 finite_children_work_718_i3 (6, 6) + required_718_i3 envelope_718_i3 pivot_mem_718_i3 child_required_sub_718_i3 child_envelope_sub_718_i3 ?_ + intro b hb + exact common_sub_718_i3 (mem_commonEnvelope childrenD_718_i3 b hb) + +theorem finite_children_work_718_i5 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_718_i5 j) (childrenD_718_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 3 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_229 5 (9, 3)).mono (by decide +kernel) + +theorem finite_row_works_718_i5 : FiniteTemplate HasSnaky 5 required_718_i5 envelope_718_i5 := by + refine finite_compose HasSnaky 4 childrenC_718_i5 childrenD_718_i5 finite_children_work_718_i5 (7, 3) + required_718_i5 envelope_718_i5 pivot_mem_718_i5 child_required_sub_718_i5 child_envelope_sub_718_i5 ?_ + intro b hb + exact common_sub_718_i5 (mem_commonEnvelope childrenD_718_i5 b hb) + +theorem finite_children_work_718_i4 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_718_i4 j) (childrenD_718_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 4 (6, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 6 (8, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 0 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_377 2 (8, 3)).mono (by decide +kernel) + · exact finite_row_works_718_i5.mono (by decide +kernel) + +theorem finite_row_works_718_i4 : FiniteTemplate HasSnaky 6 required_718_i4 envelope_718_i4 := by + refine finite_compose HasSnaky 5 childrenC_718_i4 childrenD_718_i4 finite_children_work_718_i4 (7, 4) + required_718_i4 envelope_718_i4 pivot_mem_718_i4 child_required_sub_718_i4 child_envelope_sub_718_i4 ?_ + intro b hb + exact common_sub_718_i4 (mem_commonEnvelope childrenD_718_i4 b hb) + +theorem finite_children_work_718_i6 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_718_i6 j) (childrenD_718_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_315 5 (8, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_317 0 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_640 4 (3, 9)).mono (by decide +kernel) + +theorem finite_row_works_718_i6 : FiniteTemplate HasSnaky 10 required_718_i6 envelope_718_i6 := by + refine finite_compose HasSnaky 9 childrenC_718_i6 childrenD_718_i6 finite_children_work_718_i6 (6, 6) + required_718_i6 envelope_718_i6 pivot_mem_718_i6 child_required_sub_718_i6 child_envelope_sub_718_i6 ?_ + intro b hb + exact common_sub_718_i6 (mem_commonEnvelope childrenD_718_i6 b hb) + +theorem finite_children_work_718_i2 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_718_i2 j) (childrenD_718_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_329 5 (10, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_452 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_462 4 (6, 9)).mono (by decide +kernel) + · exact finite_row_works_718_i3.mono (by decide +kernel) + · exact finite_row_works_718_i4.mono (by decide +kernel) + · exact finite_row_works_718_i6.mono (by decide +kernel) + +theorem finite_row_works_718_i2 : FiniteTemplate HasSnaky 14 required_718_i2 envelope_718_i2 := by + refine finite_compose HasSnaky 13 childrenC_718_i2 childrenD_718_i2 finite_children_work_718_i2 (7, 6) + required_718_i2 envelope_718_i2 pivot_mem_718_i2 child_required_sub_718_i2 child_envelope_sub_718_i2 ?_ + intro b hb + exact common_sub_718_i2 (mem_commonEnvelope childrenD_718_i2 b hb) + +theorem finite_children_work_718 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_718 j) (childrenD_718 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_120 6 (8, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_276 3 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_338 3 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_437 3 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_611 3 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_642 0 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_643 0 (4, 1)).mono (by decide +kernel) + · exact finite_row_works_718_i0.mono (by decide +kernel) + · exact finite_row_works_718_i1.mono (by decide +kernel) + · exact finite_row_works_718_i2.mono (by decide +kernel) + +theorem finite_row_works_718 : FiniteTemplate HasSnaky 15 required_718 envelope_718 := by + refine finite_compose HasSnaky 14 childrenC_718 childrenD_718 finite_children_work_718 (7, 5) + required_718 envelope_718 pivot_mem_718 child_required_sub_718 child_envelope_sub_718 ?_ + intro b hb + exact common_sub_718 (mem_commonEnvelope childrenD_718 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height15Part04.lean b/lean/snaky/FiniteCards/Height15Part04.lean new file mode 100644 index 0000000..ba5fef9 --- /dev/null +++ b/lean/snaky/FiniteCards/Height15Part04.lean @@ -0,0 +1,140 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part04 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height08Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_719_i5 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_719_i5 j) (childrenD_719_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_412 0 (3, 4)).mono (by decide +kernel) + +theorem finite_row_works_719_i5 : FiniteTemplate HasSnaky 9 required_719_i5 envelope_719_i5 := by + refine finite_compose HasSnaky 8 childrenC_719_i5 childrenD_719_i5 finite_children_work_719_i5 (3, 8) + required_719_i5 envelope_719_i5 pivot_mem_719_i5 child_required_sub_719_i5 child_envelope_sub_719_i5 ?_ + intro b hb + exact common_sub_719_i5 (mem_commonEnvelope childrenD_719_i5 b hb) + +theorem finite_children_work_719_i4 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_719_i4 j) (childrenD_719_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_45 3 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_343 5 (6, 5)).mono (by decide +kernel) + · exact finite_row_works_719_i5.mono (by decide +kernel) + +theorem finite_row_works_719_i4 : FiniteTemplate HasSnaky 10 required_719_i4 envelope_719_i4 := by + refine finite_compose HasSnaky 9 childrenC_719_i4 childrenD_719_i4 finite_children_work_719_i4 (4, 5) + required_719_i4 envelope_719_i4 pivot_mem_719_i4 child_required_sub_719_i4 child_envelope_sub_719_i4 ?_ + intro b hb + exact common_sub_719_i4 (mem_commonEnvelope childrenD_719_i4 b hb) + +theorem finite_children_work_719_i3 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_719_i3 j) (childrenD_719_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 7 (4, 9)).mono (by decide +kernel) + · exact finite_row_works_719_i4.mono (by decide +kernel) + +theorem finite_row_works_719_i3 : FiniteTemplate HasSnaky 11 required_719_i3 envelope_719_i3 := by + refine finite_compose HasSnaky 10 childrenC_719_i3 childrenD_719_i3 finite_children_work_719_i3 (4, 8) + required_719_i3 envelope_719_i3 pivot_mem_719_i3 child_required_sub_719_i3 child_envelope_sub_719_i3 ?_ + intro b hb + exact common_sub_719_i3 (mem_commonEnvelope childrenD_719_i3 b hb) + +theorem finite_children_work_719_i2 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_719_i2 j) (childrenD_719_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_1 1 (3, 3)).mono (by decide +kernel) + · exact finite_row_works_719_i3.mono (by decide +kernel) + +theorem finite_row_works_719_i2 : FiniteTemplate HasSnaky 12 required_719_i2 envelope_719_i2 := by + refine finite_compose HasSnaky 11 childrenC_719_i2 childrenD_719_i2 finite_children_work_719_i2 (4, 7) + required_719_i2 envelope_719_i2 pivot_mem_719_i2 child_required_sub_719_i2 child_envelope_sub_719_i2 ?_ + intro b hb + exact common_sub_719_i2 (mem_commonEnvelope childrenD_719_i2 b hb) + +theorem finite_children_work_719_i1 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_719_i1 j) (childrenD_719_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 1 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 7 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_209 7 (5, 6)).mono (by decide +kernel) + · exact finite_row_works_719_i2.mono (by decide +kernel) + +theorem finite_row_works_719_i1 : FiniteTemplate HasSnaky 13 required_719_i1 envelope_719_i1 := by + refine finite_compose HasSnaky 12 childrenC_719_i1 childrenD_719_i1 finite_children_work_719_i1 (4, 6) + required_719_i1 envelope_719_i1 pivot_mem_719_i1 child_required_sub_719_i1 child_envelope_sub_719_i1 ?_ + intro b hb + exact common_sub_719_i1 (mem_commonEnvelope childrenD_719_i1 b hb) + +theorem finite_children_work_719_i0 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_719_i0 j) (childrenD_719_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 6 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_209 6 (3, 7)).mono (by decide +kernel) + · exact finite_row_works_719_i1.mono (by decide +kernel) + +theorem finite_row_works_719_i0 : FiniteTemplate HasSnaky 14 required_719_i0 envelope_719_i0 := by + refine finite_compose HasSnaky 13 childrenC_719_i0 childrenD_719_i0 finite_children_work_719_i0 (3, 6) + required_719_i0 envelope_719_i0 pivot_mem_719_i0 child_required_sub_719_i0 child_envelope_sub_719_i0 ?_ + intro b hb + exact common_sub_719_i0 (mem_commonEnvelope childrenD_719_i0 b hb) + +theorem finite_children_work_719_i6 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_719_i6 j) (childrenD_719_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_65 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_301 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_417 7 (5, 5)).mono (by decide +kernel) + +theorem finite_row_works_719_i6 : FiniteTemplate HasSnaky 7 required_719_i6 envelope_719_i6 := by + refine finite_compose HasSnaky 6 childrenC_719_i6 childrenD_719_i6 finite_children_work_719_i6 (3, 4) + required_719_i6 envelope_719_i6 pivot_mem_719_i6 child_required_sub_719_i6 child_envelope_sub_719_i6 ?_ + intro b hb + exact common_sub_719_i6 (mem_commonEnvelope childrenD_719_i6 b hb) + +theorem finite_children_work_719_i7 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_719_i7 j) (childrenD_719_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 2 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_65 0 (2, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_72 1 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_719_i7 : FiniteTemplate HasSnaky 6 required_719_i7 envelope_719_i7 := by + refine finite_compose HasSnaky 5 childrenC_719_i7 childrenD_719_i7 finite_children_work_719_i7 (3, 4) + required_719_i7 envelope_719_i7 pivot_mem_719_i7 child_required_sub_719_i7 child_envelope_sub_719_i7 ?_ + intro b hb + exact common_sub_719_i7 (mem_commonEnvelope childrenD_719_i7 b hb) + +theorem finite_children_work_719 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_719 j) (childrenD_719 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_318 2 (3, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_334 4 (2, 7)).mono (by decide +kernel) + · exact finite_row_works_719_i0.mono (by decide +kernel) + · exact finite_row_works_719_i6.mono (by decide +kernel) + · exact finite_row_works_719_i7.mono (by decide +kernel) + +theorem finite_row_works_719 : FiniteTemplate HasSnaky 15 required_719 envelope_719 := by + refine finite_compose HasSnaky 14 childrenC_719 childrenD_719 finite_children_work_719 (3, 3) + required_719 envelope_719 pivot_mem_719 child_required_sub_719 child_envelope_sub_719 ?_ + intro b hb + exact common_sub_719 (mem_commonEnvelope childrenD_719 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height16Part01.lean b/lean/snaky/FiniteCards/Height16Part01.lean new file mode 100644 index 0000000..3ef4e51 --- /dev/null +++ b/lean/snaky/FiniteCards/Height16Part01.lean @@ -0,0 +1,321 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part05 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part04 +import FiniteCards.Height05Part05 +import FiniteCards.Height05Part06 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part05 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part03 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height09Part05 +import FiniteCards.Height10Part02 +import FiniteCards.Height10Part03 +import FiniteCards.Height11Part03 +import FiniteCards.Height11Part04 +import FiniteCards.Height12Part03 +import FiniteCards.Height13Part01 +import FiniteCards.Height13Part02 +import FiniteCards.Height13Part03 +import FiniteCards.Height14Part01 +import FiniteCards.Height14Part02 +import FiniteCards.Height15Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_602_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_602_i1 j) (childrenD_602_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_320 0 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_496 3 (2, 8)).mono (by decide +kernel) + +theorem finite_row_works_602_i1 : FiniteTemplate HasSnaky 8 required_602_i1 envelope_602_i1 := by + refine finite_compose HasSnaky 7 childrenC_602_i1 childrenD_602_i1 finite_children_work_602_i1 (5, 8) + required_602_i1 envelope_602_i1 pivot_mem_602_i1 child_required_sub_602_i1 child_envelope_sub_602_i1 ?_ + intro b hb + exact common_sub_602_i1 (mem_commonEnvelope childrenD_602_i1 b hb) + +theorem finite_children_work_602_i0 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_602_i0 j) (childrenD_602_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_59 4 (3, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_497 3 (2, 8)).mono (by decide +kernel) + · exact finite_row_works_602_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_555 0 (3, 3)).mono (by decide +kernel) + +theorem finite_row_works_602_i0 : FiniteTemplate HasSnaky 14 required_602_i0 envelope_602_i0 := by + refine finite_compose HasSnaky 13 childrenC_602_i0 childrenD_602_i0 finite_children_work_602_i0 (6, 8) + required_602_i0 envelope_602_i0 pivot_mem_602_i0 child_required_sub_602_i0 child_envelope_sub_602_i0 ?_ + intro b hb + exact common_sub_602_i0 (mem_commonEnvelope childrenD_602_i0 b hb) + +theorem finite_children_work_602_i3 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_602_i3 j) (childrenD_602_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_2 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_545 4 (5, 12)).mono (by decide +kernel) + +theorem finite_row_works_602_i3 : FiniteTemplate HasSnaky 11 required_602_i3 envelope_602_i3 := by + refine finite_compose HasSnaky 10 childrenC_602_i3 childrenD_602_i3 finite_children_work_602_i3 (6, 8) + required_602_i3 envelope_602_i3 pivot_mem_602_i3 child_required_sub_602_i3 child_envelope_sub_602_i3 ?_ + intro b hb + exact common_sub_602_i3 (mem_commonEnvelope childrenD_602_i3 b hb) + +theorem finite_children_work_602_i2 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_602_i2 j) (childrenD_602_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_107 3 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_163 3 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_556 4 (3, 11)).mono (by decide +kernel) + · exact finite_row_works_602_i3.mono (by decide +kernel) + +theorem finite_row_works_602_i2 : FiniteTemplate HasSnaky 12 required_602_i2 envelope_602_i2 := by + refine finite_compose HasSnaky 11 childrenC_602_i2 childrenD_602_i2 finite_children_work_602_i2 (7, 7) + required_602_i2 envelope_602_i2 pivot_mem_602_i2 child_required_sub_602_i2 child_envelope_sub_602_i2 ?_ + intro b hb + exact common_sub_602_i2 (mem_commonEnvelope childrenD_602_i2 b hb) + +theorem finite_children_work_602_i6 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_602_i6 j) (childrenD_602_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_157 0 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_383 2 (6, 3)).mono (by decide +kernel) + +theorem finite_row_works_602_i6 : FiniteTemplate HasSnaky 6 required_602_i6 envelope_602_i6 := by + refine finite_compose HasSnaky 5 childrenC_602_i6 childrenD_602_i6 finite_children_work_602_i6 (6, 5) + required_602_i6 envelope_602_i6 pivot_mem_602_i6 child_required_sub_602_i6 child_envelope_sub_602_i6 ?_ + intro b hb + exact common_sub_602_i6 (mem_commonEnvelope childrenD_602_i6 b hb) + +theorem finite_children_work_602_i7 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_602_i7 j) (childrenD_602_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 0 (5, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_381 7 (7, 8)).mono (by decide +kernel) + +theorem finite_row_works_602_i7 : FiniteTemplate HasSnaky 5 required_602_i7 envelope_602_i7 := by + refine finite_compose HasSnaky 4 childrenC_602_i7 childrenD_602_i7 finite_children_work_602_i7 (6, 6) + required_602_i7 envelope_602_i7 pivot_mem_602_i7 child_required_sub_602_i7 child_envelope_sub_602_i7 ?_ + intro b hb + exact common_sub_602_i7 (mem_commonEnvelope childrenD_602_i7 b hb) + +theorem finite_children_work_602_i8 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_602_i8 j) (childrenD_602_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_64 0 (5, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_500 3 (2, 8)).mono (by decide +kernel) + +theorem finite_row_works_602_i8 : FiniteTemplate HasSnaky 5 required_602_i8 envelope_602_i8 := by + refine finite_compose HasSnaky 4 childrenC_602_i8 childrenD_602_i8 finite_children_work_602_i8 (5, 7) + required_602_i8 envelope_602_i8 pivot_mem_602_i8 child_required_sub_602_i8 child_envelope_sub_602_i8 ?_ + intro b hb + exact common_sub_602_i8 (mem_commonEnvelope childrenD_602_i8 b hb) + +theorem finite_children_work_602_i5 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_602_i5 j) (childrenD_602_i5 j) := by + intro j + fin_cases j + · exact finite_row_works_602_i6.mono (by decide +kernel) + · exact finite_row_works_602_i7.mono (by decide +kernel) + · exact finite_row_works_602_i8.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_601 3 (1, 8)).mono (by decide +kernel) + +theorem finite_row_works_602_i5 : FiniteTemplate HasSnaky 12 required_602_i5 envelope_602_i5 := by + refine finite_compose HasSnaky 11 childrenC_602_i5 childrenD_602_i5 finite_children_work_602_i5 (5, 5) + required_602_i5 envelope_602_i5 pivot_mem_602_i5 child_required_sub_602_i5 child_envelope_sub_602_i5 ?_ + intro b hb + exact common_sub_602_i5 (mem_commonEnvelope childrenD_602_i5 b hb) + +theorem finite_children_work_602_i4 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_602_i4 j) (childrenD_602_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_119 0 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_497 3 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_498 1 (2, 4)).mono (by decide +kernel) + · exact finite_row_works_602_i5.mono (by decide +kernel) + +theorem finite_row_works_602_i4 : FiniteTemplate HasSnaky 13 required_602_i4 envelope_602_i4 := by + refine finite_compose HasSnaky 12 childrenC_602_i4 childrenD_602_i4 finite_children_work_602_i4 (6, 8) + required_602_i4 envelope_602_i4 pivot_mem_602_i4 child_required_sub_602_i4 child_envelope_sub_602_i4 ?_ + intro b hb + exact common_sub_602_i4 (mem_commonEnvelope childrenD_602_i4 b hb) + +theorem finite_children_work_602 : ∀ j, FiniteTemplate HasSnaky 15 (childrenC_602 j) (childrenD_602 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_553 0 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_602_i0.mono (by decide +kernel) + · exact finite_row_works_602_i2.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_557 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_564 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_568 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_573 3 (0, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_574 4 (2, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_583 4 (0, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_598 4 (0, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_599 0 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_602_i4.mono (by decide +kernel) + +theorem finite_row_works_602 : FiniteTemplate HasSnaky 16 required_602 envelope_602 := by + refine finite_compose HasSnaky 15 childrenC_602 childrenD_602 finite_children_work_602 (6, 7) + required_602 envelope_602 pivot_mem_602 child_required_sub_602 child_envelope_sub_602 ?_ + intro b hb + exact common_sub_602 (mem_commonEnvelope childrenD_602 b hb) + +theorem finite_children_work_627_i0 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_627_i0 j) (childrenD_627_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 4 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_472 2 (7, 2)).mono (by decide +kernel) + +theorem finite_row_works_627_i0 : FiniteTemplate HasSnaky 8 required_627_i0 envelope_627_i0 := by + refine finite_compose HasSnaky 7 childrenC_627_i0 childrenD_627_i0 finite_children_work_627_i0 (4, 4) + required_627_i0 envelope_627_i0 pivot_mem_627_i0 child_required_sub_627_i0 child_envelope_sub_627_i0 ?_ + intro b hb + exact common_sub_627_i0 (mem_commonEnvelope childrenD_627_i0 b hb) + +theorem finite_children_work_627_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_627_i3 j) (childrenD_627_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_38 7 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_205 6 (6, 7)).mono (by decide +kernel) + +theorem finite_row_works_627_i3 : FiniteTemplate HasSnaky 4 required_627_i3 envelope_627_i3 := by + refine finite_compose HasSnaky 3 childrenC_627_i3 childrenD_627_i3 finite_children_work_627_i3 (5, 3) + required_627_i3 envelope_627_i3 pivot_mem_627_i3 child_required_sub_627_i3 child_envelope_sub_627_i3 ?_ + intro b hb + exact common_sub_627_i3 (mem_commonEnvelope childrenD_627_i3 b hb) + +theorem finite_children_work_627_i2 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_627_i2 j) (childrenD_627_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (5, 7)).mono (by decide +kernel) + · exact finite_row_works_627_i3.mono (by decide +kernel) + +theorem finite_row_works_627_i2 : FiniteTemplate HasSnaky 5 required_627_i2 envelope_627_i2 := by + refine finite_compose HasSnaky 4 childrenC_627_i2 childrenD_627_i2 finite_children_work_627_i2 (5, 5) + required_627_i2 envelope_627_i2 pivot_mem_627_i2 child_required_sub_627_i2 child_envelope_sub_627_i2 ?_ + intro b hb + exact common_sub_627_i2 (mem_commonEnvelope childrenD_627_i2 b hb) + +theorem finite_children_work_627_i5 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_627_i5 j) (childrenD_627_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_38 7 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_179 3 (3, 7)).mono (by decide +kernel) + +theorem finite_row_works_627_i5 : FiniteTemplate HasSnaky 6 required_627_i5 envelope_627_i5 := by + refine finite_compose HasSnaky 5 childrenC_627_i5 childrenD_627_i5 finite_children_work_627_i5 (5, 3) + required_627_i5 envelope_627_i5 pivot_mem_627_i5 child_required_sub_627_i5 child_envelope_sub_627_i5 ?_ + intro b hb + exact common_sub_627_i5 (mem_commonEnvelope childrenD_627_i5 b hb) + +theorem finite_children_work_627_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_627_i4 j) (childrenD_627_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (5, 7)).mono (by decide +kernel) + · exact finite_row_works_627_i5.mono (by decide +kernel) + +theorem finite_row_works_627_i4 : FiniteTemplate HasSnaky 7 required_627_i4 envelope_627_i4 := by + refine finite_compose HasSnaky 6 childrenC_627_i4 childrenD_627_i4 finite_children_work_627_i4 (5, 5) + required_627_i4 envelope_627_i4 pivot_mem_627_i4 child_required_sub_627_i4 child_envelope_sub_627_i4 ?_ + intro b hb + exact common_sub_627_i4 (mem_commonEnvelope childrenD_627_i4 b hb) + +theorem finite_children_work_627_i6 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_627_i6 j) (childrenD_627_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_50 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_97 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_98 0 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_454 4 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_455 1 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_624 5 (10, 3)).mono (by decide +kernel) + +theorem finite_row_works_627_i6 : FiniteTemplate HasSnaky 12 required_627_i6 envelope_627_i6 := by + refine finite_compose HasSnaky 11 childrenC_627_i6 childrenD_627_i6 finite_children_work_627_i6 (5, 7) + required_627_i6 envelope_627_i6 pivot_mem_627_i6 child_required_sub_627_i6 child_envelope_sub_627_i6 ?_ + intro b hb + exact common_sub_627_i6 (mem_commonEnvelope childrenD_627_i6 b hb) + +theorem finite_children_work_627_i8 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_627_i8 j) (childrenD_627_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_38 7 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_413 0 (4, 2)).mono (by decide +kernel) + +theorem finite_row_works_627_i8 : FiniteTemplate HasSnaky 6 required_627_i8 envelope_627_i8 := by + refine finite_compose HasSnaky 5 childrenC_627_i8 childrenD_627_i8 finite_children_work_627_i8 (5, 3) + required_627_i8 envelope_627_i8 pivot_mem_627_i8 child_required_sub_627_i8 child_envelope_sub_627_i8 ?_ + intro b hb + exact common_sub_627_i8 (mem_commonEnvelope childrenD_627_i8 b hb) + +theorem finite_children_work_627_i7 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_627_i7 j) (childrenD_627_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 3 (5, 7)).mono (by decide +kernel) + · exact finite_row_works_627_i8.mono (by decide +kernel) + +theorem finite_row_works_627_i7 : FiniteTemplate HasSnaky 7 required_627_i7 envelope_627_i7 := by + refine finite_compose HasSnaky 6 childrenC_627_i7 childrenD_627_i7 finite_children_work_627_i7 (5, 5) + required_627_i7 envelope_627_i7 pivot_mem_627_i7 child_required_sub_627_i7 child_envelope_sub_627_i7 ?_ + intro b hb + exact common_sub_627_i7 (mem_commonEnvelope childrenD_627_i7 b hb) + +theorem finite_children_work_627_i9 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_627_i9 j) (childrenD_627_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_59 5 (9, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_105 2 (6, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_323 3 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_603 1 (2, 5)).mono (by decide +kernel) + +theorem finite_row_works_627_i9 : FiniteTemplate HasSnaky 14 required_627_i9 envelope_627_i9 := by + refine finite_compose HasSnaky 13 childrenC_627_i9 childrenD_627_i9 finite_children_work_627_i9 (6, 6) + required_627_i9 envelope_627_i9 pivot_mem_627_i9 child_required_sub_627_i9 child_envelope_sub_627_i9 ?_ + intro b hb + exact common_sub_627_i9 (mem_commonEnvelope childrenD_627_i9 b hb) + +theorem finite_children_work_627_i1 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_627_i1 j) (childrenD_627_i1 j) := by + intro j + fin_cases j + · exact finite_row_works_627_i2.mono (by decide +kernel) + · exact finite_row_works_627_i4.mono (by decide +kernel) + · exact finite_row_works_627_i6.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_626 1 (0, 1)).mono (by decide +kernel) + · exact finite_row_works_627_i7.mono (by decide +kernel) + · exact finite_row_works_627_i9.mono (by decide +kernel) + +theorem finite_row_works_627_i1 : FiniteTemplate HasSnaky 15 required_627_i1 envelope_627_i1 := by + refine finite_compose HasSnaky 14 childrenC_627_i1 childrenD_627_i1 finite_children_work_627_i1 (5, 6) + required_627_i1 envelope_627_i1 pivot_mem_627_i1 child_required_sub_627_i1 child_envelope_sub_627_i1 ?_ + intro b hb + exact common_sub_627_i1 (mem_commonEnvelope childrenD_627_i1 b hb) + +theorem finite_children_work_627 : ∀ j, FiniteTemplate HasSnaky 15 (childrenC_627 j) (childrenD_627 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_34 7 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_478 0 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_627_i0.mono (by decide +kernel) + · exact finite_row_works_627_i1.mono (by decide +kernel) + +theorem finite_row_works_627 : FiniteTemplate HasSnaky 16 required_627 envelope_627 := by + refine finite_compose HasSnaky 15 childrenC_627 childrenD_627 finite_children_work_627 (5, 4) + required_627 envelope_627 pivot_mem_627 child_required_sub_627 child_envelope_sub_627 ?_ + intro b hb + exact common_sub_627 (mem_commonEnvelope childrenD_627 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height16Part02.lean b/lean/snaky/FiniteCards/Height16Part02.lean new file mode 100644 index 0000000..9e439d9 --- /dev/null +++ b/lean/snaky/FiniteCards/Height16Part02.lean @@ -0,0 +1,225 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height03Part02 +import FiniteCards.Height03Part03 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part03 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part02 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part03 +import FiniteCards.Height08Part04 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part03 +import FiniteCards.Height11Part02 +import FiniteCards.Height13Part03 +import FiniteCards.Height15Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_683_i0 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_683_i0 j) (childrenD_683_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 3 (0, 6)).mono (by decide +kernel) + +theorem finite_row_works_683_i0 : FiniteTemplate HasSnaky 4 required_683_i0 envelope_683_i0 := by + refine finite_compose HasSnaky 3 childrenC_683_i0 childrenD_683_i0 finite_children_work_683_i0 (2, 5) + required_683_i0 envelope_683_i0 pivot_mem_683_i0 child_required_sub_683_i0 child_envelope_sub_683_i0 ?_ + intro b hb + exact common_sub_683_i0 (mem_commonEnvelope childrenD_683_i0 b hb) + +theorem finite_children_work_683_i1 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_683_i1 j) (childrenD_683_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 6 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_604 0 (1, 2)).mono (by decide +kernel) + +theorem finite_row_works_683_i1 : FiniteTemplate HasSnaky 9 required_683_i1 envelope_683_i1 := by + refine finite_compose HasSnaky 8 childrenC_683_i1 childrenD_683_i1 finite_children_work_683_i1 (2, 5) + required_683_i1 envelope_683_i1 pivot_mem_683_i1 child_required_sub_683_i1 child_envelope_sub_683_i1 ?_ + intro b hb + exact common_sub_683_i1 (mem_commonEnvelope childrenD_683_i1 b hb) + +theorem finite_children_work_683 : ∀ j, FiniteTemplate HasSnaky 15 (childrenC_683 j) (childrenD_683 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_50 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_150 1 (0, 4)).mono (by decide +kernel) + · exact finite_row_works_683_i0.mono (by decide +kernel) + · exact finite_row_works_683_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_682 4 (0, 10)).mono (by decide +kernel) + +theorem finite_row_works_683 : FiniteTemplate HasSnaky 16 required_683 envelope_683 := by + refine finite_compose HasSnaky 15 childrenC_683 childrenD_683 finite_children_work_683 (3, 5) + required_683 envelope_683 pivot_mem_683 child_required_sub_683 child_envelope_sub_683 ?_ + intro b hb + exact common_sub_683 (mem_commonEnvelope childrenD_683 b hb) + +theorem finite_children_work_706_i2 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_706_i2 j) (childrenD_706_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_4 4 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (2, 3)).mono (by decide +kernel) + +theorem finite_row_works_706_i2 : FiniteTemplate HasSnaky 4 required_706_i2 envelope_706_i2 := by + refine finite_compose HasSnaky 3 childrenC_706_i2 childrenD_706_i2 finite_children_work_706_i2 (6, 4) + required_706_i2 envelope_706_i2 pivot_mem_706_i2 child_required_sub_706_i2 child_envelope_sub_706_i2 ?_ + intro b hb + exact common_sub_706_i2 (mem_commonEnvelope childrenD_706_i2 b hb) + +theorem finite_children_work_706_i3 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_706_i3 j) (childrenD_706_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_154 3 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_159 4 (3, 6)).mono (by decide +kernel) + +theorem finite_row_works_706_i3 : FiniteTemplate HasSnaky 4 required_706_i3 envelope_706_i3 := by + refine finite_compose HasSnaky 3 childrenC_706_i3 childrenD_706_i3 finite_children_work_706_i3 (5, 3) + required_706_i3 envelope_706_i3 pivot_mem_706_i3 child_required_sub_706_i3 child_envelope_sub_706_i3 ?_ + intro b hb + exact common_sub_706_i3 (mem_commonEnvelope childrenD_706_i3 b hb) + +theorem finite_children_work_706_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_706_i4 j) (childrenD_706_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 3 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_152 2 (8, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_166 0 (4, 1)).mono (by decide +kernel) + +theorem finite_row_works_706_i4 : FiniteTemplate HasSnaky 7 required_706_i4 envelope_706_i4 := by + refine finite_compose HasSnaky 6 childrenC_706_i4 childrenD_706_i4 finite_children_work_706_i4 (7, 5) + required_706_i4 envelope_706_i4 pivot_mem_706_i4 child_required_sub_706_i4 child_envelope_sub_706_i4 ?_ + intro b hb + exact common_sub_706_i4 (mem_commonEnvelope childrenD_706_i4 b hb) + +theorem finite_children_work_706_i1 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_706_i1 j) (childrenD_706_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_261 3 (3, 4)).mono (by decide +kernel) + · exact finite_row_works_706_i2.mono (by decide +kernel) + · exact finite_row_works_706_i3.mono (by decide +kernel) + · exact finite_row_works_706_i4.mono (by decide +kernel) + +theorem finite_row_works_706_i1 : FiniteTemplate HasSnaky 8 required_706_i1 envelope_706_i1 := by + refine finite_compose HasSnaky 7 childrenC_706_i1 childrenD_706_i1 finite_children_work_706_i1 (7, 3) + required_706_i1 envelope_706_i1 pivot_mem_706_i1 child_required_sub_706_i1 child_envelope_sub_706_i1 ?_ + intro b hb + exact common_sub_706_i1 (mem_commonEnvelope childrenD_706_i1 b hb) + +theorem finite_children_work_706_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_706_i0 j) (childrenD_706_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_15 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_65 3 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_706_i1.mono (by decide +kernel) + +theorem finite_row_works_706_i0 : FiniteTemplate HasSnaky 9 required_706_i0 envelope_706_i0 := by + refine finite_compose HasSnaky 8 childrenC_706_i0 childrenD_706_i0 finite_children_work_706_i0 (3, 4) + required_706_i0 envelope_706_i0 pivot_mem_706_i0 child_required_sub_706_i0 child_envelope_sub_706_i0 ?_ + intro b hb + exact common_sub_706_i0 (mem_commonEnvelope childrenD_706_i0 b hb) + +theorem finite_children_work_706_i6 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_706_i6 j) (childrenD_706_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_318 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_334 7 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_379 3 (3, 5)).mono (by decide +kernel) + +theorem finite_row_works_706_i6 : FiniteTemplate HasSnaky 8 required_706_i6 envelope_706_i6 := by + refine finite_compose HasSnaky 7 childrenC_706_i6 childrenD_706_i6 finite_children_work_706_i6 (3, 3) + required_706_i6 envelope_706_i6 pivot_mem_706_i6 child_required_sub_706_i6 child_envelope_sub_706_i6 ?_ + intro b hb + exact common_sub_706_i6 (mem_commonEnvelope childrenD_706_i6 b hb) + +theorem finite_children_work_706_i7 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_706_i7 j) (childrenD_706_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_66 7 (6, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_238 7 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_394 3 (2, 5)).mono (by decide +kernel) + +theorem finite_row_works_706_i7 : FiniteTemplate HasSnaky 8 required_706_i7 envelope_706_i7 := by + refine finite_compose HasSnaky 7 childrenC_706_i7 childrenD_706_i7 finite_children_work_706_i7 (3, 4) + required_706_i7 envelope_706_i7 pivot_mem_706_i7 child_required_sub_706_i7 child_envelope_sub_706_i7 ?_ + intro b hb + exact common_sub_706_i7 (mem_commonEnvelope childrenD_706_i7 b hb) + +theorem finite_children_work_706_i5 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_706_i5 j) (childrenD_706_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_417 7 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_420 7 (6, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_526 7 (6, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_532 3 (0, 6)).mono (by decide +kernel) + · exact finite_row_works_706_i6.mono (by decide +kernel) + · exact finite_row_works_706_i7.mono (by decide +kernel) + +theorem finite_row_works_706_i5 : FiniteTemplate HasSnaky 9 required_706_i5 envelope_706_i5 := by + refine finite_compose HasSnaky 8 childrenC_706_i5 childrenD_706_i5 finite_children_work_706_i5 (5, 3) + required_706_i5 envelope_706_i5 pivot_mem_706_i5 child_required_sub_706_i5 child_envelope_sub_706_i5 ?_ + intro b hb + exact common_sub_706_i5 (mem_commonEnvelope childrenD_706_i5 b hb) + +theorem finite_children_work_706_i9 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_706_i9 j) (childrenD_706_i9 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_30 1 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_59 0 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_296 3 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_603 0 (6, 1)).mono (by decide +kernel) + +theorem finite_row_works_706_i9 : FiniteTemplate HasSnaky 14 required_706_i9 envelope_706_i9 := by + refine finite_compose HasSnaky 13 childrenC_706_i9 childrenD_706_i9 finite_children_work_706_i9 (7, 4) + required_706_i9 envelope_706_i9 pivot_mem_706_i9 child_required_sub_706_i9 child_envelope_sub_706_i9 ?_ + intro b hb + exact common_sub_706_i9 (mem_commonEnvelope childrenD_706_i9 b hb) + +theorem finite_children_work_706_i8 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_706_i8 j) (childrenD_706_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_22 3 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_74 3 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_325 4 (3, 9)).mono (by decide +kernel) + · exact finite_row_works_706_i9.mono (by decide +kernel) + +theorem finite_row_works_706_i8 : FiniteTemplate HasSnaky 15 required_706_i8 envelope_706_i8 := by + refine finite_compose HasSnaky 14 childrenC_706_i8 childrenD_706_i8 finite_children_work_706_i8 (7, 5) + required_706_i8 envelope_706_i8 pivot_mem_706_i8 child_required_sub_706_i8 child_envelope_sub_706_i8 ?_ + intro b hb + exact common_sub_706_i8 (mem_commonEnvelope childrenD_706_i8 b hb) + +theorem finite_children_work_706 : ∀ j, FiniteTemplate HasSnaky 15 (childrenC_706 j) (childrenD_706 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_512 7 (8, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_517 3 (1, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_527 7 (8, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_537 7 (8, 6)).mono (by decide +kernel) + · exact finite_row_works_706_i0.mono (by decide +kernel) + · exact finite_row_works_706_i5.mono (by decide +kernel) + · exact finite_row_works_706_i8.mono (by decide +kernel) + +theorem finite_row_works_706 : FiniteTemplate HasSnaky 16 required_706 envelope_706 := by + refine finite_compose HasSnaky 15 childrenC_706 childrenD_706 finite_children_work_706 (4, 4) + required_706 envelope_706 pivot_mem_706 child_required_sub_706 child_envelope_sub_706 ?_ + intro b hb + exact common_sub_706 (mem_commonEnvelope childrenD_706 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height16Part03.lean b/lean/snaky/FiniteCards/Height16Part03.lean new file mode 100644 index 0000000..ffc70e9 --- /dev/null +++ b/lean/snaky/FiniteCards/Height16Part03.lean @@ -0,0 +1,175 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part03 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part05 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part03 +import FiniteCards.Height08Part04 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part03 +import FiniteCards.Height10Part06 +import FiniteCards.Height12Part04 +import FiniteCards.Height12Part05 +import FiniteCards.Height13Part07 +import FiniteCards.Height15Part04 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_724_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_724_i0 j) (childrenD_724_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_57 0 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_111 2 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_390 5 (10, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_397 0 (4, 5)).mono (by decide +kernel) + +theorem finite_row_works_724_i0 : FiniteTemplate HasSnaky 10 required_724_i0 envelope_724_i0 := by + refine finite_compose HasSnaky 9 childrenC_724_i0 childrenD_724_i0 finite_children_work_724_i0 (4, 8) + required_724_i0 envelope_724_i0 pivot_mem_724_i0 child_required_sub_724_i0 child_envelope_sub_724_i0 ?_ + intro b hb + exact common_sub_724_i0 (mem_commonEnvelope childrenD_724_i0 b hb) + +theorem finite_children_work_724_i2 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_724_i2 j) (childrenD_724_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 5 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_19 7 (8, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_395 0 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_724_i2 : FiniteTemplate HasSnaky 9 required_724_i2 envelope_724_i2 := by + refine finite_compose HasSnaky 8 childrenC_724_i2 childrenD_724_i2 finite_children_work_724_i2 (4, 8) + required_724_i2 envelope_724_i2 pivot_mem_724_i2 child_required_sub_724_i2 child_envelope_sub_724_i2 ?_ + intro b hb + exact common_sub_724_i2 (mem_commonEnvelope childrenD_724_i2 b hb) + +theorem finite_children_work_724_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_724_i3 j) (childrenD_724_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_19 5 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_231 2 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_279 0 (4, 5)).mono (by decide +kernel) + +theorem finite_row_works_724_i3 : FiniteTemplate HasSnaky 6 required_724_i3 envelope_724_i3 := by + refine finite_compose HasSnaky 5 childrenC_724_i3 childrenD_724_i3 finite_children_work_724_i3 (4, 8) + required_724_i3 envelope_724_i3 pivot_mem_724_i3 child_required_sub_724_i3 child_envelope_sub_724_i3 ?_ + intro b hb + exact common_sub_724_i3 (mem_commonEnvelope childrenD_724_i3 b hb) + +theorem finite_children_work_724_i4 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_724_i4 j) (childrenD_724_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 6 (6, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_637 0 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_724_i4 : FiniteTemplate HasSnaky 8 required_724_i4 envelope_724_i4 := by + refine finite_compose HasSnaky 7 childrenC_724_i4 childrenD_724_i4 finite_children_work_724_i4 (6, 9) + required_724_i4 envelope_724_i4 pivot_mem_724_i4 child_required_sub_724_i4 child_envelope_sub_724_i4 ?_ + intro b hb + exact common_sub_724_i4 (mem_commonEnvelope childrenD_724_i4 b hb) + +theorem finite_children_work_724_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_724_i1 j) (childrenD_724_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_188 1 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_188 3 (3, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_258 0 (5, 5)).mono (by decide +kernel) + · exact finite_row_works_724_i2.mono (by decide +kernel) + · exact finite_row_works_724_i3.mono (by decide +kernel) + · exact finite_row_works_724_i4.mono (by decide +kernel) + +theorem finite_row_works_724_i1 : FiniteTemplate HasSnaky 10 required_724_i1 envelope_724_i1 := by + refine finite_compose HasSnaky 9 childrenC_724_i1 childrenD_724_i1 finite_children_work_724_i1 (7, 8) + required_724_i1 envelope_724_i1 pivot_mem_724_i1 child_required_sub_724_i1 child_envelope_sub_724_i1 ?_ + intro b hb + exact common_sub_724_i1 (mem_commonEnvelope childrenD_724_i1 b hb) + +theorem finite_children_work_724_i5 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_724_i5 j) (childrenD_724_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_53 7 (8, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_53 1 (2, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_720 7 (10, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_720 1 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_724_i5 : FiniteTemplate HasSnaky 14 required_724_i5 envelope_724_i5 := by + refine finite_compose HasSnaky 13 childrenC_724_i5 childrenD_724_i5 finite_children_work_724_i5 (4, 7) + required_724_i5 envelope_724_i5 pivot_mem_724_i5 child_required_sub_724_i5 child_envelope_sub_724_i5 ?_ + intro b hb + exact common_sub_724_i5 (mem_commonEnvelope childrenD_724_i5 b hb) + +theorem finite_children_work_724_i6 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_724_i6 j) (childrenD_724_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_512 0 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_600 3 (2, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_621 6 (9, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_702 1 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_714 2 (8, 3)).mono (by decide +kernel) + +theorem finite_row_works_724_i6 : FiniteTemplate HasSnaky 11 required_724_i6 envelope_724_i6 := by + refine finite_compose HasSnaky 10 childrenC_724_i6 childrenD_724_i6 finite_children_work_724_i6 (6, 7) + required_724_i6 envelope_724_i6 pivot_mem_724_i6 child_required_sub_724_i6 child_envelope_sub_724_i6 ?_ + intro b hb + exact common_sub_724_i6 (mem_commonEnvelope childrenD_724_i6 b hb) + +theorem finite_children_work_724_i8 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_724_i8 j) (childrenD_724_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 3 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 1 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_604 0 (4, 5)).mono (by decide +kernel) + +theorem finite_row_works_724_i8 : FiniteTemplate HasSnaky 9 required_724_i8 envelope_724_i8 := by + refine finite_compose HasSnaky 8 childrenC_724_i8 childrenD_724_i8 finite_children_work_724_i8 (7, 8) + required_724_i8 envelope_724_i8 pivot_mem_724_i8 child_required_sub_724_i8 child_envelope_sub_724_i8 ?_ + intro b hb + exact common_sub_724_i8 (mem_commonEnvelope childrenD_724_i8 b hb) + +theorem finite_children_work_724_i7 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_724_i7 j) (childrenD_724_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_88 0 (3, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_231 2 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_267 5 (8, 6)).mono (by decide +kernel) + · exact finite_row_works_724_i8.mono (by decide +kernel) + +theorem finite_row_works_724_i7 : FiniteTemplate HasSnaky 10 required_724_i7 envelope_724_i7 := by + refine finite_compose HasSnaky 9 childrenC_724_i7 childrenD_724_i7 finite_children_work_724_i7 (4, 8) + required_724_i7 envelope_724_i7 pivot_mem_724_i7 child_required_sub_724_i7 child_envelope_sub_724_i7 ?_ + intro b hb + exact common_sub_724_i7 (mem_commonEnvelope childrenD_724_i7 b hb) + +theorem finite_children_work_724 : ∀ j, FiniteTemplate HasSnaky 15 (childrenC_724 j) (childrenD_724 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_523 5 (9, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_524 5 (9, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_677 1 (1, 5)).mono (by decide +kernel) + · exact finite_row_works_724_i0.mono (by decide +kernel) + · exact finite_row_works_724_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_719 7 (10, 10)).mono (by decide +kernel) + · exact finite_row_works_724_i5.mono (by decide +kernel) + · exact finite_row_works_724_i6.mono (by decide +kernel) + · exact finite_row_works_724_i7.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_723 6 (8, 13)).mono (by decide +kernel) + +theorem finite_row_works_724 : FiniteTemplate HasSnaky 16 required_724 envelope_724 := by + refine finite_compose HasSnaky 15 childrenC_724 childrenD_724 finite_children_work_724 (6, 8) + required_724 envelope_724 pivot_mem_724 child_required_sub_724 child_envelope_sub_724 ?_ + intro b hb + exact common_sub_724 (mem_commonEnvelope childrenD_724 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height17Part01.lean b/lean/snaky/FiniteCards/Height17Part01.lean new file mode 100644 index 0000000..5f21e3e --- /dev/null +++ b/lean/snaky/FiniteCards/Height17Part01.lean @@ -0,0 +1,266 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height17Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height05Part03 +import FiniteCards.Height05Part04 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part05 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part03 +import FiniteCards.Height07Part05 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part04 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part02 +import FiniteCards.Height09Part07 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part05 +import FiniteCards.Height11Part01 +import FiniteCards.Height12Part03 +import FiniteCards.Height13Part03 +import FiniteCards.Height16Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_623_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_623_i0 j) (childrenD_623_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_188 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_444 0 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_606 4 (4, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_610 4 (4, 9)).mono (by decide +kernel) + +theorem finite_row_works_623_i0 : FiniteTemplate HasSnaky 11 required_623_i0 envelope_623_i0 := by + refine finite_compose HasSnaky 10 childrenC_623_i0 childrenD_623_i0 finite_children_work_623_i0 (5, 5) + required_623_i0 envelope_623_i0 pivot_mem_623_i0 child_required_sub_623_i0 child_envelope_sub_623_i0 ?_ + intro b hb + exact common_sub_623_i0 (mem_commonEnvelope childrenD_623_i0 b hb) + +theorem finite_children_work_623_i1 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_623_i1 j) (childrenD_623_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_137 7 (7, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 7 (7, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_363 6 (8, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_474 7 (7, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_606 4 (4, 9)).mono (by decide +kernel) + +theorem finite_row_works_623_i1 : FiniteTemplate HasSnaky 10 required_623_i1 envelope_623_i1 := by + refine finite_compose HasSnaky 9 childrenC_623_i1 childrenD_623_i1 finite_children_work_623_i1 (5, 5) + required_623_i1 envelope_623_i1 pivot_mem_623_i1 child_required_sub_623_i1 child_envelope_sub_623_i1 ?_ + intro b hb + exact common_sub_623_i1 (mem_commonEnvelope childrenD_623_i1 b hb) + +theorem finite_children_work_623_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_623_i4 j) (childrenD_623_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_27 2 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_35 3 (4, 9)).mono (by decide +kernel) + +theorem finite_row_works_623_i4 : FiniteTemplate HasSnaky 5 required_623_i4 envelope_623_i4 := by + refine finite_compose HasSnaky 4 childrenC_623_i4 childrenD_623_i4 finite_children_work_623_i4 (4, 7) + required_623_i4 envelope_623_i4 pivot_mem_623_i4 child_required_sub_623_i4 child_envelope_sub_623_i4 ?_ + intro b hb + exact common_sub_623_i4 (mem_commonEnvelope childrenD_623_i4 b hb) + +theorem finite_children_work_623_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_623_i3 j) (childrenD_623_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 4 (4, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_151 2 (8, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_186 2 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_187 2 (5, 4)).mono (by decide +kernel) + · exact finite_row_works_623_i4.mono (by decide +kernel) + +theorem finite_row_works_623_i3 : FiniteTemplate HasSnaky 6 required_623_i3 envelope_623_i3 := by + refine finite_compose HasSnaky 5 childrenC_623_i3 childrenD_623_i3 finite_children_work_623_i3 (5, 9) + required_623_i3 envelope_623_i3 pivot_mem_623_i3 child_required_sub_623_i3 child_envelope_sub_623_i3 ?_ + intro b hb + exact common_sub_623_i3 (mem_commonEnvelope childrenD_623_i3 b hb) + +theorem finite_children_work_623_i5 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_623_i5 j) (childrenD_623_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_179 3 (3, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_371 3 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_443 4 (4, 9)).mono (by decide +kernel) + +theorem finite_row_works_623_i5 : FiniteTemplate HasSnaky 10 required_623_i5 envelope_623_i5 := by + refine finite_compose HasSnaky 9 childrenC_623_i5 childrenD_623_i5 finite_children_work_623_i5 (5, 5) + required_623_i5 envelope_623_i5 pivot_mem_623_i5 child_required_sub_623_i5 child_envelope_sub_623_i5 ?_ + intro b hb + exact common_sub_623_i5 (mem_commonEnvelope childrenD_623_i5 b hb) + +theorem finite_children_work_623_i2 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_623_i2 j) (childrenD_623_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 2 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_188 2 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_211 2 (8, 4)).mono (by decide +kernel) + · exact finite_row_works_623_i3.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_619 1 (2, 5)).mono (by decide +kernel) + · exact finite_row_works_623_i5.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_620 2 (8, 2)).mono (by decide +kernel) + +theorem finite_row_works_623_i2 : FiniteTemplate HasSnaky 11 required_623_i2 envelope_623_i2 := by + refine finite_compose HasSnaky 10 childrenC_623_i2 childrenD_623_i2 finite_children_work_623_i2 (5, 8) + required_623_i2 envelope_623_i2 pivot_mem_623_i2 child_required_sub_623_i2 child_envelope_sub_623_i2 ?_ + intro b hb + exact common_sub_623_i2 (mem_commonEnvelope childrenD_623_i2 b hb) + +theorem finite_children_work_623_i7 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_623_i7 j) (childrenD_623_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_179 3 (3, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_197 3 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_465 0 (4, 4)).mono (by decide +kernel) + +theorem finite_row_works_623_i7 : FiniteTemplate HasSnaky 7 required_623_i7 envelope_623_i7 := by + refine finite_compose HasSnaky 6 childrenC_623_i7 childrenD_623_i7 finite_children_work_623_i7 (5, 5) + required_623_i7 envelope_623_i7 pivot_mem_623_i7 child_required_sub_623_i7 child_envelope_sub_623_i7 ?_ + intro b hb + exact common_sub_623_i7 (mem_commonEnvelope childrenD_623_i7 b hb) + +theorem finite_children_work_623_i6 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_623_i6 j) (childrenD_623_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 0 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_322 1 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_369 4 (4, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 1 (2, 5)).mono (by decide +kernel) + · exact finite_row_works_623_i7.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_622 6 (8, 11)).mono (by decide +kernel) + +theorem finite_row_works_623_i6 : FiniteTemplate HasSnaky 10 required_623_i6 envelope_623_i6 := by + refine finite_compose HasSnaky 9 childrenC_623_i6 childrenD_623_i6 finite_children_work_623_i6 (5, 8) + required_623_i6 envelope_623_i6 pivot_mem_623_i6 child_required_sub_623_i6 child_envelope_sub_623_i6 ?_ + intro b hb + exact common_sub_623_i6 (mem_commonEnvelope childrenD_623_i6 b hb) + +theorem finite_children_work_623 : ∀ j, FiniteTemplate HasSnaky 16 (childrenC_623 j) (childrenD_623 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_467 6 (9, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_602 1 (0, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_603 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_605 5 (8, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_607 6 (9, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_608 6 (9, 11)).mono (by decide +kernel) + · exact finite_row_works_623_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_618 6 (10, 10)).mono (by decide +kernel) + · exact finite_row_works_623_i1.mono (by decide +kernel) + · exact finite_row_works_623_i2.mono (by decide +kernel) + · exact finite_row_works_623_i6.mono (by decide +kernel) + +theorem finite_row_works_623 : FiniteTemplate HasSnaky 17 required_623 envelope_623 := by + refine finite_compose HasSnaky 16 childrenC_623 childrenD_623 finite_children_work_623 (5, 6) + required_623 envelope_623 pivot_mem_623 child_required_sub_623 child_envelope_sub_623 ?_ + intro b hb + exact common_sub_623 (mem_commonEnvelope childrenD_623 b hb) + +theorem finite_children_work_630_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_630_i0 j) (childrenD_630_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 0 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_13 6 (5, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_355 6 (7, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_356 6 (7, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_434 2 (8, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_441 4 (3, 10)).mono (by decide +kernel) + +theorem finite_row_works_630_i0 : FiniteTemplate HasSnaky 10 required_630_i0 envelope_630_i0 := by + refine finite_compose HasSnaky 9 childrenC_630_i0 childrenD_630_i0 finite_children_work_630_i0 (4, 8) + required_630_i0 envelope_630_i0 pivot_mem_630_i0 child_required_sub_630_i0 child_envelope_sub_630_i0 ?_ + intro b hb + exact common_sub_630_i0 (mem_commonEnvelope childrenD_630_i0 b hb) + +theorem finite_children_work_630_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_630_i1 j) (childrenD_630_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_112 0 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_363 6 (7, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_364 6 (7, 9)).mono (by decide +kernel) + +theorem finite_row_works_630_i1 : FiniteTemplate HasSnaky 7 required_630_i1 envelope_630_i1 := by + refine finite_compose HasSnaky 6 childrenC_630_i1 childrenD_630_i1 finite_children_work_630_i1 (4, 5) + required_630_i1 envelope_630_i1 pivot_mem_630_i1 child_required_sub_630_i1 child_envelope_sub_630_i1 ?_ + intro b hb + exact common_sub_630_i1 (mem_commonEnvelope childrenD_630_i1 b hb) + +theorem finite_children_work_630_i2 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_630_i2 j) (childrenD_630_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_112 0 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 5 (6, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 3 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_295 6 (8, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_466 0 (3, 4)).mono (by decide +kernel) + +theorem finite_row_works_630_i2 : FiniteTemplate HasSnaky 8 required_630_i2 envelope_630_i2 := by + refine finite_compose HasSnaky 7 childrenC_630_i2 childrenD_630_i2 finite_children_work_630_i2 (4, 5) + required_630_i2 envelope_630_i2 pivot_mem_630_i2 child_required_sub_630_i2 child_envelope_sub_630_i2 ?_ + intro b hb + exact common_sub_630_i2 (mem_commonEnvelope childrenD_630_i2 b hb) + +theorem finite_children_work_630_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_630_i4 j) (childrenD_630_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 6 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_34 3 (3, 7)).mono (by decide +kernel) + +theorem finite_row_works_630_i4 : FiniteTemplate HasSnaky 5 required_630_i4 envelope_630_i4 := by + refine finite_compose HasSnaky 4 childrenC_630_i4 childrenD_630_i4 finite_children_work_630_i4 (5, 7) + required_630_i4 envelope_630_i4 pivot_mem_630_i4 child_required_sub_630_i4 child_envelope_sub_630_i4 ?_ + intro b hb + exact common_sub_630_i4 (mem_commonEnvelope childrenD_630_i4 b hb) + +theorem finite_children_work_630_i3 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_630_i3 j) (childrenD_630_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_112 0 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_257 3 (1, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_398 7 (7, 7)).mono (by decide +kernel) + · exact finite_row_works_630_i4.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_628 0 (3, 3)).mono (by decide +kernel) + +theorem finite_row_works_630_i3 : FiniteTemplate HasSnaky 10 required_630_i3 envelope_630_i3 := by + refine finite_compose HasSnaky 9 childrenC_630_i3 childrenD_630_i3 finite_children_work_630_i3 (4, 5) + required_630_i3 envelope_630_i3 pivot_mem_630_i3 child_required_sub_630_i3 child_envelope_sub_630_i3 ?_ + intro b hb + exact common_sub_630_i3 (mem_commonEnvelope childrenD_630_i3 b hb) + +theorem finite_children_work_630 : ∀ j, FiniteTemplate HasSnaky 16 (childrenC_630 j) (childrenD_630 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_368 2 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_368 6 (8, 10)).mono (by decide +kernel) + · exact finite_row_works_630_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_467 6 (8, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_627 0 (1, 3)).mono (by decide +kernel) + · exact finite_row_works_630_i1.mono (by decide +kernel) + · exact finite_row_works_630_i2.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_629 4 (1, 10)).mono (by decide +kernel) + · exact finite_row_works_630_i3.mono (by decide +kernel) + +theorem finite_row_works_630 : FiniteTemplate HasSnaky 17 required_630 envelope_630 := by + refine finite_compose HasSnaky 16 childrenC_630 childrenD_630 finite_children_work_630 (4, 6) + required_630 envelope_630 pivot_mem_630 child_required_sub_630 child_envelope_sub_630 ?_ + intro b hb + exact common_sub_630 (mem_commonEnvelope childrenD_630 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height17Part02.lean b/lean/snaky/FiniteCards/Height17Part02.lean new file mode 100644 index 0000000..fd3aefb --- /dev/null +++ b/lean/snaky/FiniteCards/Height17Part02.lean @@ -0,0 +1,187 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height17Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height08Part03 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part03 +import FiniteCards.Height09Part07 +import FiniteCards.Height10Part01 +import FiniteCards.Height10Part02 +import FiniteCards.Height10Part06 +import FiniteCards.Height11Part04 +import FiniteCards.Height11Part05 +import FiniteCards.Height11Part06 +import FiniteCards.Height12Part01 +import FiniteCards.Height14Part04 +import FiniteCards.Height16Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_707_i0 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_707_i0 j) (childrenD_707_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_116 3 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_134 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_180 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_337 0 (4, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (8, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_558 5 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_662 1 (0, 3)).mono (by decide +kernel) + +theorem finite_row_works_707_i0 : FiniteTemplate HasSnaky 10 required_707_i0 envelope_707_i0 := by + refine finite_compose HasSnaky 9 childrenC_707_i0 childrenD_707_i0 finite_children_work_707_i0 (5, 7) + required_707_i0 envelope_707_i0 pivot_mem_707_i0 child_required_sub_707_i0 child_envelope_sub_707_i0 ?_ + intro b hb + exact common_sub_707_i0 (mem_commonEnvelope childrenD_707_i0 b hb) + +theorem finite_children_work_707_i2 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_707_i2 j) (childrenD_707_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_380 5 (6, 4)).mono (by decide +kernel) + +theorem finite_row_works_707_i2 : FiniteTemplate HasSnaky 10 required_707_i2 envelope_707_i2 := by + refine finite_compose HasSnaky 9 childrenC_707_i2 childrenD_707_i2 finite_children_work_707_i2 (5, 7) + required_707_i2 envelope_707_i2 pivot_mem_707_i2 child_required_sub_707_i2 child_envelope_sub_707_i2 ?_ + intro b hb + exact common_sub_707_i2 (mem_commonEnvelope childrenD_707_i2 b hb) + +theorem finite_children_work_707_i1 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_707_i1 j) (childrenD_707_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_14 6 (6, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_33 4 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_322 3 (1, 7)).mono (by decide +kernel) + · exact finite_row_works_707_i2.mono (by decide +kernel) + +theorem finite_row_works_707_i1 : FiniteTemplate HasSnaky 11 required_707_i1 envelope_707_i1 := by + refine finite_compose HasSnaky 10 childrenC_707_i1 childrenD_707_i1 finite_children_work_707_i1 (5, 4) + required_707_i1 envelope_707_i1 pivot_mem_707_i1 child_required_sub_707_i1 child_envelope_sub_707_i1 ?_ + intro b hb + exact common_sub_707_i1 (mem_commonEnvelope childrenD_707_i1 b hb) + +theorem finite_children_work_707_i4 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_707_i4 j) (childrenD_707_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 0 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_485 4 (4, 9)).mono (by decide +kernel) + +theorem finite_row_works_707_i4 : FiniteTemplate HasSnaky 13 required_707_i4 envelope_707_i4 := by + refine finite_compose HasSnaky 12 childrenC_707_i4 childrenD_707_i4 finite_children_work_707_i4 (5, 7) + required_707_i4 envelope_707_i4 pivot_mem_707_i4 child_required_sub_707_i4 child_envelope_sub_707_i4 ?_ + intro b hb + exact common_sub_707_i4 (mem_commonEnvelope childrenD_707_i4 b hb) + +theorem finite_children_work_707_i3 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_707_i3 j) (childrenD_707_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_136 4 (3, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_267 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_322 3 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_322 5 (9, 3)).mono (by decide +kernel) + · exact finite_row_works_707_i4.mono (by decide +kernel) + +theorem finite_row_works_707_i3 : FiniteTemplate HasSnaky 14 required_707_i3 envelope_707_i3 := by + refine finite_compose HasSnaky 13 childrenC_707_i3 childrenD_707_i3 finite_children_work_707_i3 (5, 4) + required_707_i3 envelope_707_i3 pivot_mem_707_i3 child_required_sub_707_i3 child_envelope_sub_707_i3 ?_ + intro b hb + exact common_sub_707_i3 (mem_commonEnvelope childrenD_707_i3 b hb) + +theorem finite_children_work_707_i6 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_707_i6 j) (childrenD_707_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_9 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_115 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_302 5 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_303 5 (8, 3)).mono (by decide +kernel) + +theorem finite_row_works_707_i6 : FiniteTemplate HasSnaky 7 required_707_i6 envelope_707_i6 := by + refine finite_compose HasSnaky 6 childrenC_707_i6 childrenD_707_i6 finite_children_work_707_i6 (5, 7) + required_707_i6 envelope_707_i6 pivot_mem_707_i6 child_required_sub_707_i6 child_envelope_sub_707_i6 ?_ + intro b hb + exact common_sub_707_i6 (mem_commonEnvelope childrenD_707_i6 b hb) + +theorem finite_children_work_707_i5 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_707_i5 j) (childrenD_707_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_13 4 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_14 6 (6, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_332 7 (8, 7)).mono (by decide +kernel) + · exact finite_row_works_707_i6.mono (by decide +kernel) + +theorem finite_row_works_707_i5 : FiniteTemplate HasSnaky 8 required_707_i5 envelope_707_i5 := by + refine finite_compose HasSnaky 7 childrenC_707_i5 childrenD_707_i5 finite_children_work_707_i5 (5, 4) + required_707_i5 envelope_707_i5 pivot_mem_707_i5 child_required_sub_707_i5 child_envelope_sub_707_i5 ?_ + intro b hb + exact common_sub_707_i5 (mem_commonEnvelope childrenD_707_i5 b hb) + +theorem finite_children_work_707_i7 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_707_i7 j) (childrenD_707_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_13 2 (6, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_118 5 (8, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_369 6 (6, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (8, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_528 0 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_689 1 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_707_i7 : FiniteTemplate HasSnaky 12 required_707_i7 envelope_707_i7 := by + refine finite_compose HasSnaky 11 childrenC_707_i7 childrenD_707_i7 finite_children_work_707_i7 (5, 7) + required_707_i7 envelope_707_i7 pivot_mem_707_i7 child_required_sub_707_i7 child_envelope_sub_707_i7 ?_ + intro b hb + exact common_sub_707_i7 (mem_commonEnvelope childrenD_707_i7 b hb) + +theorem finite_children_work_707_i8 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_707_i8 j) (childrenD_707_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_537 5 (8, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_537 4 (3, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_702 5 (7, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_702 4 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_704 1 (0, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_704 0 (3, 1)).mono (by decide +kernel) + +theorem finite_row_works_707_i8 : FiniteTemplate HasSnaky 11 required_707_i8 envelope_707_i8 := by + refine finite_compose HasSnaky 10 childrenC_707_i8 childrenD_707_i8 finite_children_work_707_i8 (4, 6) + required_707_i8 envelope_707_i8 pivot_mem_707_i8 child_required_sub_707_i8 child_envelope_sub_707_i8 ?_ + intro b hb + exact common_sub_707_i8 (mem_commonEnvelope childrenD_707_i8 b hb) + +theorem finite_children_work_707 : ∀ j, FiniteTemplate HasSnaky 16 (childrenC_707 j) (childrenD_707 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_459 0 (4, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_535 4 (3, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_617 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_660 1 (0, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_663 1 (0, 3)).mono (by decide +kernel) + · exact finite_row_works_707_i0.mono (by decide +kernel) + · exact finite_row_works_707_i1.mono (by decide +kernel) + · exact finite_row_works_707_i3.mono (by decide +kernel) + · exact finite_row_works_707_i5.mono (by decide +kernel) + · exact finite_row_works_707_i7.mono (by decide +kernel) + · exact finite_row_works_707_i8.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_705 4 (2, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_706 4 (0, 10)).mono (by decide +kernel) + +theorem finite_row_works_707 : FiniteTemplate HasSnaky 17 required_707 envelope_707 := by + refine finite_compose HasSnaky 16 childrenC_707 childrenD_707 finite_children_work_707 (5, 6) + required_707 envelope_707 pivot_mem_707 child_required_sub_707 child_envelope_sub_707 ?_ + intro b hb + exact common_sub_707 (mem_commonEnvelope childrenD_707 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height18Part01.lean b/lean/snaky/FiniteCards/Height18Part01.lean new file mode 100644 index 0000000..2a5698a --- /dev/null +++ b/lean/snaky/FiniteCards/Height18Part01.lean @@ -0,0 +1,323 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height18Part01 +import FiniteCards.Height01Part01 +import FiniteCards.Height02Part01 +import FiniteCards.Height02Part02 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part04 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part03 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part03 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part02 +import FiniteCards.Height08Part04 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part02 +import FiniteCards.Height10Part01 +import FiniteCards.Height11Part01 +import FiniteCards.Height11Part04 +import FiniteCards.Height11Part05 +import FiniteCards.Height12Part01 +import FiniteCards.Height12Part02 +import FiniteCards.Height12Part04 +import FiniteCards.Height13Part01 +import FiniteCards.Height13Part03 +import FiniteCards.Height13Part04 +import FiniteCards.Height13Part05 +import FiniteCards.Height14Part02 +import FiniteCards.Height14Part03 +import FiniteCards.Height15Part01 +import FiniteCards.Height15Part02 +import FiniteCards.Height16Part02 +import FiniteCards.Height17Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_684_i1 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_684_i1 j) (childrenD_684_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 4 (6, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_115 4 (6, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_469 1 (5, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_470 4 (5, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_485 3 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_489 4 (4, 12)).mono (by decide +kernel) + +theorem finite_row_works_684_i1 : FiniteTemplate HasSnaky 13 required_684_i1 envelope_684_i1 := by + refine finite_compose HasSnaky 12 childrenC_684_i1 childrenD_684_i1 finite_children_work_684_i1 (9, 7) + required_684_i1 envelope_684_i1 pivot_mem_684_i1 child_required_sub_684_i1 child_envelope_sub_684_i1 ?_ + intro b hb + exact common_sub_684_i1 (mem_commonEnvelope childrenD_684_i1 b hb) + +theorem finite_children_work_684_i0 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_684_i0 j) (childrenD_684_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_118 4 (5, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_355 3 (5, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_434 3 (5, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_468 1 (3, 6)).mono (by decide +kernel) + · exact finite_row_works_684_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_491 7 (9, 11)).mono (by decide +kernel) + +theorem finite_row_works_684_i0 : FiniteTemplate HasSnaky 14 required_684_i0 envelope_684_i0 := by + refine finite_compose HasSnaky 13 childrenC_684_i0 childrenD_684_i0 finite_children_work_684_i0 (8, 7) + required_684_i0 envelope_684_i0 pivot_mem_684_i0 child_required_sub_684_i0 child_envelope_sub_684_i0 ?_ + intro b hb + exact common_sub_684_i0 (mem_commonEnvelope childrenD_684_i0 b hb) + +theorem finite_children_work_684_i2 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_684_i2 j) (childrenD_684_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_50 0 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_97 0 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_98 2 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_454 6 (8, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_455 5 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_624 1 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_684_i2 : FiniteTemplate HasSnaky 12 required_684_i2 envelope_684_i2 := by + refine finite_compose HasSnaky 11 childrenC_684_i2 childrenD_684_i2 finite_children_work_684_i2 (7, 9) + required_684_i2 envelope_684_i2 pivot_mem_684_i2 child_required_sub_684_i2 child_envelope_sub_684_i2 ?_ + intro b hb + exact common_sub_684_i2 (mem_commonEnvelope childrenD_684_i2 b hb) + +theorem finite_children_work_684_i3 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_684_i3 j) (childrenD_684_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_174 4 (4, 14)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_475 0 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_475 2 (9, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_483 0 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_508 1 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_508 5 (10, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_566 4 (4, 14)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 0 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 2 (9, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_635 4 (5, 15)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_644 4 (3, 15)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_645 4 (3, 15)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_647 4 (3, 15)).mono (by decide +kernel) + +theorem finite_row_works_684_i3 : FiniteTemplate HasSnaky 15 required_684_i3 envelope_684_i3 := by + refine finite_compose HasSnaky 14 childrenC_684_i3 childrenD_684_i3 finite_children_work_684_i3 (7, 11) + required_684_i3 envelope_684_i3 pivot_mem_684_i3 child_required_sub_684_i3 child_envelope_sub_684_i3 ?_ + intro b hb + exact common_sub_684_i3 (mem_commonEnvelope childrenD_684_i3 b hb) + +theorem finite_children_work_684_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_684_i5 j) (childrenD_684_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 0 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_313 2 (9, 6)).mono (by decide +kernel) + +theorem finite_row_works_684_i5 : FiniteTemplate HasSnaky 7 required_684_i5 envelope_684_i5 := by + refine finite_compose HasSnaky 6 childrenC_684_i5 childrenD_684_i5 finite_children_work_684_i5 (9, 7) + required_684_i5 envelope_684_i5 pivot_mem_684_i5 child_required_sub_684_i5 child_envelope_sub_684_i5 ?_ + intro b hb + exact common_sub_684_i5 (mem_commonEnvelope childrenD_684_i5 b hb) + +theorem finite_children_work_684_i4 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_684_i4 j) (childrenD_684_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_257 0 (5, 4)).mono (by decide +kernel) + · exact finite_row_works_684_i5.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_434 3 (5, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_468 5 (11, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_491 7 (9, 11)).mono (by decide +kernel) + +theorem finite_row_works_684_i4 : FiniteTemplate HasSnaky 12 required_684_i4 envelope_684_i4 := by + refine finite_compose HasSnaky 11 childrenC_684_i4 childrenD_684_i4 finite_children_work_684_i4 (8, 7) + required_684_i4 envelope_684_i4 pivot_mem_684_i4 child_required_sub_684_i4 child_envelope_sub_684_i4 ?_ + intro b hb + exact common_sub_684_i4 (mem_commonEnvelope childrenD_684_i4 b hb) + +theorem finite_children_work_684 : ∀ j, FiniteTemplate HasSnaky 17 (childrenC_684 j) (childrenD_684 j) := by + intro j + fin_cases j + · exact finite_row_works_684_i0.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_623 3 (0, 15)).mono (by decide +kernel) + · exact finite_row_works_684_i2.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_625 5 (9, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_630 3 (0, 14)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_632 5 (10, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_636 5 (11, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_639 1 (3, 6)).mono (by decide +kernel) + · exact finite_row_works_684_i3.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_656 1 (1, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_657 1 (4, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_670 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_675 5 (12, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_683 1 (2, 6)).mono (by decide +kernel) + · exact finite_row_works_684_i4.mono (by decide +kernel) + +theorem finite_row_works_684 : FiniteTemplate HasSnaky 18 required_684 envelope_684 := by + refine finite_compose HasSnaky 17 childrenC_684 childrenD_684 finite_children_work_684 (7, 10) + required_684 envelope_684 pivot_mem_684 child_required_sub_684 child_envelope_sub_684 ?_ + intro b hb + exact common_sub_684 (mem_commonEnvelope childrenD_684 b hb) + +theorem finite_children_work_691_i0 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_691_i0 j) (childrenD_691_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_27 4 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_277 3 (1, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_278 1 (1, 3)).mono (by decide +kernel) + +theorem finite_row_works_691_i0 : FiniteTemplate HasSnaky 6 required_691_i0 envelope_691_i0 := by + refine finite_compose HasSnaky 5 childrenC_691_i0 childrenD_691_i0 finite_children_work_691_i0 (4, 5) + required_691_i0 envelope_691_i0 pivot_mem_691_i0 child_required_sub_691_i0 child_envelope_sub_691_i0 ?_ + intro b hb + exact common_sub_691_i0 (mem_commonEnvelope childrenD_691_i0 b hb) + +theorem finite_children_work_691_i5 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_691_i5 j) (childrenD_691_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 6 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_317 0 (3, 2)).mono (by decide +kernel) + +theorem finite_row_works_691_i5 : FiniteTemplate HasSnaky 8 required_691_i5 envelope_691_i5 := by + refine finite_compose HasSnaky 7 childrenC_691_i5 childrenD_691_i5 finite_children_work_691_i5 (5, 6) + required_691_i5 envelope_691_i5 pivot_mem_691_i5 child_required_sub_691_i5 child_envelope_sub_691_i5 ?_ + intro b hb + exact common_sub_691_i5 (mem_commonEnvelope childrenD_691_i5 b hb) + +theorem finite_children_work_691_i4 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_691_i4 j) (childrenD_691_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_30 3 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_59 4 (3, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_462 0 (5, 2)).mono (by decide +kernel) + · exact finite_row_works_691_i5.mono (by decide +kernel) + +theorem finite_row_works_691_i4 : FiniteTemplate HasSnaky 14 required_691_i4 envelope_691_i4 := by + refine finite_compose HasSnaky 13 childrenC_691_i4 childrenD_691_i4 finite_children_work_691_i4 (6, 6) + required_691_i4 envelope_691_i4 pivot_mem_691_i4 child_required_sub_691_i4 child_envelope_sub_691_i4 ?_ + intro b hb + exact common_sub_691_i4 (mem_commonEnvelope childrenD_691_i4 b hb) + +theorem finite_children_work_691_i3 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_691_i3 j) (childrenD_691_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_102 3 (2, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_400 0 (2, 3)).mono (by decide +kernel) + · exact finite_row_works_691_i4.mono (by decide +kernel) + +theorem finite_row_works_691_i3 : FiniteTemplate HasSnaky 15 required_691_i3 envelope_691_i3 := by + refine finite_compose HasSnaky 14 childrenC_691_i3 childrenD_691_i3 finite_children_work_691_i3 (6, 5) + required_691_i3 envelope_691_i3 pivot_mem_691_i3 child_required_sub_691_i3 child_envelope_sub_691_i3 ?_ + intro b hb + exact common_sub_691_i3 (mem_commonEnvelope childrenD_691_i3 b hb) + +theorem finite_children_work_691_i2 : ∀ j, FiniteTemplate HasSnaky 15 (childrenC_691_i2 j) (childrenD_691_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_0 1 (3, 2)).mono (by decide +kernel) + · exact finite_row_works_691_i3.mono (by decide +kernel) + +theorem finite_row_works_691_i2 : FiniteTemplate HasSnaky 16 required_691_i2 envelope_691_i2 := by + refine finite_compose HasSnaky 15 childrenC_691_i2 childrenD_691_i2 finite_children_work_691_i2 (4, 5) + required_691_i2 envelope_691_i2 pivot_mem_691_i2 child_required_sub_691_i2 child_envelope_sub_691_i2 ?_ + intro b hb + exact common_sub_691_i2 (mem_commonEnvelope childrenD_691_i2 b hb) + +theorem finite_children_work_691_i1 : ∀ j, FiniteTemplate HasSnaky 16 (childrenC_691_i1 j) (childrenD_691_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 1 (3, 3)).mono (by decide +kernel) + · exact finite_row_works_691_i2.mono (by decide +kernel) + +theorem finite_row_works_691_i1 : FiniteTemplate HasSnaky 17 required_691_i1 envelope_691_i1 := by + refine finite_compose HasSnaky 16 childrenC_691_i1 childrenD_691_i1 finite_children_work_691_i1 (4, 6) + required_691_i1 envelope_691_i1 pivot_mem_691_i1 child_required_sub_691_i1 child_envelope_sub_691_i1 ?_ + intro b hb + exact common_sub_691_i1 (mem_commonEnvelope childrenD_691_i1 b hb) + +theorem finite_children_work_691_i10 : ∀ j, FiniteTemplate HasSnaky 2 (childrenC_691_i10 j) (childrenD_691_i10 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 5 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_35 1 (2, 4)).mono (by decide +kernel) + +theorem finite_row_works_691_i10 : FiniteTemplate HasSnaky 3 required_691_i10 envelope_691_i10 := by + refine finite_compose HasSnaky 2 childrenC_691_i10 childrenD_691_i10 finite_children_work_691_i10 (2, 6) + required_691_i10 envelope_691_i10 pivot_mem_691_i10 child_required_sub_691_i10 child_envelope_sub_691_i10 ?_ + intro b hb + exact common_sub_691_i10 (mem_commonEnvelope childrenD_691_i10 b hb) + +theorem finite_children_work_691_i9 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_691_i9 j) (childrenD_691_i9 j) := by + intro j + fin_cases j + · exact finite_row_works_691_i10.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_460 4 (5, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_488 0 (2, 2)).mono (by decide +kernel) + +theorem finite_row_works_691_i9 : FiniteTemplate HasSnaky 11 required_691_i9 envelope_691_i9 := by + refine finite_compose HasSnaky 10 childrenC_691_i9 childrenD_691_i9 finite_children_work_691_i9 (6, 7) + required_691_i9 envelope_691_i9 pivot_mem_691_i9 child_required_sub_691_i9 child_envelope_sub_691_i9 ?_ + intro b hb + exact common_sub_691_i9 (mem_commonEnvelope childrenD_691_i9 b hb) + +theorem finite_children_work_691_i8 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_691_i8 j) (childrenD_691_i8 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_39 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_80 1 (2, 4)).mono (by decide +kernel) + · exact finite_row_works_691_i9.mono (by decide +kernel) + +theorem finite_row_works_691_i8 : FiniteTemplate HasSnaky 12 required_691_i8 envelope_691_i8 := by + refine finite_compose HasSnaky 11 childrenC_691_i8 childrenD_691_i8 finite_children_work_691_i8 (6, 5) + required_691_i8 envelope_691_i8 pivot_mem_691_i8 child_required_sub_691_i8 child_envelope_sub_691_i8 ?_ + intro b hb + exact common_sub_691_i8 (mem_commonEnvelope childrenD_691_i8 b hb) + +theorem finite_children_work_691_i7 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_691_i7 j) (childrenD_691_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_21 0 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_56 7 (6, 7)).mono (by decide +kernel) + · exact finite_row_works_691_i8.mono (by decide +kernel) + +theorem finite_row_works_691_i7 : FiniteTemplate HasSnaky 13 required_691_i7 envelope_691_i7 := by + refine finite_compose HasSnaky 12 childrenC_691_i7 childrenD_691_i7 finite_children_work_691_i7 (4, 5) + required_691_i7 envelope_691_i7 pivot_mem_691_i7 child_required_sub_691_i7 child_envelope_sub_691_i7 ?_ + intro b hb + exact common_sub_691_i7 (mem_commonEnvelope childrenD_691_i7 b hb) + +theorem finite_children_work_691_i6 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_691_i6 j) (childrenD_691_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_6 2 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_8 1 (2, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_690 1 (0, 2)).mono (by decide +kernel) + · exact finite_row_works_691_i7.mono (by decide +kernel) + +theorem finite_row_works_691_i6 : FiniteTemplate HasSnaky 14 required_691_i6 envelope_691_i6 := by + refine finite_compose HasSnaky 13 childrenC_691_i6 childrenD_691_i6 finite_children_work_691_i6 (3, 7) + required_691_i6 envelope_691_i6 pivot_mem_691_i6 child_required_sub_691_i6 child_envelope_sub_691_i6 ?_ + intro b hb + exact common_sub_691_i6 (mem_commonEnvelope childrenD_691_i6 b hb) + +theorem finite_children_work_691 : ∀ j, FiniteTemplate HasSnaky 17 (childrenC_691 j) (childrenD_691 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 1 (2, 3)).mono (by decide +kernel) + · exact finite_row_works_691_i0.mono (by decide +kernel) + · exact finite_row_works_691_i1.mono (by decide +kernel) + · exact finite_row_works_691_i6.mono (by decide +kernel) + +theorem finite_row_works_691 : FiniteTemplate HasSnaky 18 required_691 envelope_691 := by + refine finite_compose HasSnaky 17 childrenC_691 childrenD_691 finite_children_work_691 (3, 6) + required_691 envelope_691 pivot_mem_691 child_required_sub_691 child_envelope_sub_691 ?_ + intro b hb + exact common_sub_691 (mem_commonEnvelope childrenD_691 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height18Part02.lean b/lean/snaky/FiniteCards/Height18Part02.lean new file mode 100644 index 0000000..33a4111 --- /dev/null +++ b/lean/snaky/FiniteCards/Height18Part02.lean @@ -0,0 +1,140 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height18Part02 +import FiniteCards.Height01Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height06Part03 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part02 +import FiniteCards.Height09Part01 +import FiniteCards.Height11Part01 +import FiniteCards.Height11Part06 +import FiniteCards.Height14Part04 +import FiniteCards.Height15Part03 +import FiniteCards.Height16Part02 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_701_i1 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_701_i1 j) (childrenD_701_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 3 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_39 2 (6, 6)).mono (by decide +kernel) + +theorem finite_row_works_701_i1 : FiniteTemplate HasSnaky 5 required_701_i1 envelope_701_i1 := by + refine finite_compose HasSnaky 4 childrenC_701_i1 childrenD_701_i1 finite_children_work_701_i1 (5, 8) + required_701_i1 envelope_701_i1 pivot_mem_701_i1 child_required_sub_701_i1 child_envelope_sub_701_i1 ?_ + intro b hb + exact common_sub_701_i1 (mem_commonEnvelope childrenD_701_i1 b hb) + +theorem finite_children_work_701_i2 : ∀ j, FiniteTemplate HasSnaky 9 (childrenC_701_i2 j) (childrenD_701_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_52 5 (8, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_325 1 (1, 6)).mono (by decide +kernel) + +theorem finite_row_works_701_i2 : FiniteTemplate HasSnaky 10 required_701_i2 envelope_701_i2 := by + refine finite_compose HasSnaky 9 childrenC_701_i2 childrenD_701_i2 finite_children_work_701_i2 (5, 8) + required_701_i2 envelope_701_i2 pivot_mem_701_i2 child_required_sub_701_i2 child_envelope_sub_701_i2 ?_ + intro b hb + exact common_sub_701_i2 (mem_commonEnvelope childrenD_701_i2 b hb) + +theorem finite_children_work_701_i3 : ∀ j, FiniteTemplate HasSnaky 11 (childrenC_701_i3 j) (childrenD_701_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_8 2 (7, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_463 1 (2, 6)).mono (by decide +kernel) + +theorem finite_row_works_701_i3 : FiniteTemplate HasSnaky 12 required_701_i3 envelope_701_i3 := by + refine finite_compose HasSnaky 11 childrenC_701_i3 childrenD_701_i3 finite_children_work_701_i3 (4, 7) + required_701_i3 envelope_701_i3 pivot_mem_701_i3 child_required_sub_701_i3 child_envelope_sub_701_i3 ?_ + intro b hb + exact common_sub_701_i3 (mem_commonEnvelope childrenD_701_i3 b hb) + +theorem finite_children_work_701_i4 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_701_i4 j) (childrenD_701_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_18 3 (4, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_348 2 (7, 6)).mono (by decide +kernel) + +theorem finite_row_works_701_i4 : FiniteTemplate HasSnaky 7 required_701_i4 envelope_701_i4 := by + refine finite_compose HasSnaky 6 childrenC_701_i4 childrenD_701_i4 finite_children_work_701_i4 (4, 8) + required_701_i4 envelope_701_i4 pivot_mem_701_i4 child_required_sub_701_i4 child_envelope_sub_701_i4 ?_ + intro b hb + exact common_sub_701_i4 (mem_commonEnvelope childrenD_701_i4 b hb) + +theorem finite_children_work_701_i6 : ∀ j, FiniteTemplate HasSnaky 3 (childrenC_701_i6 j) (childrenD_701_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (5, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 0 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_701_i6 : FiniteTemplate HasSnaky 4 required_701_i6 envelope_701_i6 := by + refine finite_compose HasSnaky 3 childrenC_701_i6 childrenD_701_i6 finite_children_work_701_i6 (5, 9) + required_701_i6 envelope_701_i6 pivot_mem_701_i6 child_required_sub_701_i6 child_envelope_sub_701_i6 ?_ + intro b hb + exact common_sub_701_i6 (mem_commonEnvelope childrenD_701_i6 b hb) + +theorem finite_children_work_701_i7 : ∀ j, FiniteTemplate HasSnaky 7 (childrenC_701_i7 j) (childrenD_701_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_5 3 (5, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_372 0 (4, 6)).mono (by decide +kernel) + +theorem finite_row_works_701_i7 : FiniteTemplate HasSnaky 8 required_701_i7 envelope_701_i7 := by + refine finite_compose HasSnaky 7 childrenC_701_i7 childrenD_701_i7 finite_children_work_701_i7 (5, 9) + required_701_i7 envelope_701_i7 pivot_mem_701_i7 child_required_sub_701_i7 child_envelope_sub_701_i7 ?_ + intro b hb + exact common_sub_701_i7 (mem_commonEnvelope childrenD_701_i7 b hb) + +theorem finite_children_work_701_i5 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_701_i5 j) (childrenD_701_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_10 3 (4, 8)).mono (by decide +kernel) + · exact finite_row_works_701_i6.mono (by decide +kernel) + · exact finite_row_works_701_i7.mono (by decide +kernel) + +theorem finite_row_works_701_i5 : FiniteTemplate HasSnaky 9 required_701_i5 envelope_701_i5 := by + refine finite_compose HasSnaky 8 childrenC_701_i5 childrenD_701_i5 finite_children_work_701_i5 (5, 8) + required_701_i5 envelope_701_i5 pivot_mem_701_i5 child_required_sub_701_i5 child_envelope_sub_701_i5 ?_ + intro b hb + exact common_sub_701_i5 (mem_commonEnvelope childrenD_701_i5 b hb) + +theorem finite_children_work_701_i0 : ∀ j, FiniteTemplate HasSnaky 16 (childrenC_701_i0 j) (childrenD_701_i0 j) := by + intro j + fin_cases j + · exact finite_row_works_701_i1.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_683 5 (10, 6)).mono (by decide +kernel) + · exact finite_row_works_701_i2.mono (by decide +kernel) + · exact finite_row_works_701_i3.mono (by decide +kernel) + · exact finite_row_works_701_i4.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_700 1 (2, 6)).mono (by decide +kernel) + · exact finite_row_works_701_i5.mono (by decide +kernel) + +theorem finite_row_works_701_i0 : FiniteTemplate HasSnaky 17 required_701_i0 envelope_701_i0 := by + refine finite_compose HasSnaky 16 childrenC_701_i0 childrenD_701_i0 finite_children_work_701_i0 (5, 10) + required_701_i0 envelope_701_i0 pivot_mem_701_i0 child_required_sub_701_i0 child_envelope_sub_701_i0 ?_ + intro b hb + exact common_sub_701_i0 (mem_commonEnvelope childrenD_701_i0 b hb) + +theorem finite_children_work_701 : ∀ j, FiniteTemplate HasSnaky 17 (childrenC_701 j) (childrenD_701 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 3 (3, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_322 2 (8, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 0 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_697 6 (9, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_699 0 (1, 2)).mono (by decide +kernel) + · exact finite_row_works_701_i0.mono (by decide +kernel) + +theorem finite_row_works_701 : FiniteTemplate HasSnaky 18 required_701 envelope_701 := by + refine finite_compose HasSnaky 17 childrenC_701 childrenD_701 finite_children_work_701 (7, 7) + required_701 envelope_701 pivot_mem_701 child_required_sub_701 child_envelope_sub_701 ?_ + intro b hb + exact common_sub_701 (mem_commonEnvelope childrenD_701 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height19Part01.lean b/lean/snaky/FiniteCards/Height19Part01.lean new file mode 100644 index 0000000..db23b2f --- /dev/null +++ b/lean/snaky/FiniteCards/Height19Part01.lean @@ -0,0 +1,69 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height19Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height05Part01 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part04 +import FiniteCards.Height06Part06 +import FiniteCards.Height07Part01 +import FiniteCards.Height09Part01 +import FiniteCards.Height09Part04 +import FiniteCards.Height10Part02 +import FiniteCards.Height10Part03 +import FiniteCards.Height14Part03 +import FiniteCards.Height18Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_694_i0 : ∀ j, FiniteTemplate HasSnaky 10 (childrenC_694_i0 j) (childrenD_694_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_390 4 (4, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_544 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_545 1 (0, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_546 5 (9, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_549 1 (0, 5)).mono (by decide +kernel) + +theorem finite_row_works_694_i0 : FiniteTemplate HasSnaky 11 required_694_i0 envelope_694_i0 := by + refine finite_compose HasSnaky 10 childrenC_694_i0 childrenD_694_i0 finite_children_work_694_i0 (4, 6) + required_694_i0 envelope_694_i0 pivot_mem_694_i0 child_required_sub_694_i0 child_envelope_sub_694_i0 ?_ + intro b hb + exact common_sub_694_i0 (mem_commonEnvelope childrenD_694_i0 b hb) + +theorem finite_children_work_694_i1 : ∀ j, FiniteTemplate HasSnaky 14 (childrenC_694_i1 j) (childrenD_694_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 4 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_26 3 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_142 7 (8, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_693 3 (0, 11)).mono (by decide +kernel) + +theorem finite_row_works_694_i1 : FiniteTemplate HasSnaky 15 required_694_i1 envelope_694_i1 := by + refine finite_compose HasSnaky 14 childrenC_694_i1 childrenD_694_i1 finite_children_work_694_i1 (5, 4) + required_694_i1 envelope_694_i1 pivot_mem_694_i1 child_required_sub_694_i1 child_envelope_sub_694_i1 ?_ + intro b hb + exact common_sub_694_i1 (mem_commonEnvelope childrenD_694_i1 b hb) + +theorem finite_children_work_694 : ∀ j, FiniteTemplate HasSnaky 18 (childrenC_694 j) (childrenD_694 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_116 3 (2, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_188 2 (7, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_397 1 (2, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 5 (8, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_691 0 (2, 2)).mono (by decide +kernel) + · exact finite_row_works_694_i0.mono (by decide +kernel) + · exact finite_row_works_694_i1.mono (by decide +kernel) + +theorem finite_row_works_694 : FiniteTemplate HasSnaky 19 required_694 envelope_694 := by + refine finite_compose HasSnaky 18 childrenC_694 childrenD_694 finite_children_work_694 (5, 7) + required_694 envelope_694 pivot_mem_694 child_required_sub_694 child_envelope_sub_694 ?_ + intro b hb + exact common_sub_694 (mem_commonEnvelope childrenD_694 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height20Part01.lean b/lean/snaky/FiniteCards/Height20Part01.lean new file mode 100644 index 0000000..57af76b --- /dev/null +++ b/lean/snaky/FiniteCards/Height20Part01.lean @@ -0,0 +1,237 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height20Part01 +import FiniteCards.Height03Part01 +import FiniteCards.Height04Part01 +import FiniteCards.Height04Part02 +import FiniteCards.Height04Part03 +import FiniteCards.Height05Part01 +import FiniteCards.Height05Part02 +import FiniteCards.Height06Part01 +import FiniteCards.Height06Part02 +import FiniteCards.Height06Part04 +import FiniteCards.Height07Part01 +import FiniteCards.Height07Part04 +import FiniteCards.Height08Part01 +import FiniteCards.Height08Part05 +import FiniteCards.Height10Part01 +import FiniteCards.Height11Part02 +import FiniteCards.Height11Part06 +import FiniteCards.Height12Part02 +import FiniteCards.Height12Part03 +import FiniteCards.Height12Part04 +import FiniteCards.Height12Part05 +import FiniteCards.Height13Part01 +import FiniteCards.Height13Part03 +import FiniteCards.Height13Part04 +import FiniteCards.Height13Part06 +import FiniteCards.Height15Part02 +import FiniteCards.Height15Part03 +import FiniteCards.Height16Part03 +import FiniteCards.Height17Part02 +import FiniteCards.Height18Part01 +import FiniteCards.Height18Part02 +import FiniteCards.Height19Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_708_i2 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_708_i2 j) (childrenD_708_i2 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 5 (9, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_234 1 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_241 5 (9, 7)).mono (by decide +kernel) + +theorem finite_row_works_708_i2 : FiniteTemplate HasSnaky 6 required_708_i2 envelope_708_i2 := by + refine finite_compose HasSnaky 5 childrenC_708_i2 childrenD_708_i2 finite_children_work_708_i2 (5, 8) + required_708_i2 envelope_708_i2 pivot_mem_708_i2 child_required_sub_708_i2 child_envelope_sub_708_i2 ?_ + intro b hb + exact common_sub_708_i2 (mem_commonEnvelope childrenD_708_i2 b hb) + +theorem finite_children_work_708_i4 : ∀ j, FiniteTemplate HasSnaky 4 (childrenC_708_i4 j) (childrenD_708_i4 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 2 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_9 0 (6, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_92 5 (9, 6)).mono (by decide +kernel) + +theorem finite_row_works_708_i4 : FiniteTemplate HasSnaky 5 required_708_i4 envelope_708_i4 := by + refine finite_compose HasSnaky 4 childrenC_708_i4 childrenD_708_i4 finite_children_work_708_i4 (7, 9) + required_708_i4 envelope_708_i4 pivot_mem_708_i4 child_required_sub_708_i4 child_envelope_sub_708_i4 ?_ + intro b hb + exact common_sub_708_i4 (mem_commonEnvelope childrenD_708_i4 b hb) + +theorem finite_children_work_708_i3 : ∀ j, FiniteTemplate HasSnaky 5 (childrenC_708_i3 j) (childrenD_708_i3 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_44 2 (7, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_52 0 (7, 5)).mono (by decide +kernel) + · exact finite_row_works_708_i4.mono (by decide +kernel) + +theorem finite_row_works_708_i3 : FiniteTemplate HasSnaky 6 required_708_i3 envelope_708_i3 := by + refine finite_compose HasSnaky 5 childrenC_708_i3 childrenD_708_i3 finite_children_work_708_i3 (7, 6) + required_708_i3 envelope_708_i3 pivot_mem_708_i3 child_required_sub_708_i3 child_envelope_sub_708_i3 ?_ + intro b hb + exact common_sub_708_i3 (mem_commonEnvelope childrenD_708_i3 b hb) + +theorem finite_children_work_708_i1 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_708_i1 j) (childrenD_708_i1 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_57 2 (9, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_88 2 (9, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_111 2 (9, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_213 0 (5, 5)).mono (by decide +kernel) + · exact finite_row_works_708_i2.mono (by decide +kernel) + · exact finite_row_works_708_i3.mono (by decide +kernel) + +theorem finite_row_works_708_i1 : FiniteTemplate HasSnaky 7 required_708_i1 envelope_708_i1 := by + refine finite_compose HasSnaky 6 childrenC_708_i1 childrenD_708_i1 finite_children_work_708_i1 (7, 7) + required_708_i1 envelope_708_i1 pivot_mem_708_i1 child_required_sub_708_i1 child_envelope_sub_708_i1 ?_ + intro b hb + exact common_sub_708_i1 (mem_commonEnvelope childrenD_708_i1 b hb) + +theorem finite_children_work_708_i5 : ∀ j, FiniteTemplate HasSnaky 6 (childrenC_708_i5 j) (childrenD_708_i5 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_7 3 (5, 8)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_186 5 (11, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_292 6 (9, 11)).mono (by decide +kernel) + +theorem finite_row_works_708_i5 : FiniteTemplate HasSnaky 7 required_708_i5 envelope_708_i5 := by + refine finite_compose HasSnaky 6 childrenC_708_i5 childrenD_708_i5 finite_children_work_708_i5 (9, 8) + required_708_i5 envelope_708_i5 pivot_mem_708_i5 child_required_sub_708_i5 child_envelope_sub_708_i5 ?_ + intro b hb + exact common_sub_708_i5 (mem_commonEnvelope childrenD_708_i5 b hb) + +theorem finite_children_work_708_i0 : ∀ j, FiniteTemplate HasSnaky 8 (childrenC_708_i0 j) (childrenD_708_i0 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_117 0 (5, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_137 2 (9, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 2 (9, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_257 2 (9, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 2 (9, 5)).mono (by decide +kernel) + · exact finite_row_works_708_i1.mono (by decide +kernel) + · exact finite_row_works_708_i5.mono (by decide +kernel) + +theorem finite_row_works_708_i0 : FiniteTemplate HasSnaky 9 required_708_i0 envelope_708_i0 := by + refine finite_compose HasSnaky 8 childrenC_708_i0 childrenD_708_i0 finite_children_work_708_i0 (6, 8) + required_708_i0 envelope_708_i0 pivot_mem_708_i0 child_required_sub_708_i0 child_envelope_sub_708_i0 ?_ + intro b hb + exact common_sub_708_i0 (mem_commonEnvelope childrenD_708_i0 b hb) + +theorem finite_children_work_708_i6 : ∀ j, FiniteTemplate HasSnaky 12 (childrenC_708_i6 j) (childrenD_708_i6 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 3 (5, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_135 5 (11, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_181 0 (6, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_435 4 (6, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_565 4 (5, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_687 2 (12, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_689 0 (5, 4)).mono (by decide +kernel) + +theorem finite_row_works_708_i6 : FiniteTemplate HasSnaky 13 required_708_i6 envelope_708_i6 := by + refine finite_compose HasSnaky 12 childrenC_708_i6 childrenD_708_i6 finite_children_work_708_i6 (9, 8) + required_708_i6 envelope_708_i6 pivot_mem_708_i6 child_required_sub_708_i6 child_envelope_sub_708_i6 ?_ + intro b hb + exact common_sub_708_i6 (mem_commonEnvelope childrenD_708_i6 b hb) + +theorem finite_children_work_708_i7 : ∀ j, FiniteTemplate HasSnaky 13 (childrenC_708_i7 j) (childrenD_708_i7 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_12 1 (5, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 3 (5, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 5 (11, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_12 7 (11, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_490 0 (5, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_490 2 (11, 1)).mono (by decide +kernel) + +theorem finite_row_works_708_i7 : FiniteTemplate HasSnaky 14 required_708_i7 envelope_708_i7 := by + refine finite_compose HasSnaky 13 childrenC_708_i7 childrenD_708_i7 finite_children_work_708_i7 (9, 8) + required_708_i7 envelope_708_i7 pivot_mem_708_i7 child_required_sub_708_i7 child_envelope_sub_708_i7 ?_ + intro b hb + exact common_sub_708_i7 (mem_commonEnvelope childrenD_708_i7 b hb) + +theorem finite_children_work_708 : ∀ j, FiniteTemplate HasSnaky 19 (childrenC_708 j) (childrenD_708 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_459 5 (12, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_475 5 (11, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_587 3 (4, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_603 1 (4, 7)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_605 0 (5, 5)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_650 6 (11, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_684 0 (1, 1)).mono (by decide +kernel) + · exact finite_row_works_708_i0.mono (by decide +kernel) + · exact finite_row_works_708_i6.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_694 7 (13, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_695 0 (5, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_696 5 (13, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_698 1 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_701 2 (13, 1)).mono (by decide +kernel) + · exact finite_row_works_708_i7.mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_707 2 (12, 3)).mono (by decide +kernel) + +theorem finite_row_works_708 : FiniteTemplate HasSnaky 20 required_708 envelope_708 := by + refine finite_compose HasSnaky 19 childrenC_708 childrenD_708 finite_children_work_708 (7, 8) + required_708 envelope_708 pivot_mem_708 child_required_sub_708 child_envelope_sub_708 ?_ + intro b hb + exact common_sub_708 (mem_commonEnvelope childrenD_708 b hb) + +theorem finite_children_work_725 : ∀ j, FiniteTemplate HasSnaky 19 (childrenC_725 j) (childrenD_725 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_459 4 (6, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_579 7 (11, 9)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_581 6 (11, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_654 4 (4, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_661 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_677 6 (10, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_682 7 (12, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_694 4 (2, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_696 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_698 6 (11, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_709 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_710 0 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_715 3 (2, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_717 7 (13, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_718 0 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_724 6 (12, 15)).mono (by decide +kernel) + +theorem finite_row_works_725 : FiniteTemplate HasSnaky 20 required_725 envelope_725 := by + refine finite_compose HasSnaky 19 childrenC_725 childrenD_725 finite_children_work_725 (7, 8) + required_725 envelope_725 pivot_mem_725 child_required_sub_725 child_envelope_sub_725 ?_ + intro b hb + exact common_sub_725 (mem_commonEnvelope childrenD_725 b hb) + +theorem finite_children_work_726 : ∀ j, FiniteTemplate HasSnaky 19 (childrenC_726 j) (childrenD_726 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_459 1 (3, 6)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_579 4 (6, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_581 1 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_654 1 (4, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_661 5 (12, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_677 3 (3, 10)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_682 4 (4, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_694 1 (2, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_696 5 (13, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_698 3 (3, 11)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_709 5 (13, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_710 5 (12, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_715 0 (3, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_717 4 (3, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_718 5 (13, 2)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_724 5 (15, 2)).mono (by decide +kernel) + +theorem finite_row_works_726 : FiniteTemplate HasSnaky 20 required_726 envelope_726 := by + refine finite_compose HasSnaky 19 childrenC_726 childrenD_726 finite_children_work_726 (8, 7) + required_726 envelope_726 pivot_mem_726 child_required_sub_726 child_envelope_sub_726 ?_ + intro b hb + exact common_sub_726 (mem_commonEnvelope childrenD_726 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/FiniteCards/Height21Part01.lean b/lean/snaky/FiniteCards/Height21Part01.lean new file mode 100644 index 0000000..78befb7 --- /dev/null +++ b/lean/snaky/FiniteCards/Height21Part01.lean @@ -0,0 +1,55 @@ +/- Derived from openai/math SnakyTwentyOne card proofs at +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Modified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/ +import SnakySemantics +import OAI.GameTheory.SnakyTwentyOne.Cards.Height21Part01 +import FiniteCards.Height15Part01 +import FiniteCards.Height15Part03 +import FiniteCards.Height20Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +theorem finite_children_work_727 : ∀ j, FiniteTemplate HasSnaky 20 (childrenC_727 j) (childrenD_727 j) := by + intro j + fin_cases j + · exact (finite_placed21_template finite_row_works_648 0 (4, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_648 1 (3, 4)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_648 3 (3, 12)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_648 4 (4, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_708 1 (0, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_708 2 (16, 0)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_708 4 (0, 16)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_708 7 (16, 16)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_712 0 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_712 1 (3, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_712 2 (13, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_712 3 (3, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_712 4 (3, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_712 5 (13, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_712 6 (13, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_712 7 (13, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_713 2 (13, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_713 3 (3, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_713 4 (3, 13)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_713 5 (13, 3)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_725 0 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_725 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_725 2 (15, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_725 3 (1, 15)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_725 4 (1, 15)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_725 5 (15, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_725 6 (15, 15)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_725 7 (15, 15)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_726 1 (1, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_726 2 (15, 1)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_726 4 (1, 15)).mono (by decide +kernel) + · exact (finite_placed21_template finite_row_works_726 6 (15, 15)).mono (by decide +kernel) + +theorem finite_row_works_727 : FiniteTemplate HasSnaky 21 required_727 envelope_727 := by + refine finite_compose HasSnaky 20 childrenC_727 childrenD_727 finite_children_work_727 (8, 8) + required_727 envelope_727 pivot_mem_727 child_required_sub_727 child_envelope_sub_727 ?_ + intro b hb + exact common_sub_727 (mem_commonEnvelope childrenD_727 b hb) + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height01Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height01Part01.lean new file mode 100644 index 0000000..b1b9b1c --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height01Part01.lean @@ -0,0 +1,124 @@ +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_0 : Finset Cell := ⟨(([(1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_0 : Finset Cell := ⟨(([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +theorem row_works_0 : Template HasSnaky 1 required_0 envelope_0 := by + have hA : required_0 = snaky.erase (0, 0) := by decide +kernel + have hT : envelope_0 = snaky := by decide +kernel + rw [hA, hT] + exact immediate_template HasSnaky snaky (0, 0) (by decide +kernel) identity_target +def required_1 : Finset Cell := ⟨(([(0, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_1 : Finset Cell := ⟨(([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +theorem row_works_1 : Template HasSnaky 1 required_1 envelope_1 := by + have hA : required_1 = snaky.erase (1, 0) := by decide +kernel + have hT : envelope_1 = snaky := by decide +kernel + rw [hA, hT] + exact immediate_template HasSnaky snaky (1, 0) (by decide +kernel) identity_target +def required_2 : Finset Cell := ⟨(([(0, 0), (1, 0), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_2 : Finset Cell := ⟨(([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +theorem row_works_2 : Template HasSnaky 1 required_2 envelope_2 := by + have hA : required_2 = snaky.erase (2, 0) := by decide +kernel + have hT : envelope_2 = snaky := by decide +kernel + rw [hA, hT] + exact immediate_template HasSnaky snaky (2, 0) (by decide +kernel) identity_target +def required_3 : Finset Cell := ⟨(([(0, 0), (1, 0), (2, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_3 : Finset Cell := ⟨(([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +theorem row_works_3 : Template HasSnaky 1 required_3 envelope_3 := by + have hA : required_3 = snaky.erase (3, 0) := by decide +kernel + have hT : envelope_3 = snaky := by decide +kernel + rw [hA, hT] + exact immediate_template HasSnaky snaky (3, 0) (by decide +kernel) identity_target +def required_4 : Finset Cell := ⟨(([(0, 0), (1, 0), (2, 0), (3, 0), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_4 : Finset Cell := ⟨(([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +theorem row_works_4 : Template HasSnaky 1 required_4 envelope_4 := by + have hA : required_4 = snaky.erase (3, 1) := by decide +kernel + have hT : envelope_4 = snaky := by decide +kernel + rw [hA, hT] + exact immediate_template HasSnaky snaky (3, 1) (by decide +kernel) identity_target +def required_5 : Finset Cell := ⟨(([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_5 : Finset Cell := ⟨(([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +theorem row_works_5 : Template HasSnaky 1 required_5 envelope_5 := by + have hA : required_5 = snaky.erase (4, 1) := by decide +kernel + have hT : envelope_5 = snaky := by decide +kernel + rw [hA, hT] + exact immediate_template HasSnaky snaky (4, 1) (by decide +kernel) identity_target +def height_0 : ℕ := 1 +theorem base_required_exact_0 : required_0 = snaky.erase (0, 0) := by decide +kernel +theorem base_envelope_exact_0 : envelope_0 = snaky := by decide +kernel +theorem base_height_exact_0 : height_0 = 1 := rfl +def checked_0 : CheckedCard where + required := required_0 + envelope := envelope_0 + height := height_0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_0 +def height_1 : ℕ := 1 +theorem base_required_exact_1 : required_1 = snaky.erase (1, 0) := by decide +kernel +theorem base_envelope_exact_1 : envelope_1 = snaky := by decide +kernel +theorem base_height_exact_1 : height_1 = 1 := rfl +def checked_1 : CheckedCard where + required := required_1 + envelope := envelope_1 + height := height_1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_1 +def height_2 : ℕ := 1 +theorem base_required_exact_2 : required_2 = snaky.erase (2, 0) := by decide +kernel +theorem base_envelope_exact_2 : envelope_2 = snaky := by decide +kernel +theorem base_height_exact_2 : height_2 = 1 := rfl +def checked_2 : CheckedCard where + required := required_2 + envelope := envelope_2 + height := height_2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_2 +def height_3 : ℕ := 1 +theorem base_required_exact_3 : required_3 = snaky.erase (3, 0) := by decide +kernel +theorem base_envelope_exact_3 : envelope_3 = snaky := by decide +kernel +theorem base_height_exact_3 : height_3 = 1 := rfl +def checked_3 : CheckedCard where + required := required_3 + envelope := envelope_3 + height := height_3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_3 +def height_4 : ℕ := 1 +theorem base_required_exact_4 : required_4 = snaky.erase (3, 1) := by decide +kernel +theorem base_envelope_exact_4 : envelope_4 = snaky := by decide +kernel +theorem base_height_exact_4 : height_4 = 1 := rfl +def checked_4 : CheckedCard where + required := required_4 + envelope := envelope_4 + height := height_4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_4 +def height_5 : ℕ := 1 +theorem base_required_exact_5 : required_5 = snaky.erase (4, 1) := by decide +kernel +theorem base_envelope_exact_5 : envelope_5 = snaky := by decide +kernel +theorem base_height_exact_5 : height_5 = 1 := rfl +def checked_5 : CheckedCard where + required := required_5 + envelope := envelope_5 + height := height_5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_5 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part01.lean new file mode 100644 index 0000000..013dcdc --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part01.lean @@ -0,0 +1,995 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_6 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_6 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_6 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_4), (placed21 1 (0, 1) required_5)] +def childrenD_6 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_4), (placed21 1 (0, 1) envelope_5)] +theorem common_sub_6 : commonEnvelope childrenD_6 ⊆ insert (1, 4) required_6 := by decide +kernel +theorem child_required_sub_6 : ∀ j, childrenC_6 j ⊆ insert (1, 4) required_6 := by decide +kernel +theorem child_envelope_sub_6 : ∀ j, childrenD_6 j ⊆ envelope_6 := by decide +kernel +theorem pivot_mem_6 : (1, 4) ∈ envelope_6 := by decide +kernel +theorem children_work_6 : ∀ j, Template HasSnaky 1 (childrenC_6 j) (childrenD_6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_5 1 (0, 1)).mono (by decide +kernel) +theorem row_works_6 : Template HasSnaky 2 required_6 envelope_6 := by + refine compose HasSnaky 1 childrenC_6 childrenD_6 children_work_6 (1, 4) + required_6 envelope_6 pivot_mem_6 child_required_sub_6 child_envelope_sub_6 ?_ + intro b hb + exact common_sub_6 (mem_commonEnvelope childrenD_6 b hb) +def required_11 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (1, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_11 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_11 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) required_0), (placed21 3 (0, 4) required_5)] +def childrenD_11 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) envelope_0), (placed21 3 (0, 4) envelope_5)] +theorem common_sub_11 : commonEnvelope childrenD_11 ⊆ insert (1, 1) required_11 := by decide +kernel +theorem child_required_sub_11 : ∀ j, childrenC_11 j ⊆ insert (1, 1) required_11 := by decide +kernel +theorem child_envelope_sub_11 : ∀ j, childrenD_11 j ⊆ envelope_11 := by decide +kernel +theorem pivot_mem_11 : (1, 1) ∈ envelope_11 := by decide +kernel +theorem children_work_11 : ∀ j, Template HasSnaky 1 (childrenC_11 j) (childrenD_11 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (0, 4)).mono (by decide +kernel) +theorem row_works_11 : Template HasSnaky 2 required_11 envelope_11 := by + refine compose HasSnaky 1 childrenC_11 childrenD_11 children_work_11 (1, 1) + required_11 envelope_11 pivot_mem_11 child_required_sub_11 child_envelope_sub_11 ?_ + intro b hb + exact common_sub_11 (mem_commonEnvelope childrenD_11 b hb) +def required_15 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_15 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_15 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 7 (1, 5) required_0)] +def childrenD_15 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 7 (1, 5) envelope_0)] +theorem common_sub_15 : commonEnvelope childrenD_15 ⊆ insert (1, 4) required_15 := by decide +kernel +theorem child_required_sub_15 : ∀ j, childrenC_15 j ⊆ insert (1, 4) required_15 := by decide +kernel +theorem child_envelope_sub_15 : ∀ j, childrenD_15 j ⊆ envelope_15 := by decide +kernel +theorem pivot_mem_15 : (1, 4) ∈ envelope_15 := by decide +kernel +theorem children_work_15 : ∀ j, Template HasSnaky 1 (childrenC_15 j) (childrenD_15 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) +theorem row_works_15 : Template HasSnaky 2 required_15 envelope_15 := by + refine compose HasSnaky 1 childrenC_15 childrenD_15 children_work_15 (1, 4) + required_15 envelope_15 pivot_mem_15 child_required_sub_15 child_envelope_sub_15 ?_ + intro b hb + exact common_sub_15 (mem_commonEnvelope childrenD_15 b hb) +def required_22 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_22 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_22 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) required_0), (placed21 3 (0, 4) required_5)] +def childrenD_22 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) envelope_0), (placed21 3 (0, 4) envelope_5)] +theorem common_sub_22 : commonEnvelope childrenD_22 ⊆ insert (0, 3) required_22 := by decide +kernel +theorem child_required_sub_22 : ∀ j, childrenC_22 j ⊆ insert (0, 3) required_22 := by decide +kernel +theorem child_envelope_sub_22 : ∀ j, childrenD_22 j ⊆ envelope_22 := by decide +kernel +theorem pivot_mem_22 : (0, 3) ∈ envelope_22 := by decide +kernel +theorem children_work_22 : ∀ j, Template HasSnaky 1 (childrenC_22 j) (childrenD_22 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (0, 4)).mono (by decide +kernel) +theorem row_works_22 : Template HasSnaky 2 required_22 envelope_22 := by + refine compose HasSnaky 1 childrenC_22 childrenD_22 children_work_22 (0, 3) + required_22 envelope_22 pivot_mem_22 child_required_sub_22 child_envelope_sub_22 ?_ + intro b hb + exact common_sub_22 (mem_commonEnvelope childrenD_22 b hb) +def required_23 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 1), (1, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_23 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_23 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) required_0), (placed21 3 (0, 4) required_5)] +def childrenD_23 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) envelope_0), (placed21 3 (0, 4) envelope_5)] +theorem common_sub_23 : commonEnvelope childrenD_23 ⊆ insert (0, 4) required_23 := by decide +kernel +theorem child_required_sub_23 : ∀ j, childrenC_23 j ⊆ insert (0, 4) required_23 := by decide +kernel +theorem child_envelope_sub_23 : ∀ j, childrenD_23 j ⊆ envelope_23 := by decide +kernel +theorem pivot_mem_23 : (0, 4) ∈ envelope_23 := by decide +kernel +theorem children_work_23 : ∀ j, Template HasSnaky 1 (childrenC_23 j) (childrenD_23 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (0, 4)).mono (by decide +kernel) +theorem row_works_23 : Template HasSnaky 2 required_23 envelope_23 := by + refine compose HasSnaky 1 childrenC_23 childrenD_23 children_work_23 (0, 4) + required_23 envelope_23 pivot_mem_23 child_required_sub_23 child_envelope_sub_23 ?_ + intro b hb + exact common_sub_23 (mem_commonEnvelope childrenD_23 b hb) +def required_25 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_25 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (4, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_25 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) required_2), (placed21 4 (0, 1) required_5)] +def childrenD_25 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) envelope_2), (placed21 4 (0, 1) envelope_5)] +theorem common_sub_25 : commonEnvelope childrenD_25 ⊆ insert (3, 0) required_25 := by decide +kernel +theorem child_required_sub_25 : ∀ j, childrenC_25 j ⊆ insert (3, 0) required_25 := by decide +kernel +theorem child_envelope_sub_25 : ∀ j, childrenD_25 j ⊆ envelope_25 := by decide +kernel +theorem pivot_mem_25 : (3, 0) ∈ envelope_25 := by decide +kernel +theorem children_work_25 : ∀ j, Template HasSnaky 1 (childrenC_25 j) (childrenD_25 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 3 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) +theorem row_works_25 : Template HasSnaky 2 required_25 envelope_25 := by + refine compose HasSnaky 1 childrenC_25 childrenD_25 children_work_25 (3, 0) + required_25 envelope_25 pivot_mem_25 child_required_sub_25 child_envelope_sub_25 ?_ + intro b hb + exact common_sub_25 (mem_commonEnvelope childrenD_25 b hb) +def required_28 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (1, 4), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_28 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_28 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 7 (1, 4) required_5)] +def childrenD_28 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 7 (1, 4) envelope_5)] +theorem common_sub_28 : commonEnvelope childrenD_28 ⊆ insert (1, 2) required_28 := by decide +kernel +theorem child_required_sub_28 : ∀ j, childrenC_28 j ⊆ insert (1, 2) required_28 := by decide +kernel +theorem child_envelope_sub_28 : ∀ j, childrenD_28 j ⊆ envelope_28 := by decide +kernel +theorem pivot_mem_28 : (1, 2) ∈ envelope_28 := by decide +kernel +theorem children_work_28 : ∀ j, Template HasSnaky 1 (childrenC_28 j) (childrenD_28 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) +theorem row_works_28 : Template HasSnaky 2 required_28 envelope_28 := by + refine compose HasSnaky 1 childrenC_28 childrenD_28 children_work_28 (1, 2) + required_28 envelope_28 pivot_mem_28 child_required_sub_28 child_envelope_sub_28 ?_ + intro b hb + exact common_sub_28 (mem_commonEnvelope childrenD_28 b hb) +def required_30 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (1, 0), (1, 1), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_30 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_30 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_0), (placed21 1 (0, 0) required_5)] +def childrenD_30 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_0), (placed21 1 (0, 0) envelope_5)] +theorem common_sub_30 : commonEnvelope childrenD_30 ⊆ insert (0, 2) required_30 := by decide +kernel +theorem child_required_sub_30 : ∀ j, childrenC_30 j ⊆ insert (0, 2) required_30 := by decide +kernel +theorem child_envelope_sub_30 : ∀ j, childrenD_30 j ⊆ envelope_30 := by decide +kernel +theorem pivot_mem_30 : (0, 2) ∈ envelope_30 := by decide +kernel +theorem children_work_30 : ∀ j, Template HasSnaky 1 (childrenC_30 j) (childrenD_30 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 1 (0, 0)).mono (by decide +kernel) +theorem row_works_30 : Template HasSnaky 2 required_30 envelope_30 := by + refine compose HasSnaky 1 childrenC_30 childrenD_30 children_work_30 (0, 2) + required_30 envelope_30 pivot_mem_30 child_required_sub_30 child_envelope_sub_30 ?_ + intro b hb + exact common_sub_30 (mem_commonEnvelope childrenD_30 b hb) +def required_32 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (2, 3), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_32 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (4, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_32 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) required_0), (placed21 4 (0, 1) required_5)] +def childrenD_32 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) envelope_0), (placed21 4 (0, 1) envelope_5)] +theorem common_sub_32 : commonEnvelope childrenD_32 ⊆ insert (3, 0) required_32 := by decide +kernel +theorem child_required_sub_32 : ∀ j, childrenC_32 j ⊆ insert (3, 0) required_32 := by decide +kernel +theorem child_envelope_sub_32 : ∀ j, childrenD_32 j ⊆ envelope_32 := by decide +kernel +theorem pivot_mem_32 : (3, 0) ∈ envelope_32 := by decide +kernel +theorem children_work_32 : ∀ j, Template HasSnaky 1 (childrenC_32 j) (childrenD_32 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) +theorem row_works_32 : Template HasSnaky 2 required_32 envelope_32 := by + refine compose HasSnaky 1 childrenC_32 childrenD_32 children_work_32 (3, 0) + required_32 envelope_32 pivot_mem_32 child_required_sub_32 child_envelope_sub_32 ?_ + intro b hb + exact common_sub_32 (mem_commonEnvelope childrenD_32 b hb) +def required_34 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_34 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_34 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_5), (placed21 3 (0, 4) required_5)] +def childrenD_34 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_5), (placed21 3 (0, 4) envelope_5)] +theorem common_sub_34 : commonEnvelope childrenD_34 ⊆ insert (0, 3) required_34 := by decide +kernel +theorem child_required_sub_34 : ∀ j, childrenC_34 j ⊆ insert (0, 3) required_34 := by decide +kernel +theorem child_envelope_sub_34 : ∀ j, childrenD_34 j ⊆ envelope_34 := by decide +kernel +theorem pivot_mem_34 : (0, 3) ∈ envelope_34 := by decide +kernel +theorem children_work_34 : ∀ j, Template HasSnaky 1 (childrenC_34 j) (childrenD_34 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (0, 4)).mono (by decide +kernel) +theorem row_works_34 : Template HasSnaky 2 required_34 envelope_34 := by + refine compose HasSnaky 1 childrenC_34 childrenD_34 children_work_34 (0, 3) + required_34 envelope_34 pivot_mem_34 child_required_sub_34 child_envelope_sub_34 ?_ + intro b hb + exact common_sub_34 (mem_commonEnvelope childrenD_34 b hb) +def required_35 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_35 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_35 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) required_1), (placed21 0 (0, 1) required_5)] +def childrenD_35 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) envelope_1), (placed21 0 (0, 1) envelope_5)] +theorem common_sub_35 : commonEnvelope childrenD_35 ⊆ insert (3, 2) required_35 := by decide +kernel +theorem child_required_sub_35 : ∀ j, childrenC_35 j ⊆ insert (3, 2) required_35 := by decide +kernel +theorem child_envelope_sub_35 : ∀ j, childrenD_35 j ⊆ envelope_35 := by decide +kernel +theorem pivot_mem_35 : (3, 2) ∈ envelope_35 := by decide +kernel +theorem children_work_35 : ∀ j, Template HasSnaky 1 (childrenC_35 j) (childrenD_35 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 7 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) +theorem row_works_35 : Template HasSnaky 2 required_35 envelope_35 := by + refine compose HasSnaky 1 childrenC_35 childrenD_35 children_work_35 (3, 2) + required_35 envelope_35 pivot_mem_35 child_required_sub_35 child_envelope_sub_35 ?_ + intro b hb + exact common_sub_35 (mem_commonEnvelope childrenD_35 b hb) +def required_36 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (1, 1), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_36 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_36 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_2), (placed21 7 (1, 4) required_2)] +def childrenD_36 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_2), (placed21 7 (1, 4) envelope_2)] +theorem common_sub_36 : commonEnvelope childrenD_36 ⊆ insert (1, 4) required_36 := by decide +kernel +theorem child_required_sub_36 : ∀ j, childrenC_36 j ⊆ insert (1, 4) required_36 := by decide +kernel +theorem child_envelope_sub_36 : ∀ j, childrenD_36 j ⊆ envelope_36 := by decide +kernel +theorem pivot_mem_36 : (1, 4) ∈ envelope_36 := by decide +kernel +theorem children_work_36 : ∀ j, Template HasSnaky 1 (childrenC_36 j) (childrenD_36 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_2 7 (1, 4)).mono (by decide +kernel) +theorem row_works_36 : Template HasSnaky 2 required_36 envelope_36 := by + refine compose HasSnaky 1 childrenC_36 childrenD_36 children_work_36 (1, 4) + required_36 envelope_36 pivot_mem_36 child_required_sub_36 child_envelope_sub_36 ?_ + intro b hb + exact common_sub_36 (mem_commonEnvelope childrenD_36 b hb) +def required_38 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_38 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_38 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) required_0), (placed21 0 (0, 1) required_5)] +def childrenD_38 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) envelope_0), (placed21 0 (0, 1) envelope_5)] +theorem common_sub_38 : commonEnvelope childrenD_38 ⊆ insert (3, 2) required_38 := by decide +kernel +theorem child_required_sub_38 : ∀ j, childrenC_38 j ⊆ insert (3, 2) required_38 := by decide +kernel +theorem child_envelope_sub_38 : ∀ j, childrenD_38 j ⊆ envelope_38 := by decide +kernel +theorem pivot_mem_38 : (3, 2) ∈ envelope_38 := by decide +kernel +theorem children_work_38 : ∀ j, Template HasSnaky 1 (childrenC_38 j) (childrenD_38 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) +theorem row_works_38 : Template HasSnaky 2 required_38 envelope_38 := by + refine compose HasSnaky 1 childrenC_38 childrenD_38 children_work_38 (3, 2) + required_38 envelope_38 pivot_mem_38 child_required_sub_38 child_envelope_sub_38 ?_ + intro b hb + exact common_sub_38 (mem_commonEnvelope childrenD_38 b hb) +def required_40 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 4), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_40 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_40 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), (placed21 7 (1, 4) required_5)] +def childrenD_40 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), (placed21 7 (1, 4) envelope_5)] +theorem common_sub_40 : commonEnvelope childrenD_40 ⊆ insert (1, 3) required_40 := by decide +kernel +theorem child_required_sub_40 : ∀ j, childrenC_40 j ⊆ insert (1, 3) required_40 := by decide +kernel +theorem child_envelope_sub_40 : ∀ j, childrenD_40 j ⊆ envelope_40 := by decide +kernel +theorem pivot_mem_40 : (1, 3) ∈ envelope_40 := by decide +kernel +theorem children_work_40 : ∀ j, Template HasSnaky 1 (childrenC_40 j) (childrenD_40 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) +theorem row_works_40 : Template HasSnaky 2 required_40 envelope_40 := by + refine compose HasSnaky 1 childrenC_40 childrenD_40 children_work_40 (1, 3) + required_40 envelope_40 pivot_mem_40 child_required_sub_40 child_envelope_sub_40 ?_ + intro b hb + exact common_sub_40 (mem_commonEnvelope childrenD_40 b hb) +def required_43 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_43 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_43 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), (placed21 7 (1, 4) required_3)] +def childrenD_43 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), (placed21 7 (1, 4) envelope_3)] +theorem common_sub_43 : commonEnvelope childrenD_43 ⊆ insert (1, 4) required_43 := by decide +kernel +theorem child_required_sub_43 : ∀ j, childrenC_43 j ⊆ insert (1, 4) required_43 := by decide +kernel +theorem child_envelope_sub_43 : ∀ j, childrenD_43 j ⊆ envelope_43 := by decide +kernel +theorem pivot_mem_43 : (1, 4) ∈ envelope_43 := by decide +kernel +theorem children_work_43 : ∀ j, Template HasSnaky 1 (childrenC_43 j) (childrenD_43 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_3 7 (1, 4)).mono (by decide +kernel) +theorem row_works_43 : Template HasSnaky 2 required_43 envelope_43 := by + refine compose HasSnaky 1 childrenC_43 childrenD_43 children_work_43 (1, 4) + required_43 envelope_43 pivot_mem_43 child_required_sub_43 child_envelope_sub_43 ?_ + intro b hb + exact common_sub_43 (mem_commonEnvelope childrenD_43 b hb) +def required_51 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_51 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_51 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), (placed21 1 (0, 0) required_3)] +def childrenD_51 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), (placed21 1 (0, 0) envelope_3)] +theorem common_sub_51 : commonEnvelope childrenD_51 ⊆ insert (1, 4) required_51 := by decide +kernel +theorem child_required_sub_51 : ∀ j, childrenC_51 j ⊆ insert (1, 4) required_51 := by decide +kernel +theorem child_envelope_sub_51 : ∀ j, childrenD_51 j ⊆ envelope_51 := by decide +kernel +theorem pivot_mem_51 : (1, 4) ∈ envelope_51 := by decide +kernel +theorem children_work_51 : ∀ j, Template HasSnaky 1 (childrenC_51 j) (childrenD_51 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_3 1 (0, 0)).mono (by decide +kernel) +theorem row_works_51 : Template HasSnaky 2 required_51 envelope_51 := by + refine compose HasSnaky 1 childrenC_51 childrenD_51 children_work_51 (1, 4) + required_51 envelope_51 pivot_mem_51 child_required_sub_51 child_envelope_sub_51 ?_ + intro b hb + exact common_sub_51 (mem_commonEnvelope childrenD_51 b hb) +def required_66 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_66 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_66 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), (placed21 3 (1, 4) required_5)] +def childrenD_66 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), (placed21 3 (1, 4) envelope_5)] +theorem common_sub_66 : commonEnvelope childrenD_66 ⊆ insert (1, 4) required_66 := by decide +kernel +theorem child_required_sub_66 : ∀ j, childrenC_66 j ⊆ insert (1, 4) required_66 := by decide +kernel +theorem child_envelope_sub_66 : ∀ j, childrenD_66 j ⊆ envelope_66 := by decide +kernel +theorem pivot_mem_66 : (1, 4) ∈ envelope_66 := by decide +kernel +theorem children_work_66 : ∀ j, Template HasSnaky 1 (childrenC_66 j) (childrenD_66 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) +theorem row_works_66 : Template HasSnaky 2 required_66 envelope_66 := by + refine compose HasSnaky 1 childrenC_66 childrenD_66 children_work_66 (1, 4) + required_66 envelope_66 pivot_mem_66 child_required_sub_66 child_envelope_sub_66 ?_ + intro b hb + exact common_sub_66 (mem_commonEnvelope childrenD_66 b hb) +def required_68 : Finset Cell := ⟨(([(0, 0), (0, 3), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_68 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_68 : Fin 2 → Finset Cell := ![(placed21 7 (1, 6) required_0), (placed21 1 (0, 0) required_1)] +def childrenD_68 : Fin 2 → Finset Cell := ![(placed21 7 (1, 6) envelope_0), (placed21 1 (0, 0) envelope_1)] +theorem common_sub_68 : commonEnvelope childrenD_68 ⊆ insert (0, 2) required_68 := by decide +kernel +theorem child_required_sub_68 : ∀ j, childrenC_68 j ⊆ insert (0, 2) required_68 := by decide +kernel +theorem child_envelope_sub_68 : ∀ j, childrenD_68 j ⊆ envelope_68 := by decide +kernel +theorem pivot_mem_68 : (0, 2) ∈ envelope_68 := by decide +kernel +theorem children_work_68 : ∀ j, Template HasSnaky 1 (childrenC_68 j) (childrenD_68 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_1 1 (0, 0)).mono (by decide +kernel) +theorem row_works_68 : Template HasSnaky 2 required_68 envelope_68 := by + refine compose HasSnaky 1 childrenC_68 childrenD_68 children_work_68 (0, 2) + required_68 envelope_68 pivot_mem_68 child_required_sub_68 child_envelope_sub_68 ?_ + intro b hb + exact common_sub_68 (mem_commonEnvelope childrenD_68 b hb) +def required_70 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_70 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_70 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_2), (placed21 1 (0, 0) required_3)] +def childrenD_70 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_2), (placed21 1 (0, 0) envelope_3)] +theorem common_sub_70 : commonEnvelope childrenD_70 ⊆ insert (1, 3) required_70 := by decide +kernel +theorem child_required_sub_70 : ∀ j, childrenC_70 j ⊆ insert (1, 3) required_70 := by decide +kernel +theorem child_envelope_sub_70 : ∀ j, childrenD_70 j ⊆ envelope_70 := by decide +kernel +theorem pivot_mem_70 : (1, 3) ∈ envelope_70 := by decide +kernel +theorem children_work_70 : ∀ j, Template HasSnaky 1 (childrenC_70 j) (childrenD_70 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_3 1 (0, 0)).mono (by decide +kernel) +theorem row_works_70 : Template HasSnaky 2 required_70 envelope_70 := by + refine compose HasSnaky 1 childrenC_70 childrenD_70 children_work_70 (1, 3) + required_70 envelope_70 pivot_mem_70 child_required_sub_70 child_envelope_sub_70 ?_ + intro b hb + exact common_sub_70 (mem_commonEnvelope childrenD_70 b hb) +def required_76 : Finset Cell := ⟨(([(0, 0), (1, 1), (1, 2), (1, 3), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_76 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_76 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_4), (placed21 3 (1, 4) required_5)] +def childrenD_76 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_4), (placed21 3 (1, 4) envelope_5)] +theorem common_sub_76 : commonEnvelope childrenD_76 ⊆ insert (1, 4) required_76 := by decide +kernel +theorem child_required_sub_76 : ∀ j, childrenC_76 j ⊆ insert (1, 4) required_76 := by decide +kernel +theorem child_envelope_sub_76 : ∀ j, childrenD_76 j ⊆ envelope_76 := by decide +kernel +theorem pivot_mem_76 : (1, 4) ∈ envelope_76 := by decide +kernel +theorem children_work_76 : ∀ j, Template HasSnaky 1 (childrenC_76 j) (childrenD_76 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) +theorem row_works_76 : Template HasSnaky 2 required_76 envelope_76 := by + refine compose HasSnaky 1 childrenC_76 childrenD_76 children_work_76 (1, 4) + required_76 envelope_76 pivot_mem_76 child_required_sub_76 child_envelope_sub_76 ?_ + intro b hb + exact common_sub_76 (mem_commonEnvelope childrenD_76 b hb) +def required_77 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_77 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (3, 1), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_77 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_3), (placed21 3 (1, 4) required_5)] +def childrenD_77 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_3), (placed21 3 (1, 4) envelope_5)] +theorem common_sub_77 : commonEnvelope childrenD_77 ⊆ insert (2, 1) required_77 := by decide +kernel +theorem child_required_sub_77 : ∀ j, childrenC_77 j ⊆ insert (2, 1) required_77 := by decide +kernel +theorem child_envelope_sub_77 : ∀ j, childrenD_77 j ⊆ envelope_77 := by decide +kernel +theorem pivot_mem_77 : (2, 1) ∈ envelope_77 := by decide +kernel +theorem children_work_77 : ∀ j, Template HasSnaky 1 (childrenC_77 j) (childrenD_77 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) +theorem row_works_77 : Template HasSnaky 2 required_77 envelope_77 := by + refine compose HasSnaky 1 childrenC_77 childrenD_77 children_work_77 (2, 1) + required_77 envelope_77 pivot_mem_77 child_required_sub_77 child_envelope_sub_77 ?_ + intro b hb + exact common_sub_77 (mem_commonEnvelope childrenD_77 b hb) +def required_80 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 4), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_80 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_80 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 7 (1, 4) required_5)] +def childrenD_80 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 7 (1, 4) envelope_5)] +theorem common_sub_80 : commonEnvelope childrenD_80 ⊆ insert (1, 3) required_80 := by decide +kernel +theorem child_required_sub_80 : ∀ j, childrenC_80 j ⊆ insert (1, 3) required_80 := by decide +kernel +theorem child_envelope_sub_80 : ∀ j, childrenD_80 j ⊆ envelope_80 := by decide +kernel +theorem pivot_mem_80 : (1, 3) ∈ envelope_80 := by decide +kernel +theorem children_work_80 : ∀ j, Template HasSnaky 1 (childrenC_80 j) (childrenD_80 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) +theorem row_works_80 : Template HasSnaky 2 required_80 envelope_80 := by + refine compose HasSnaky 1 childrenC_80 childrenD_80 children_work_80 (1, 3) + required_80 envelope_80 pivot_mem_80 child_required_sub_80 child_envelope_sub_80 ?_ + intro b hb + exact common_sub_80 (mem_commonEnvelope childrenD_80 b hb) +def required_83 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_83 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_83 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 7 (1, 4) required_5)] +def childrenD_83 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 7 (1, 4) envelope_5)] +theorem common_sub_83 : commonEnvelope childrenD_83 ⊆ insert (1, 4) required_83 := by decide +kernel +theorem child_required_sub_83 : ∀ j, childrenC_83 j ⊆ insert (1, 4) required_83 := by decide +kernel +theorem child_envelope_sub_83 : ∀ j, childrenD_83 j ⊆ envelope_83 := by decide +kernel +theorem pivot_mem_83 : (1, 4) ∈ envelope_83 := by decide +kernel +theorem children_work_83 : ∀ j, Template HasSnaky 1 (childrenC_83 j) (childrenD_83 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) +theorem row_works_83 : Template HasSnaky 2 required_83 envelope_83 := by + refine compose HasSnaky 1 childrenC_83 childrenD_83 children_work_83 (1, 4) + required_83 envelope_83 pivot_mem_83 child_required_sub_83 child_envelope_sub_83 ?_ + intro b hb + exact common_sub_83 (mem_commonEnvelope childrenD_83 b hb) +def required_94 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_94 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_94 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_0), (placed21 1 (0, 0) required_5)] +def childrenD_94 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_0), (placed21 1 (0, 0) envelope_5)] +theorem common_sub_94 : commonEnvelope childrenD_94 ⊆ insert (0, 3) required_94 := by decide +kernel +theorem child_required_sub_94 : ∀ j, childrenC_94 j ⊆ insert (0, 3) required_94 := by decide +kernel +theorem child_envelope_sub_94 : ∀ j, childrenD_94 j ⊆ envelope_94 := by decide +kernel +theorem pivot_mem_94 : (0, 3) ∈ envelope_94 := by decide +kernel +theorem children_work_94 : ∀ j, Template HasSnaky 1 (childrenC_94 j) (childrenD_94 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 1 (0, 0)).mono (by decide +kernel) +theorem row_works_94 : Template HasSnaky 2 required_94 envelope_94 := by + refine compose HasSnaky 1 childrenC_94 childrenD_94 children_work_94 (0, 3) + required_94 envelope_94 pivot_mem_94 child_required_sub_94 child_envelope_sub_94 ?_ + intro b hb + exact common_sub_94 (mem_commonEnvelope childrenD_94 b hb) +def height_6 : ℕ := 2 +def childrenH_6 : Fin 2 → ℕ := ![height_4, height_5] +theorem height_exact_6 : height_6 = 1 + Finset.univ.sup childrenH_6 := by decide +kernel +theorem required_origin_6 : ∀ x ∈ required_6, + (∃ j, x ∈ childrenC_6 j) ∨ ∀ j, x ∈ childrenD_6 j := by decide +kernel +theorem required_exact_6 : required_6 = + ((Finset.univ.biUnion childrenC_6) ∪ commonEnvelope childrenD_6).erase (1, 4) := by + exact required_eq_combination childrenC_6 childrenD_6 (1, 4) required_6 + (by decide +kernel) child_required_sub_6 common_sub_6 required_origin_6 +theorem envelope_origin_6 : ∀ x ∈ envelope_6, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_6 j := by decide +kernel +theorem envelope_exact_6 : envelope_6 = + insert (1, 4) (Finset.univ.biUnion childrenD_6) := by + exact envelope_eq_combination childrenD_6 (1, 4) envelope_6 + pivot_mem_6 child_envelope_sub_6 envelope_origin_6 +def checked_6 : CheckedCard where + required := required_6 + envelope := envelope_6 + height := height_6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_6 +def height_11 : ℕ := 2 +def childrenH_11 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_11 : height_11 = 1 + Finset.univ.sup childrenH_11 := by decide +kernel +theorem required_origin_11 : ∀ x ∈ required_11, + (∃ j, x ∈ childrenC_11 j) ∨ ∀ j, x ∈ childrenD_11 j := by decide +kernel +theorem required_exact_11 : required_11 = + ((Finset.univ.biUnion childrenC_11) ∪ commonEnvelope childrenD_11).erase (1, 1) := by + exact required_eq_combination childrenC_11 childrenD_11 (1, 1) required_11 + (by decide +kernel) child_required_sub_11 common_sub_11 required_origin_11 +theorem envelope_origin_11 : ∀ x ∈ envelope_11, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_11 j := by decide +kernel +theorem envelope_exact_11 : envelope_11 = + insert (1, 1) (Finset.univ.biUnion childrenD_11) := by + exact envelope_eq_combination childrenD_11 (1, 1) envelope_11 + pivot_mem_11 child_envelope_sub_11 envelope_origin_11 +def checked_11 : CheckedCard where + required := required_11 + envelope := envelope_11 + height := height_11 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_11 +def height_15 : ℕ := 2 +def childrenH_15 : Fin 2 → ℕ := ![height_0, height_0] +theorem height_exact_15 : height_15 = 1 + Finset.univ.sup childrenH_15 := by decide +kernel +theorem required_origin_15 : ∀ x ∈ required_15, + (∃ j, x ∈ childrenC_15 j) ∨ ∀ j, x ∈ childrenD_15 j := by decide +kernel +theorem required_exact_15 : required_15 = + ((Finset.univ.biUnion childrenC_15) ∪ commonEnvelope childrenD_15).erase (1, 4) := by + exact required_eq_combination childrenC_15 childrenD_15 (1, 4) required_15 + (by decide +kernel) child_required_sub_15 common_sub_15 required_origin_15 +theorem envelope_origin_15 : ∀ x ∈ envelope_15, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_15 j := by decide +kernel +theorem envelope_exact_15 : envelope_15 = + insert (1, 4) (Finset.univ.biUnion childrenD_15) := by + exact envelope_eq_combination childrenD_15 (1, 4) envelope_15 + pivot_mem_15 child_envelope_sub_15 envelope_origin_15 +def checked_15 : CheckedCard where + required := required_15 + envelope := envelope_15 + height := height_15 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_15 +def height_22 : ℕ := 2 +def childrenH_22 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_22 : height_22 = 1 + Finset.univ.sup childrenH_22 := by decide +kernel +theorem required_origin_22 : ∀ x ∈ required_22, + (∃ j, x ∈ childrenC_22 j) ∨ ∀ j, x ∈ childrenD_22 j := by decide +kernel +theorem required_exact_22 : required_22 = + ((Finset.univ.biUnion childrenC_22) ∪ commonEnvelope childrenD_22).erase (0, 3) := by + exact required_eq_combination childrenC_22 childrenD_22 (0, 3) required_22 + (by decide +kernel) child_required_sub_22 common_sub_22 required_origin_22 +theorem envelope_origin_22 : ∀ x ∈ envelope_22, + x = (0, 3) ∨ ∃ j, x ∈ childrenD_22 j := by decide +kernel +theorem envelope_exact_22 : envelope_22 = + insert (0, 3) (Finset.univ.biUnion childrenD_22) := by + exact envelope_eq_combination childrenD_22 (0, 3) envelope_22 + pivot_mem_22 child_envelope_sub_22 envelope_origin_22 +def checked_22 : CheckedCard where + required := required_22 + envelope := envelope_22 + height := height_22 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_22 +def height_23 : ℕ := 2 +def childrenH_23 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_23 : height_23 = 1 + Finset.univ.sup childrenH_23 := by decide +kernel +theorem required_origin_23 : ∀ x ∈ required_23, + (∃ j, x ∈ childrenC_23 j) ∨ ∀ j, x ∈ childrenD_23 j := by decide +kernel +theorem required_exact_23 : required_23 = + ((Finset.univ.biUnion childrenC_23) ∪ commonEnvelope childrenD_23).erase (0, 4) := by + exact required_eq_combination childrenC_23 childrenD_23 (0, 4) required_23 + (by decide +kernel) child_required_sub_23 common_sub_23 required_origin_23 +theorem envelope_origin_23 : ∀ x ∈ envelope_23, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_23 j := by decide +kernel +theorem envelope_exact_23 : envelope_23 = + insert (0, 4) (Finset.univ.biUnion childrenD_23) := by + exact envelope_eq_combination childrenD_23 (0, 4) envelope_23 + pivot_mem_23 child_envelope_sub_23 envelope_origin_23 +def checked_23 : CheckedCard where + required := required_23 + envelope := envelope_23 + height := height_23 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_23 +def height_25 : ℕ := 2 +def childrenH_25 : Fin 2 → ℕ := ![height_2, height_5] +theorem height_exact_25 : height_25 = 1 + Finset.univ.sup childrenH_25 := by decide +kernel +theorem required_origin_25 : ∀ x ∈ required_25, + (∃ j, x ∈ childrenC_25 j) ∨ ∀ j, x ∈ childrenD_25 j := by decide +kernel +theorem required_exact_25 : required_25 = + ((Finset.univ.biUnion childrenC_25) ∪ commonEnvelope childrenD_25).erase (3, 0) := by + exact required_eq_combination childrenC_25 childrenD_25 (3, 0) required_25 + (by decide +kernel) child_required_sub_25 common_sub_25 required_origin_25 +theorem envelope_origin_25 : ∀ x ∈ envelope_25, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_25 j := by decide +kernel +theorem envelope_exact_25 : envelope_25 = + insert (3, 0) (Finset.univ.biUnion childrenD_25) := by + exact envelope_eq_combination childrenD_25 (3, 0) envelope_25 + pivot_mem_25 child_envelope_sub_25 envelope_origin_25 +def checked_25 : CheckedCard where + required := required_25 + envelope := envelope_25 + height := height_25 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_25 +def height_28 : ℕ := 2 +def childrenH_28 : Fin 2 → ℕ := ![height_5, height_5] +theorem height_exact_28 : height_28 = 1 + Finset.univ.sup childrenH_28 := by decide +kernel +theorem required_origin_28 : ∀ x ∈ required_28, + (∃ j, x ∈ childrenC_28 j) ∨ ∀ j, x ∈ childrenD_28 j := by decide +kernel +theorem required_exact_28 : required_28 = + ((Finset.univ.biUnion childrenC_28) ∪ commonEnvelope childrenD_28).erase (1, 2) := by + exact required_eq_combination childrenC_28 childrenD_28 (1, 2) required_28 + (by decide +kernel) child_required_sub_28 common_sub_28 required_origin_28 +theorem envelope_origin_28 : ∀ x ∈ envelope_28, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_28 j := by decide +kernel +theorem envelope_exact_28 : envelope_28 = + insert (1, 2) (Finset.univ.biUnion childrenD_28) := by + exact envelope_eq_combination childrenD_28 (1, 2) envelope_28 + pivot_mem_28 child_envelope_sub_28 envelope_origin_28 +def checked_28 : CheckedCard where + required := required_28 + envelope := envelope_28 + height := height_28 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_28 +def height_30 : ℕ := 2 +def childrenH_30 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_30 : height_30 = 1 + Finset.univ.sup childrenH_30 := by decide +kernel +theorem required_origin_30 : ∀ x ∈ required_30, + (∃ j, x ∈ childrenC_30 j) ∨ ∀ j, x ∈ childrenD_30 j := by decide +kernel +theorem required_exact_30 : required_30 = + ((Finset.univ.biUnion childrenC_30) ∪ commonEnvelope childrenD_30).erase (0, 2) := by + exact required_eq_combination childrenC_30 childrenD_30 (0, 2) required_30 + (by decide +kernel) child_required_sub_30 common_sub_30 required_origin_30 +theorem envelope_origin_30 : ∀ x ∈ envelope_30, + x = (0, 2) ∨ ∃ j, x ∈ childrenD_30 j := by decide +kernel +theorem envelope_exact_30 : envelope_30 = + insert (0, 2) (Finset.univ.biUnion childrenD_30) := by + exact envelope_eq_combination childrenD_30 (0, 2) envelope_30 + pivot_mem_30 child_envelope_sub_30 envelope_origin_30 +def checked_30 : CheckedCard where + required := required_30 + envelope := envelope_30 + height := height_30 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_30 +def height_32 : ℕ := 2 +def childrenH_32 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_32 : height_32 = 1 + Finset.univ.sup childrenH_32 := by decide +kernel +theorem required_origin_32 : ∀ x ∈ required_32, + (∃ j, x ∈ childrenC_32 j) ∨ ∀ j, x ∈ childrenD_32 j := by decide +kernel +theorem required_exact_32 : required_32 = + ((Finset.univ.biUnion childrenC_32) ∪ commonEnvelope childrenD_32).erase (3, 0) := by + exact required_eq_combination childrenC_32 childrenD_32 (3, 0) required_32 + (by decide +kernel) child_required_sub_32 common_sub_32 required_origin_32 +theorem envelope_origin_32 : ∀ x ∈ envelope_32, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_32 j := by decide +kernel +theorem envelope_exact_32 : envelope_32 = + insert (3, 0) (Finset.univ.biUnion childrenD_32) := by + exact envelope_eq_combination childrenD_32 (3, 0) envelope_32 + pivot_mem_32 child_envelope_sub_32 envelope_origin_32 +def checked_32 : CheckedCard where + required := required_32 + envelope := envelope_32 + height := height_32 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_32 +def height_34 : ℕ := 2 +def childrenH_34 : Fin 2 → ℕ := ![height_5, height_5] +theorem height_exact_34 : height_34 = 1 + Finset.univ.sup childrenH_34 := by decide +kernel +theorem required_origin_34 : ∀ x ∈ required_34, + (∃ j, x ∈ childrenC_34 j) ∨ ∀ j, x ∈ childrenD_34 j := by decide +kernel +theorem required_exact_34 : required_34 = + ((Finset.univ.biUnion childrenC_34) ∪ commonEnvelope childrenD_34).erase (0, 3) := by + exact required_eq_combination childrenC_34 childrenD_34 (0, 3) required_34 + (by decide +kernel) child_required_sub_34 common_sub_34 required_origin_34 +theorem envelope_origin_34 : ∀ x ∈ envelope_34, + x = (0, 3) ∨ ∃ j, x ∈ childrenD_34 j := by decide +kernel +theorem envelope_exact_34 : envelope_34 = + insert (0, 3) (Finset.univ.biUnion childrenD_34) := by + exact envelope_eq_combination childrenD_34 (0, 3) envelope_34 + pivot_mem_34 child_envelope_sub_34 envelope_origin_34 +def checked_34 : CheckedCard where + required := required_34 + envelope := envelope_34 + height := height_34 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_34 +def height_35 : ℕ := 2 +def childrenH_35 : Fin 2 → ℕ := ![height_1, height_5] +theorem height_exact_35 : height_35 = 1 + Finset.univ.sup childrenH_35 := by decide +kernel +theorem required_origin_35 : ∀ x ∈ required_35, + (∃ j, x ∈ childrenC_35 j) ∨ ∀ j, x ∈ childrenD_35 j := by decide +kernel +theorem required_exact_35 : required_35 = + ((Finset.univ.biUnion childrenC_35) ∪ commonEnvelope childrenD_35).erase (3, 2) := by + exact required_eq_combination childrenC_35 childrenD_35 (3, 2) required_35 + (by decide +kernel) child_required_sub_35 common_sub_35 required_origin_35 +theorem envelope_origin_35 : ∀ x ∈ envelope_35, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_35 j := by decide +kernel +theorem envelope_exact_35 : envelope_35 = + insert (3, 2) (Finset.univ.biUnion childrenD_35) := by + exact envelope_eq_combination childrenD_35 (3, 2) envelope_35 + pivot_mem_35 child_envelope_sub_35 envelope_origin_35 +def checked_35 : CheckedCard where + required := required_35 + envelope := envelope_35 + height := height_35 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_35 +def height_36 : ℕ := 2 +def childrenH_36 : Fin 2 → ℕ := ![height_2, height_2] +theorem height_exact_36 : height_36 = 1 + Finset.univ.sup childrenH_36 := by decide +kernel +theorem required_origin_36 : ∀ x ∈ required_36, + (∃ j, x ∈ childrenC_36 j) ∨ ∀ j, x ∈ childrenD_36 j := by decide +kernel +theorem required_exact_36 : required_36 = + ((Finset.univ.biUnion childrenC_36) ∪ commonEnvelope childrenD_36).erase (1, 4) := by + exact required_eq_combination childrenC_36 childrenD_36 (1, 4) required_36 + (by decide +kernel) child_required_sub_36 common_sub_36 required_origin_36 +theorem envelope_origin_36 : ∀ x ∈ envelope_36, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_36 j := by decide +kernel +theorem envelope_exact_36 : envelope_36 = + insert (1, 4) (Finset.univ.biUnion childrenD_36) := by + exact envelope_eq_combination childrenD_36 (1, 4) envelope_36 + pivot_mem_36 child_envelope_sub_36 envelope_origin_36 +def checked_36 : CheckedCard where + required := required_36 + envelope := envelope_36 + height := height_36 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_36 +def height_38 : ℕ := 2 +def childrenH_38 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_38 : height_38 = 1 + Finset.univ.sup childrenH_38 := by decide +kernel +theorem required_origin_38 : ∀ x ∈ required_38, + (∃ j, x ∈ childrenC_38 j) ∨ ∀ j, x ∈ childrenD_38 j := by decide +kernel +theorem required_exact_38 : required_38 = + ((Finset.univ.biUnion childrenC_38) ∪ commonEnvelope childrenD_38).erase (3, 2) := by + exact required_eq_combination childrenC_38 childrenD_38 (3, 2) required_38 + (by decide +kernel) child_required_sub_38 common_sub_38 required_origin_38 +theorem envelope_origin_38 : ∀ x ∈ envelope_38, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_38 j := by decide +kernel +theorem envelope_exact_38 : envelope_38 = + insert (3, 2) (Finset.univ.biUnion childrenD_38) := by + exact envelope_eq_combination childrenD_38 (3, 2) envelope_38 + pivot_mem_38 child_envelope_sub_38 envelope_origin_38 +def checked_38 : CheckedCard where + required := required_38 + envelope := envelope_38 + height := height_38 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_38 +def height_40 : ℕ := 2 +def childrenH_40 : Fin 2 → ℕ := ![height_5, height_5] +theorem height_exact_40 : height_40 = 1 + Finset.univ.sup childrenH_40 := by decide +kernel +theorem required_origin_40 : ∀ x ∈ required_40, + (∃ j, x ∈ childrenC_40 j) ∨ ∀ j, x ∈ childrenD_40 j := by decide +kernel +theorem required_exact_40 : required_40 = + ((Finset.univ.biUnion childrenC_40) ∪ commonEnvelope childrenD_40).erase (1, 3) := by + exact required_eq_combination childrenC_40 childrenD_40 (1, 3) required_40 + (by decide +kernel) child_required_sub_40 common_sub_40 required_origin_40 +theorem envelope_origin_40 : ∀ x ∈ envelope_40, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_40 j := by decide +kernel +theorem envelope_exact_40 : envelope_40 = + insert (1, 3) (Finset.univ.biUnion childrenD_40) := by + exact envelope_eq_combination childrenD_40 (1, 3) envelope_40 + pivot_mem_40 child_envelope_sub_40 envelope_origin_40 +def checked_40 : CheckedCard where + required := required_40 + envelope := envelope_40 + height := height_40 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_40 +def height_43 : ℕ := 2 +def childrenH_43 : Fin 2 → ℕ := ![height_0, height_3] +theorem height_exact_43 : height_43 = 1 + Finset.univ.sup childrenH_43 := by decide +kernel +theorem required_origin_43 : ∀ x ∈ required_43, + (∃ j, x ∈ childrenC_43 j) ∨ ∀ j, x ∈ childrenD_43 j := by decide +kernel +theorem required_exact_43 : required_43 = + ((Finset.univ.biUnion childrenC_43) ∪ commonEnvelope childrenD_43).erase (1, 4) := by + exact required_eq_combination childrenC_43 childrenD_43 (1, 4) required_43 + (by decide +kernel) child_required_sub_43 common_sub_43 required_origin_43 +theorem envelope_origin_43 : ∀ x ∈ envelope_43, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_43 j := by decide +kernel +theorem envelope_exact_43 : envelope_43 = + insert (1, 4) (Finset.univ.biUnion childrenD_43) := by + exact envelope_eq_combination childrenD_43 (1, 4) envelope_43 + pivot_mem_43 child_envelope_sub_43 envelope_origin_43 +def checked_43 : CheckedCard where + required := required_43 + envelope := envelope_43 + height := height_43 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_43 +def height_51 : ℕ := 2 +def childrenH_51 : Fin 2 → ℕ := ![height_0, height_3] +theorem height_exact_51 : height_51 = 1 + Finset.univ.sup childrenH_51 := by decide +kernel +theorem required_origin_51 : ∀ x ∈ required_51, + (∃ j, x ∈ childrenC_51 j) ∨ ∀ j, x ∈ childrenD_51 j := by decide +kernel +theorem required_exact_51 : required_51 = + ((Finset.univ.biUnion childrenC_51) ∪ commonEnvelope childrenD_51).erase (1, 4) := by + exact required_eq_combination childrenC_51 childrenD_51 (1, 4) required_51 + (by decide +kernel) child_required_sub_51 common_sub_51 required_origin_51 +theorem envelope_origin_51 : ∀ x ∈ envelope_51, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_51 j := by decide +kernel +theorem envelope_exact_51 : envelope_51 = + insert (1, 4) (Finset.univ.biUnion childrenD_51) := by + exact envelope_eq_combination childrenD_51 (1, 4) envelope_51 + pivot_mem_51 child_envelope_sub_51 envelope_origin_51 +def checked_51 : CheckedCard where + required := required_51 + envelope := envelope_51 + height := height_51 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_51 +def height_66 : ℕ := 2 +def childrenH_66 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_66 : height_66 = 1 + Finset.univ.sup childrenH_66 := by decide +kernel +theorem required_origin_66 : ∀ x ∈ required_66, + (∃ j, x ∈ childrenC_66 j) ∨ ∀ j, x ∈ childrenD_66 j := by decide +kernel +theorem required_exact_66 : required_66 = + ((Finset.univ.biUnion childrenC_66) ∪ commonEnvelope childrenD_66).erase (1, 4) := by + exact required_eq_combination childrenC_66 childrenD_66 (1, 4) required_66 + (by decide +kernel) child_required_sub_66 common_sub_66 required_origin_66 +theorem envelope_origin_66 : ∀ x ∈ envelope_66, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_66 j := by decide +kernel +theorem envelope_exact_66 : envelope_66 = + insert (1, 4) (Finset.univ.biUnion childrenD_66) := by + exact envelope_eq_combination childrenD_66 (1, 4) envelope_66 + pivot_mem_66 child_envelope_sub_66 envelope_origin_66 +def checked_66 : CheckedCard where + required := required_66 + envelope := envelope_66 + height := height_66 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_66 +def height_68 : ℕ := 2 +def childrenH_68 : Fin 2 → ℕ := ![height_0, height_1] +theorem height_exact_68 : height_68 = 1 + Finset.univ.sup childrenH_68 := by decide +kernel +theorem required_origin_68 : ∀ x ∈ required_68, + (∃ j, x ∈ childrenC_68 j) ∨ ∀ j, x ∈ childrenD_68 j := by decide +kernel +theorem required_exact_68 : required_68 = + ((Finset.univ.biUnion childrenC_68) ∪ commonEnvelope childrenD_68).erase (0, 2) := by + exact required_eq_combination childrenC_68 childrenD_68 (0, 2) required_68 + (by decide +kernel) child_required_sub_68 common_sub_68 required_origin_68 +theorem envelope_origin_68 : ∀ x ∈ envelope_68, + x = (0, 2) ∨ ∃ j, x ∈ childrenD_68 j := by decide +kernel +theorem envelope_exact_68 : envelope_68 = + insert (0, 2) (Finset.univ.biUnion childrenD_68) := by + exact envelope_eq_combination childrenD_68 (0, 2) envelope_68 + pivot_mem_68 child_envelope_sub_68 envelope_origin_68 +def checked_68 : CheckedCard where + required := required_68 + envelope := envelope_68 + height := height_68 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_68 +def height_70 : ℕ := 2 +def childrenH_70 : Fin 2 → ℕ := ![height_2, height_3] +theorem height_exact_70 : height_70 = 1 + Finset.univ.sup childrenH_70 := by decide +kernel +theorem required_origin_70 : ∀ x ∈ required_70, + (∃ j, x ∈ childrenC_70 j) ∨ ∀ j, x ∈ childrenD_70 j := by decide +kernel +theorem required_exact_70 : required_70 = + ((Finset.univ.biUnion childrenC_70) ∪ commonEnvelope childrenD_70).erase (1, 3) := by + exact required_eq_combination childrenC_70 childrenD_70 (1, 3) required_70 + (by decide +kernel) child_required_sub_70 common_sub_70 required_origin_70 +theorem envelope_origin_70 : ∀ x ∈ envelope_70, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_70 j := by decide +kernel +theorem envelope_exact_70 : envelope_70 = + insert (1, 3) (Finset.univ.biUnion childrenD_70) := by + exact envelope_eq_combination childrenD_70 (1, 3) envelope_70 + pivot_mem_70 child_envelope_sub_70 envelope_origin_70 +def checked_70 : CheckedCard where + required := required_70 + envelope := envelope_70 + height := height_70 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_70 +def height_76 : ℕ := 2 +def childrenH_76 : Fin 2 → ℕ := ![height_4, height_5] +theorem height_exact_76 : height_76 = 1 + Finset.univ.sup childrenH_76 := by decide +kernel +theorem required_origin_76 : ∀ x ∈ required_76, + (∃ j, x ∈ childrenC_76 j) ∨ ∀ j, x ∈ childrenD_76 j := by decide +kernel +theorem required_exact_76 : required_76 = + ((Finset.univ.biUnion childrenC_76) ∪ commonEnvelope childrenD_76).erase (1, 4) := by + exact required_eq_combination childrenC_76 childrenD_76 (1, 4) required_76 + (by decide +kernel) child_required_sub_76 common_sub_76 required_origin_76 +theorem envelope_origin_76 : ∀ x ∈ envelope_76, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_76 j := by decide +kernel +theorem envelope_exact_76 : envelope_76 = + insert (1, 4) (Finset.univ.biUnion childrenD_76) := by + exact envelope_eq_combination childrenD_76 (1, 4) envelope_76 + pivot_mem_76 child_envelope_sub_76 envelope_origin_76 +def checked_76 : CheckedCard where + required := required_76 + envelope := envelope_76 + height := height_76 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_76 +def height_77 : ℕ := 2 +def childrenH_77 : Fin 2 → ℕ := ![height_3, height_5] +theorem height_exact_77 : height_77 = 1 + Finset.univ.sup childrenH_77 := by decide +kernel +theorem required_origin_77 : ∀ x ∈ required_77, + (∃ j, x ∈ childrenC_77 j) ∨ ∀ j, x ∈ childrenD_77 j := by decide +kernel +theorem required_exact_77 : required_77 = + ((Finset.univ.biUnion childrenC_77) ∪ commonEnvelope childrenD_77).erase (2, 1) := by + exact required_eq_combination childrenC_77 childrenD_77 (2, 1) required_77 + (by decide +kernel) child_required_sub_77 common_sub_77 required_origin_77 +theorem envelope_origin_77 : ∀ x ∈ envelope_77, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_77 j := by decide +kernel +theorem envelope_exact_77 : envelope_77 = + insert (2, 1) (Finset.univ.biUnion childrenD_77) := by + exact envelope_eq_combination childrenD_77 (2, 1) envelope_77 + pivot_mem_77 child_envelope_sub_77 envelope_origin_77 +def checked_77 : CheckedCard where + required := required_77 + envelope := envelope_77 + height := height_77 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_77 +def height_80 : ℕ := 2 +def childrenH_80 : Fin 2 → ℕ := ![height_5, height_5] +theorem height_exact_80 : height_80 = 1 + Finset.univ.sup childrenH_80 := by decide +kernel +theorem required_origin_80 : ∀ x ∈ required_80, + (∃ j, x ∈ childrenC_80 j) ∨ ∀ j, x ∈ childrenD_80 j := by decide +kernel +theorem required_exact_80 : required_80 = + ((Finset.univ.biUnion childrenC_80) ∪ commonEnvelope childrenD_80).erase (1, 3) := by + exact required_eq_combination childrenC_80 childrenD_80 (1, 3) required_80 + (by decide +kernel) child_required_sub_80 common_sub_80 required_origin_80 +theorem envelope_origin_80 : ∀ x ∈ envelope_80, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_80 j := by decide +kernel +theorem envelope_exact_80 : envelope_80 = + insert (1, 3) (Finset.univ.biUnion childrenD_80) := by + exact envelope_eq_combination childrenD_80 (1, 3) envelope_80 + pivot_mem_80 child_envelope_sub_80 envelope_origin_80 +def checked_80 : CheckedCard where + required := required_80 + envelope := envelope_80 + height := height_80 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_80 +def height_83 : ℕ := 2 +def childrenH_83 : Fin 2 → ℕ := ![height_5, height_5] +theorem height_exact_83 : height_83 = 1 + Finset.univ.sup childrenH_83 := by decide +kernel +theorem required_origin_83 : ∀ x ∈ required_83, + (∃ j, x ∈ childrenC_83 j) ∨ ∀ j, x ∈ childrenD_83 j := by decide +kernel +theorem required_exact_83 : required_83 = + ((Finset.univ.biUnion childrenC_83) ∪ commonEnvelope childrenD_83).erase (1, 4) := by + exact required_eq_combination childrenC_83 childrenD_83 (1, 4) required_83 + (by decide +kernel) child_required_sub_83 common_sub_83 required_origin_83 +theorem envelope_origin_83 : ∀ x ∈ envelope_83, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_83 j := by decide +kernel +theorem envelope_exact_83 : envelope_83 = + insert (1, 4) (Finset.univ.biUnion childrenD_83) := by + exact envelope_eq_combination childrenD_83 (1, 4) envelope_83 + pivot_mem_83 child_envelope_sub_83 envelope_origin_83 +def checked_83 : CheckedCard where + required := required_83 + envelope := envelope_83 + height := height_83 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_83 +def height_94 : ℕ := 2 +def childrenH_94 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_94 : height_94 = 1 + Finset.univ.sup childrenH_94 := by decide +kernel +theorem required_origin_94 : ∀ x ∈ required_94, + (∃ j, x ∈ childrenC_94 j) ∨ ∀ j, x ∈ childrenD_94 j := by decide +kernel +theorem required_exact_94 : required_94 = + ((Finset.univ.biUnion childrenC_94) ∪ commonEnvelope childrenD_94).erase (0, 3) := by + exact required_eq_combination childrenC_94 childrenD_94 (0, 3) required_94 + (by decide +kernel) child_required_sub_94 common_sub_94 required_origin_94 +theorem envelope_origin_94 : ∀ x ∈ envelope_94, + x = (0, 3) ∨ ∃ j, x ∈ childrenD_94 j := by decide +kernel +theorem envelope_exact_94 : envelope_94 = + insert (0, 3) (Finset.univ.biUnion childrenD_94) := by + exact envelope_eq_combination childrenD_94 (0, 3) envelope_94 + pivot_mem_94 child_envelope_sub_94 envelope_origin_94 +def checked_94 : CheckedCard where + required := required_94 + envelope := envelope_94 + height := height_94 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_94 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part02.lean new file mode 100644 index 0000000..da608f2 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part02.lean @@ -0,0 +1,749 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_96 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_96 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_96 : Fin 2 → Finset Cell := ![(placed21 5 (3, 0) required_4), (placed21 4 (0, 1) required_5)] +def childrenD_96 : Fin 2 → Finset Cell := ![(placed21 5 (3, 0) envelope_4), (placed21 4 (0, 1) envelope_5)] +theorem common_sub_96 : commonEnvelope childrenD_96 ⊆ insert (3, 0) required_96 := by decide +kernel +theorem child_required_sub_96 : ∀ j, childrenC_96 j ⊆ insert (3, 0) required_96 := by decide +kernel +theorem child_envelope_sub_96 : ∀ j, childrenD_96 j ⊆ envelope_96 := by decide +kernel +theorem pivot_mem_96 : (3, 0) ∈ envelope_96 := by decide +kernel +theorem children_work_96 : ∀ j, Template HasSnaky 1 (childrenC_96 j) (childrenD_96 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 5 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) +theorem row_works_96 : Template HasSnaky 2 required_96 envelope_96 := by + refine compose HasSnaky 1 childrenC_96 childrenD_96 children_work_96 (3, 0) + required_96 envelope_96 pivot_mem_96 child_required_sub_96 child_envelope_sub_96 ?_ + intro b hb + exact common_sub_96 (mem_commonEnvelope childrenD_96 b hb) +def required_102 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 4), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_102 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_102 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), (placed21 3 (1, 4) required_5)] +def childrenD_102 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), (placed21 3 (1, 4) envelope_5)] +theorem common_sub_102 : commonEnvelope childrenD_102 ⊆ insert (1, 3) required_102 := by decide +kernel +theorem child_required_sub_102 : ∀ j, childrenC_102 j ⊆ insert (1, 3) required_102 := by decide +kernel +theorem child_envelope_sub_102 : ∀ j, childrenD_102 j ⊆ envelope_102 := by decide +kernel +theorem pivot_mem_102 : (1, 3) ∈ envelope_102 := by decide +kernel +theorem children_work_102 : ∀ j, Template HasSnaky 1 (childrenC_102 j) (childrenD_102 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) +theorem row_works_102 : Template HasSnaky 2 required_102 envelope_102 := by + refine compose HasSnaky 1 childrenC_102 childrenD_102 children_work_102 (1, 3) + required_102 envelope_102 pivot_mem_102 child_required_sub_102 child_envelope_sub_102 ?_ + intro b hb + exact common_sub_102 (mem_commonEnvelope childrenD_102 b hb) +def required_121 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (2, 4), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_121 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (4, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_121 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) required_1), (placed21 4 (0, 1) required_5)] +def childrenD_121 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) envelope_1), (placed21 4 (0, 1) envelope_5)] +theorem common_sub_121 : commonEnvelope childrenD_121 ⊆ insert (3, 0) required_121 := by decide +kernel +theorem child_required_sub_121 : ∀ j, childrenC_121 j ⊆ insert (3, 0) required_121 := by decide +kernel +theorem child_envelope_sub_121 : ∀ j, childrenD_121 j ⊆ envelope_121 := by decide +kernel +theorem pivot_mem_121 : (3, 0) ∈ envelope_121 := by decide +kernel +theorem children_work_121 : ∀ j, Template HasSnaky 1 (childrenC_121 j) (childrenD_121 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 3 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) +theorem row_works_121 : Template HasSnaky 2 required_121 envelope_121 := by + refine compose HasSnaky 1 childrenC_121 childrenD_121 children_work_121 (3, 0) + required_121 envelope_121 pivot_mem_121 child_required_sub_121 child_envelope_sub_121 ?_ + intro b hb + exact common_sub_121 (mem_commonEnvelope childrenD_121 b hb) +def required_123 : Finset Cell := ⟨(([(0, 0), (0, 2), (1, 1), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_123 : Finset Cell := ⟨(([(0, 0), (0, 2), (1, 0), (1, 1), (1, 2), (2, 1), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_123 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_4), (placed21 6 (4, 1) required_4)] +def childrenD_123 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_4), (placed21 6 (4, 1) envelope_4)] +theorem common_sub_123 : commonEnvelope childrenD_123 ⊆ insert (4, 1) required_123 := by decide +kernel +theorem child_required_sub_123 : ∀ j, childrenC_123 j ⊆ insert (4, 1) required_123 := by decide +kernel +theorem child_envelope_sub_123 : ∀ j, childrenD_123 j ⊆ envelope_123 := by decide +kernel +theorem pivot_mem_123 : (4, 1) ∈ envelope_123 := by decide +kernel +theorem children_work_123 : ∀ j, Template HasSnaky 1 (childrenC_123 j) (childrenD_123 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_4 6 (4, 1)).mono (by decide +kernel) +theorem row_works_123 : Template HasSnaky 2 required_123 envelope_123 := by + refine compose HasSnaky 1 childrenC_123 childrenD_123 children_work_123 (4, 1) + required_123 envelope_123 pivot_mem_123 child_required_sub_123 child_envelope_sub_123 ?_ + intro b hb + exact common_sub_123 (mem_commonEnvelope childrenD_123 b hb) +def required_129 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_129 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_129 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), (placed21 7 (1, 4) required_3)] +def childrenD_129 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), (placed21 7 (1, 4) envelope_3)] +theorem common_sub_129 : commonEnvelope childrenD_129 ⊆ insert (1, 2) required_129 := by decide +kernel +theorem child_required_sub_129 : ∀ j, childrenC_129 j ⊆ insert (1, 2) required_129 := by decide +kernel +theorem child_envelope_sub_129 : ∀ j, childrenD_129 j ⊆ envelope_129 := by decide +kernel +theorem pivot_mem_129 : (1, 2) ∈ envelope_129 := by decide +kernel +theorem children_work_129 : ∀ j, Template HasSnaky 1 (childrenC_129 j) (childrenD_129 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_3 7 (1, 4)).mono (by decide +kernel) +theorem row_works_129 : Template HasSnaky 2 required_129 envelope_129 := by + refine compose HasSnaky 1 childrenC_129 childrenD_129 children_work_129 (1, 2) + required_129 envelope_129 pivot_mem_129 child_required_sub_129 child_envelope_sub_129 ?_ + intro b hb + exact common_sub_129 (mem_commonEnvelope childrenD_129 b hb) +def required_138 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_138 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_138 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_3), (placed21 7 (1, 4) required_3)] +def childrenD_138 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_3), (placed21 7 (1, 4) envelope_3)] +theorem common_sub_138 : commonEnvelope childrenD_138 ⊆ insert (1, 4) required_138 := by decide +kernel +theorem child_required_sub_138 : ∀ j, childrenC_138 j ⊆ insert (1, 4) required_138 := by decide +kernel +theorem child_envelope_sub_138 : ∀ j, childrenD_138 j ⊆ envelope_138 := by decide +kernel +theorem pivot_mem_138 : (1, 4) ∈ envelope_138 := by decide +kernel +theorem children_work_138 : ∀ j, Template HasSnaky 1 (childrenC_138 j) (childrenD_138 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_3 7 (1, 4)).mono (by decide +kernel) +theorem row_works_138 : Template HasSnaky 2 required_138 envelope_138 := by + refine compose HasSnaky 1 childrenC_138 childrenD_138 children_work_138 (1, 4) + required_138 envelope_138 pivot_mem_138 child_required_sub_138 child_envelope_sub_138 ?_ + intro b hb + exact common_sub_138 (mem_commonEnvelope childrenD_138 b hb) +def required_146 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_146 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (3, 1), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_146 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), (placed21 3 (1, 4) required_5)] +def childrenD_146 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), (placed21 3 (1, 4) envelope_5)] +theorem common_sub_146 : commonEnvelope childrenD_146 ⊆ insert (2, 1) required_146 := by decide +kernel +theorem child_required_sub_146 : ∀ j, childrenC_146 j ⊆ insert (2, 1) required_146 := by decide +kernel +theorem child_envelope_sub_146 : ∀ j, childrenD_146 j ⊆ envelope_146 := by decide +kernel +theorem pivot_mem_146 : (2, 1) ∈ envelope_146 := by decide +kernel +theorem children_work_146 : ∀ j, Template HasSnaky 1 (childrenC_146 j) (childrenD_146 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) +theorem row_works_146 : Template HasSnaky 2 required_146 envelope_146 := by + refine compose HasSnaky 1 childrenC_146 childrenD_146 children_work_146 (2, 1) + required_146 envelope_146 pivot_mem_146 child_required_sub_146 child_envelope_sub_146 ?_ + intro b hb + exact common_sub_146 (mem_commonEnvelope childrenD_146 b hb) +def required_153 : Finset Cell := ⟨(([(0, 0), (1, 1), (1, 2), (1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_153 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_153 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_4), (placed21 2 (4, 3) required_5)] +def childrenD_153 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_4), (placed21 2 (4, 3) envelope_5)] +theorem common_sub_153 : commonEnvelope childrenD_153 ⊆ insert (1, 4) required_153 := by decide +kernel +theorem child_required_sub_153 : ∀ j, childrenC_153 j ⊆ insert (1, 4) required_153 := by decide +kernel +theorem child_envelope_sub_153 : ∀ j, childrenD_153 j ⊆ envelope_153 := by decide +kernel +theorem pivot_mem_153 : (1, 4) ∈ envelope_153 := by decide +kernel +theorem children_work_153 : ∀ j, Template HasSnaky 1 (childrenC_153 j) (childrenD_153 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 2 (4, 3)).mono (by decide +kernel) +theorem row_works_153 : Template HasSnaky 2 required_153 envelope_153 := by + refine compose HasSnaky 1 childrenC_153 childrenD_153 children_work_153 (1, 4) + required_153 envelope_153 pivot_mem_153 child_required_sub_153 child_envelope_sub_153 ?_ + intro b hb + exact common_sub_153 (mem_commonEnvelope childrenD_153 b hb) +def required_154 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 2), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_154 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_154 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), (placed21 7 (1, 4) required_3)] +def childrenD_154 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), (placed21 7 (1, 4) envelope_3)] +theorem common_sub_154 : commonEnvelope childrenD_154 ⊆ insert (1, 3) required_154 := by decide +kernel +theorem child_required_sub_154 : ∀ j, childrenC_154 j ⊆ insert (1, 3) required_154 := by decide +kernel +theorem child_envelope_sub_154 : ∀ j, childrenD_154 j ⊆ envelope_154 := by decide +kernel +theorem pivot_mem_154 : (1, 3) ∈ envelope_154 := by decide +kernel +theorem children_work_154 : ∀ j, Template HasSnaky 1 (childrenC_154 j) (childrenD_154 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_3 7 (1, 4)).mono (by decide +kernel) +theorem row_works_154 : Template HasSnaky 2 required_154 envelope_154 := by + refine compose HasSnaky 1 childrenC_154 childrenD_154 children_work_154 (1, 3) + required_154 envelope_154 pivot_mem_154 child_required_sub_154 child_envelope_sub_154 ?_ + intro b hb + exact common_sub_154 (mem_commonEnvelope childrenD_154 b hb) +def required_156 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (3, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_156 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (4, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_156 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) required_2), (placed21 4 (0, 1) required_5)] +def childrenD_156 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) envelope_2), (placed21 4 (0, 1) envelope_5)] +theorem common_sub_156 : commonEnvelope childrenD_156 ⊆ insert (3, 1) required_156 := by decide +kernel +theorem child_required_sub_156 : ∀ j, childrenC_156 j ⊆ insert (3, 1) required_156 := by decide +kernel +theorem child_envelope_sub_156 : ∀ j, childrenD_156 j ⊆ envelope_156 := by decide +kernel +theorem pivot_mem_156 : (3, 1) ∈ envelope_156 := by decide +kernel +theorem children_work_156 : ∀ j, Template HasSnaky 1 (childrenC_156 j) (childrenD_156 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 3 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) +theorem row_works_156 : Template HasSnaky 2 required_156 envelope_156 := by + refine compose HasSnaky 1 childrenC_156 childrenD_156 children_work_156 (3, 1) + required_156 envelope_156 pivot_mem_156 child_required_sub_156 child_envelope_sub_156 ?_ + intro b hb + exact common_sub_156 (mem_commonEnvelope childrenD_156 b hb) +def required_169 : Finset Cell := ⟨(([(0, 0), (0, 2), (0, 3), (1, 3), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_169 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_169 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_1), (placed21 7 (1, 6) required_1)] +def childrenD_169 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_1), (placed21 7 (1, 6) envelope_1)] +theorem common_sub_169 : commonEnvelope childrenD_169 ⊆ insert (1, 4) required_169 := by decide +kernel +theorem child_required_sub_169 : ∀ j, childrenC_169 j ⊆ insert (1, 4) required_169 := by decide +kernel +theorem child_envelope_sub_169 : ∀ j, childrenD_169 j ⊆ envelope_169 := by decide +kernel +theorem pivot_mem_169 : (1, 4) ∈ envelope_169 := by decide +kernel +theorem children_work_169 : ∀ j, Template HasSnaky 1 (childrenC_169 j) (childrenD_169 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_1 7 (1, 6)).mono (by decide +kernel) +theorem row_works_169 : Template HasSnaky 2 required_169 envelope_169 := by + refine compose HasSnaky 1 childrenC_169 childrenD_169 children_work_169 (1, 4) + required_169 envelope_169 pivot_mem_169 child_required_sub_169 child_envelope_sub_169 ?_ + intro b hb + exact common_sub_169 (mem_commonEnvelope childrenD_169 b hb) +def required_170 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (1, 3), (1, 4), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_170 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_170 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_2), (placed21 7 (1, 4) required_3)] +def childrenD_170 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_2), (placed21 7 (1, 4) envelope_3)] +theorem common_sub_170 : commonEnvelope childrenD_170 ⊆ insert (1, 2) required_170 := by decide +kernel +theorem child_required_sub_170 : ∀ j, childrenC_170 j ⊆ insert (1, 2) required_170 := by decide +kernel +theorem child_envelope_sub_170 : ∀ j, childrenD_170 j ⊆ envelope_170 := by decide +kernel +theorem pivot_mem_170 : (1, 2) ∈ envelope_170 := by decide +kernel +theorem children_work_170 : ∀ j, Template HasSnaky 1 (childrenC_170 j) (childrenD_170 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_3 7 (1, 4)).mono (by decide +kernel) +theorem row_works_170 : Template HasSnaky 2 required_170 envelope_170 := by + refine compose HasSnaky 1 childrenC_170 childrenD_170 children_work_170 (1, 2) + required_170 envelope_170 pivot_mem_170 child_required_sub_170 child_envelope_sub_170 ?_ + intro b hb + exact common_sub_170 (mem_commonEnvelope childrenD_170 b hb) +def required_200 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 2), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_200 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_200 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_3), (placed21 7 (1, 4) required_3)] +def childrenD_200 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_3), (placed21 7 (1, 4) envelope_3)] +theorem common_sub_200 : commonEnvelope childrenD_200 ⊆ insert (1, 3) required_200 := by decide +kernel +theorem child_required_sub_200 : ∀ j, childrenC_200 j ⊆ insert (1, 3) required_200 := by decide +kernel +theorem child_envelope_sub_200 : ∀ j, childrenD_200 j ⊆ envelope_200 := by decide +kernel +theorem pivot_mem_200 : (1, 3) ∈ envelope_200 := by decide +kernel +theorem children_work_200 : ∀ j, Template HasSnaky 1 (childrenC_200 j) (childrenD_200 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_3 7 (1, 4)).mono (by decide +kernel) +theorem row_works_200 : Template HasSnaky 2 required_200 envelope_200 := by + refine compose HasSnaky 1 childrenC_200 childrenD_200 children_work_200 (1, 3) + required_200 envelope_200 pivot_mem_200 child_required_sub_200 child_envelope_sub_200 ?_ + intro b hb + exact common_sub_200 (mem_commonEnvelope childrenD_200 b hb) +def required_210 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 4), (2, 1), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_210 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_210 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_1), (placed21 6 (4, 1) required_4)] +def childrenD_210 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_1), (placed21 6 (4, 1) envelope_4)] +theorem common_sub_210 : commonEnvelope childrenD_210 ⊆ insert (0, 0) required_210 := by decide +kernel +theorem child_required_sub_210 : ∀ j, childrenC_210 j ⊆ insert (0, 0) required_210 := by decide +kernel +theorem child_envelope_sub_210 : ∀ j, childrenD_210 j ⊆ envelope_210 := by decide +kernel +theorem pivot_mem_210 : (0, 0) ∈ envelope_210 := by decide +kernel +theorem children_work_210 : ∀ j, Template HasSnaky 1 (childrenC_210 j) (childrenD_210 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_4 6 (4, 1)).mono (by decide +kernel) +theorem row_works_210 : Template HasSnaky 2 required_210 envelope_210 := by + refine compose HasSnaky 1 childrenC_210 childrenD_210 children_work_210 (0, 0) + required_210 envelope_210 pivot_mem_210 child_required_sub_210 child_envelope_sub_210 ?_ + intro b hb + exact common_sub_210 (mem_commonEnvelope childrenD_210 b hb) +def required_220 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_220 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_220 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_0), (placed21 3 (2, 4) required_5)] +def childrenD_220 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_0), (placed21 3 (2, 4) envelope_5)] +theorem common_sub_220 : commonEnvelope childrenD_220 ⊆ insert (3, 1) required_220 := by decide +kernel +theorem child_required_sub_220 : ∀ j, childrenC_220 j ⊆ insert (3, 1) required_220 := by decide +kernel +theorem child_envelope_sub_220 : ∀ j, childrenD_220 j ⊆ envelope_220 := by decide +kernel +theorem pivot_mem_220 : (3, 1) ∈ envelope_220 := by decide +kernel +theorem children_work_220 : ∀ j, Template HasSnaky 1 (childrenC_220 j) (childrenD_220 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (2, 4)).mono (by decide +kernel) +theorem row_works_220 : Template HasSnaky 2 required_220 envelope_220 := by + refine compose HasSnaky 1 childrenC_220 childrenD_220 children_work_220 (3, 1) + required_220 envelope_220 pivot_mem_220 child_required_sub_220 child_envelope_sub_220 ?_ + intro b hb + exact common_sub_220 (mem_commonEnvelope childrenD_220 b hb) +def required_224 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_224 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_224 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), (placed21 7 (3, 4) required_5)] +def childrenD_224 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), (placed21 7 (3, 4) envelope_5)] +theorem common_sub_224 : commonEnvelope childrenD_224 ⊆ insert (3, 1) required_224 := by decide +kernel +theorem child_required_sub_224 : ∀ j, childrenC_224 j ⊆ insert (3, 1) required_224 := by decide +kernel +theorem child_envelope_sub_224 : ∀ j, childrenD_224 j ⊆ envelope_224 := by decide +kernel +theorem pivot_mem_224 : (3, 1) ∈ envelope_224 := by decide +kernel +theorem children_work_224 : ∀ j, Template HasSnaky 1 (childrenC_224 j) (childrenD_224 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_5 7 (3, 4)).mono (by decide +kernel) +theorem row_works_224 : Template HasSnaky 2 required_224 envelope_224 := by + refine compose HasSnaky 1 childrenC_224 childrenD_224 children_work_224 (3, 1) + required_224 envelope_224 pivot_mem_224 child_required_sub_224 child_envelope_sub_224 ?_ + intro b hb + exact common_sub_224 (mem_commonEnvelope childrenD_224 b hb) +def required_244 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_244 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_244 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) required_5), (placed21 7 (1, 4) required_5)] +def childrenD_244 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) envelope_5), (placed21 7 (1, 4) envelope_5)] +theorem common_sub_244 : commonEnvelope childrenD_244 ⊆ insert (1, 4) required_244 := by decide +kernel +theorem child_required_sub_244 : ∀ j, childrenC_244 j ⊆ insert (1, 4) required_244 := by decide +kernel +theorem child_envelope_sub_244 : ∀ j, childrenD_244 j ⊆ envelope_244 := by decide +kernel +theorem pivot_mem_244 : (1, 4) ∈ envelope_244 := by decide +kernel +theorem children_work_244 : ∀ j, Template HasSnaky 1 (childrenC_244 j) (childrenD_244 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) +theorem row_works_244 : Template HasSnaky 2 required_244 envelope_244 := by + refine compose HasSnaky 1 childrenC_244 childrenD_244 children_work_244 (1, 4) + required_244 envelope_244 pivot_mem_244 child_required_sub_244 child_envelope_sub_244 ?_ + intro b hb + exact common_sub_244 (mem_commonEnvelope childrenD_244 b hb) +def required_281 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (1, 4), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_281 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_281 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) required_2), (placed21 1 (0, 0) required_3)] +def childrenD_281 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) envelope_2), (placed21 1 (0, 0) envelope_3)] +theorem common_sub_281 : commonEnvelope childrenD_281 ⊆ insert (1, 3) required_281 := by decide +kernel +theorem child_required_sub_281 : ∀ j, childrenC_281 j ⊆ insert (1, 3) required_281 := by decide +kernel +theorem child_envelope_sub_281 : ∀ j, childrenD_281 j ⊆ envelope_281 := by decide +kernel +theorem pivot_mem_281 : (1, 3) ∈ envelope_281 := by decide +kernel +theorem children_work_281 : ∀ j, Template HasSnaky 1 (childrenC_281 j) (childrenD_281 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 2 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_3 1 (0, 0)).mono (by decide +kernel) +theorem row_works_281 : Template HasSnaky 2 required_281 envelope_281 := by + refine compose HasSnaky 1 childrenC_281 childrenD_281 children_work_281 (1, 3) + required_281 envelope_281 pivot_mem_281 child_required_sub_281 child_envelope_sub_281 ?_ + intro b hb + exact common_sub_281 (mem_commonEnvelope childrenD_281 b hb) +def height_96 : ℕ := 2 +def childrenH_96 : Fin 2 → ℕ := ![height_4, height_5] +theorem height_exact_96 : height_96 = 1 + Finset.univ.sup childrenH_96 := by decide +kernel +theorem required_origin_96 : ∀ x ∈ required_96, + (∃ j, x ∈ childrenC_96 j) ∨ ∀ j, x ∈ childrenD_96 j := by decide +kernel +theorem required_exact_96 : required_96 = + ((Finset.univ.biUnion childrenC_96) ∪ commonEnvelope childrenD_96).erase (3, 0) := by + exact required_eq_combination childrenC_96 childrenD_96 (3, 0) required_96 + (by decide +kernel) child_required_sub_96 common_sub_96 required_origin_96 +theorem envelope_origin_96 : ∀ x ∈ envelope_96, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_96 j := by decide +kernel +theorem envelope_exact_96 : envelope_96 = + insert (3, 0) (Finset.univ.biUnion childrenD_96) := by + exact envelope_eq_combination childrenD_96 (3, 0) envelope_96 + pivot_mem_96 child_envelope_sub_96 envelope_origin_96 +def checked_96 : CheckedCard where + required := required_96 + envelope := envelope_96 + height := height_96 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_96 +def height_102 : ℕ := 2 +def childrenH_102 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_102 : height_102 = 1 + Finset.univ.sup childrenH_102 := by decide +kernel +theorem required_origin_102 : ∀ x ∈ required_102, + (∃ j, x ∈ childrenC_102 j) ∨ ∀ j, x ∈ childrenD_102 j := by decide +kernel +theorem required_exact_102 : required_102 = + ((Finset.univ.biUnion childrenC_102) ∪ commonEnvelope childrenD_102).erase (1, 3) := by + exact required_eq_combination childrenC_102 childrenD_102 (1, 3) required_102 + (by decide +kernel) child_required_sub_102 common_sub_102 required_origin_102 +theorem envelope_origin_102 : ∀ x ∈ envelope_102, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_102 j := by decide +kernel +theorem envelope_exact_102 : envelope_102 = + insert (1, 3) (Finset.univ.biUnion childrenD_102) := by + exact envelope_eq_combination childrenD_102 (1, 3) envelope_102 + pivot_mem_102 child_envelope_sub_102 envelope_origin_102 +def checked_102 : CheckedCard where + required := required_102 + envelope := envelope_102 + height := height_102 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_102 +def height_121 : ℕ := 2 +def childrenH_121 : Fin 2 → ℕ := ![height_1, height_5] +theorem height_exact_121 : height_121 = 1 + Finset.univ.sup childrenH_121 := by decide +kernel +theorem required_origin_121 : ∀ x ∈ required_121, + (∃ j, x ∈ childrenC_121 j) ∨ ∀ j, x ∈ childrenD_121 j := by decide +kernel +theorem required_exact_121 : required_121 = + ((Finset.univ.biUnion childrenC_121) ∪ commonEnvelope childrenD_121).erase (3, 0) := by + exact required_eq_combination childrenC_121 childrenD_121 (3, 0) required_121 + (by decide +kernel) child_required_sub_121 common_sub_121 required_origin_121 +theorem envelope_origin_121 : ∀ x ∈ envelope_121, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_121 j := by decide +kernel +theorem envelope_exact_121 : envelope_121 = + insert (3, 0) (Finset.univ.biUnion childrenD_121) := by + exact envelope_eq_combination childrenD_121 (3, 0) envelope_121 + pivot_mem_121 child_envelope_sub_121 envelope_origin_121 +def checked_121 : CheckedCard where + required := required_121 + envelope := envelope_121 + height := height_121 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_121 +def height_123 : ℕ := 2 +def childrenH_123 : Fin 2 → ℕ := ![height_4, height_4] +theorem height_exact_123 : height_123 = 1 + Finset.univ.sup childrenH_123 := by decide +kernel +theorem required_origin_123 : ∀ x ∈ required_123, + (∃ j, x ∈ childrenC_123 j) ∨ ∀ j, x ∈ childrenD_123 j := by decide +kernel +theorem required_exact_123 : required_123 = + ((Finset.univ.biUnion childrenC_123) ∪ commonEnvelope childrenD_123).erase (4, 1) := by + exact required_eq_combination childrenC_123 childrenD_123 (4, 1) required_123 + (by decide +kernel) child_required_sub_123 common_sub_123 required_origin_123 +theorem envelope_origin_123 : ∀ x ∈ envelope_123, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_123 j := by decide +kernel +theorem envelope_exact_123 : envelope_123 = + insert (4, 1) (Finset.univ.biUnion childrenD_123) := by + exact envelope_eq_combination childrenD_123 (4, 1) envelope_123 + pivot_mem_123 child_envelope_sub_123 envelope_origin_123 +def checked_123 : CheckedCard where + required := required_123 + envelope := envelope_123 + height := height_123 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_123 +def height_129 : ℕ := 2 +def childrenH_129 : Fin 2 → ℕ := ![height_0, height_3] +theorem height_exact_129 : height_129 = 1 + Finset.univ.sup childrenH_129 := by decide +kernel +theorem required_origin_129 : ∀ x ∈ required_129, + (∃ j, x ∈ childrenC_129 j) ∨ ∀ j, x ∈ childrenD_129 j := by decide +kernel +theorem required_exact_129 : required_129 = + ((Finset.univ.biUnion childrenC_129) ∪ commonEnvelope childrenD_129).erase (1, 2) := by + exact required_eq_combination childrenC_129 childrenD_129 (1, 2) required_129 + (by decide +kernel) child_required_sub_129 common_sub_129 required_origin_129 +theorem envelope_origin_129 : ∀ x ∈ envelope_129, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_129 j := by decide +kernel +theorem envelope_exact_129 : envelope_129 = + insert (1, 2) (Finset.univ.biUnion childrenD_129) := by + exact envelope_eq_combination childrenD_129 (1, 2) envelope_129 + pivot_mem_129 child_envelope_sub_129 envelope_origin_129 +def checked_129 : CheckedCard where + required := required_129 + envelope := envelope_129 + height := height_129 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_129 +def height_138 : ℕ := 2 +def childrenH_138 : Fin 2 → ℕ := ![height_3, height_3] +theorem height_exact_138 : height_138 = 1 + Finset.univ.sup childrenH_138 := by decide +kernel +theorem required_origin_138 : ∀ x ∈ required_138, + (∃ j, x ∈ childrenC_138 j) ∨ ∀ j, x ∈ childrenD_138 j := by decide +kernel +theorem required_exact_138 : required_138 = + ((Finset.univ.biUnion childrenC_138) ∪ commonEnvelope childrenD_138).erase (1, 4) := by + exact required_eq_combination childrenC_138 childrenD_138 (1, 4) required_138 + (by decide +kernel) child_required_sub_138 common_sub_138 required_origin_138 +theorem envelope_origin_138 : ∀ x ∈ envelope_138, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_138 j := by decide +kernel +theorem envelope_exact_138 : envelope_138 = + insert (1, 4) (Finset.univ.biUnion childrenD_138) := by + exact envelope_eq_combination childrenD_138 (1, 4) envelope_138 + pivot_mem_138 child_envelope_sub_138 envelope_origin_138 +def checked_138 : CheckedCard where + required := required_138 + envelope := envelope_138 + height := height_138 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_138 +def height_146 : ℕ := 2 +def childrenH_146 : Fin 2 → ℕ := ![height_5, height_5] +theorem height_exact_146 : height_146 = 1 + Finset.univ.sup childrenH_146 := by decide +kernel +theorem required_origin_146 : ∀ x ∈ required_146, + (∃ j, x ∈ childrenC_146 j) ∨ ∀ j, x ∈ childrenD_146 j := by decide +kernel +theorem required_exact_146 : required_146 = + ((Finset.univ.biUnion childrenC_146) ∪ commonEnvelope childrenD_146).erase (2, 1) := by + exact required_eq_combination childrenC_146 childrenD_146 (2, 1) required_146 + (by decide +kernel) child_required_sub_146 common_sub_146 required_origin_146 +theorem envelope_origin_146 : ∀ x ∈ envelope_146, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_146 j := by decide +kernel +theorem envelope_exact_146 : envelope_146 = + insert (2, 1) (Finset.univ.biUnion childrenD_146) := by + exact envelope_eq_combination childrenD_146 (2, 1) envelope_146 + pivot_mem_146 child_envelope_sub_146 envelope_origin_146 +def checked_146 : CheckedCard where + required := required_146 + envelope := envelope_146 + height := height_146 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_146 +def height_153 : ℕ := 2 +def childrenH_153 : Fin 2 → ℕ := ![height_4, height_5] +theorem height_exact_153 : height_153 = 1 + Finset.univ.sup childrenH_153 := by decide +kernel +theorem required_origin_153 : ∀ x ∈ required_153, + (∃ j, x ∈ childrenC_153 j) ∨ ∀ j, x ∈ childrenD_153 j := by decide +kernel +theorem required_exact_153 : required_153 = + ((Finset.univ.biUnion childrenC_153) ∪ commonEnvelope childrenD_153).erase (1, 4) := by + exact required_eq_combination childrenC_153 childrenD_153 (1, 4) required_153 + (by decide +kernel) child_required_sub_153 common_sub_153 required_origin_153 +theorem envelope_origin_153 : ∀ x ∈ envelope_153, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_153 j := by decide +kernel +theorem envelope_exact_153 : envelope_153 = + insert (1, 4) (Finset.univ.biUnion childrenD_153) := by + exact envelope_eq_combination childrenD_153 (1, 4) envelope_153 + pivot_mem_153 child_envelope_sub_153 envelope_origin_153 +def checked_153 : CheckedCard where + required := required_153 + envelope := envelope_153 + height := height_153 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_153 +def height_154 : ℕ := 2 +def childrenH_154 : Fin 2 → ℕ := ![height_0, height_3] +theorem height_exact_154 : height_154 = 1 + Finset.univ.sup childrenH_154 := by decide +kernel +theorem required_origin_154 : ∀ x ∈ required_154, + (∃ j, x ∈ childrenC_154 j) ∨ ∀ j, x ∈ childrenD_154 j := by decide +kernel +theorem required_exact_154 : required_154 = + ((Finset.univ.biUnion childrenC_154) ∪ commonEnvelope childrenD_154).erase (1, 3) := by + exact required_eq_combination childrenC_154 childrenD_154 (1, 3) required_154 + (by decide +kernel) child_required_sub_154 common_sub_154 required_origin_154 +theorem envelope_origin_154 : ∀ x ∈ envelope_154, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_154 j := by decide +kernel +theorem envelope_exact_154 : envelope_154 = + insert (1, 3) (Finset.univ.biUnion childrenD_154) := by + exact envelope_eq_combination childrenD_154 (1, 3) envelope_154 + pivot_mem_154 child_envelope_sub_154 envelope_origin_154 +def checked_154 : CheckedCard where + required := required_154 + envelope := envelope_154 + height := height_154 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_154 +def height_156 : ℕ := 2 +def childrenH_156 : Fin 2 → ℕ := ![height_2, height_5] +theorem height_exact_156 : height_156 = 1 + Finset.univ.sup childrenH_156 := by decide +kernel +theorem required_origin_156 : ∀ x ∈ required_156, + (∃ j, x ∈ childrenC_156 j) ∨ ∀ j, x ∈ childrenD_156 j := by decide +kernel +theorem required_exact_156 : required_156 = + ((Finset.univ.biUnion childrenC_156) ∪ commonEnvelope childrenD_156).erase (3, 1) := by + exact required_eq_combination childrenC_156 childrenD_156 (3, 1) required_156 + (by decide +kernel) child_required_sub_156 common_sub_156 required_origin_156 +theorem envelope_origin_156 : ∀ x ∈ envelope_156, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_156 j := by decide +kernel +theorem envelope_exact_156 : envelope_156 = + insert (3, 1) (Finset.univ.biUnion childrenD_156) := by + exact envelope_eq_combination childrenD_156 (3, 1) envelope_156 + pivot_mem_156 child_envelope_sub_156 envelope_origin_156 +def checked_156 : CheckedCard where + required := required_156 + envelope := envelope_156 + height := height_156 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_156 +def height_169 : ℕ := 2 +def childrenH_169 : Fin 2 → ℕ := ![height_1, height_1] +theorem height_exact_169 : height_169 = 1 + Finset.univ.sup childrenH_169 := by decide +kernel +theorem required_origin_169 : ∀ x ∈ required_169, + (∃ j, x ∈ childrenC_169 j) ∨ ∀ j, x ∈ childrenD_169 j := by decide +kernel +theorem required_exact_169 : required_169 = + ((Finset.univ.biUnion childrenC_169) ∪ commonEnvelope childrenD_169).erase (1, 4) := by + exact required_eq_combination childrenC_169 childrenD_169 (1, 4) required_169 + (by decide +kernel) child_required_sub_169 common_sub_169 required_origin_169 +theorem envelope_origin_169 : ∀ x ∈ envelope_169, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_169 j := by decide +kernel +theorem envelope_exact_169 : envelope_169 = + insert (1, 4) (Finset.univ.biUnion childrenD_169) := by + exact envelope_eq_combination childrenD_169 (1, 4) envelope_169 + pivot_mem_169 child_envelope_sub_169 envelope_origin_169 +def checked_169 : CheckedCard where + required := required_169 + envelope := envelope_169 + height := height_169 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_169 +def height_170 : ℕ := 2 +def childrenH_170 : Fin 2 → ℕ := ![height_2, height_3] +theorem height_exact_170 : height_170 = 1 + Finset.univ.sup childrenH_170 := by decide +kernel +theorem required_origin_170 : ∀ x ∈ required_170, + (∃ j, x ∈ childrenC_170 j) ∨ ∀ j, x ∈ childrenD_170 j := by decide +kernel +theorem required_exact_170 : required_170 = + ((Finset.univ.biUnion childrenC_170) ∪ commonEnvelope childrenD_170).erase (1, 2) := by + exact required_eq_combination childrenC_170 childrenD_170 (1, 2) required_170 + (by decide +kernel) child_required_sub_170 common_sub_170 required_origin_170 +theorem envelope_origin_170 : ∀ x ∈ envelope_170, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_170 j := by decide +kernel +theorem envelope_exact_170 : envelope_170 = + insert (1, 2) (Finset.univ.biUnion childrenD_170) := by + exact envelope_eq_combination childrenD_170 (1, 2) envelope_170 + pivot_mem_170 child_envelope_sub_170 envelope_origin_170 +def checked_170 : CheckedCard where + required := required_170 + envelope := envelope_170 + height := height_170 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_170 +def height_200 : ℕ := 2 +def childrenH_200 : Fin 2 → ℕ := ![height_3, height_3] +theorem height_exact_200 : height_200 = 1 + Finset.univ.sup childrenH_200 := by decide +kernel +theorem required_origin_200 : ∀ x ∈ required_200, + (∃ j, x ∈ childrenC_200 j) ∨ ∀ j, x ∈ childrenD_200 j := by decide +kernel +theorem required_exact_200 : required_200 = + ((Finset.univ.biUnion childrenC_200) ∪ commonEnvelope childrenD_200).erase (1, 3) := by + exact required_eq_combination childrenC_200 childrenD_200 (1, 3) required_200 + (by decide +kernel) child_required_sub_200 common_sub_200 required_origin_200 +theorem envelope_origin_200 : ∀ x ∈ envelope_200, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_200 j := by decide +kernel +theorem envelope_exact_200 : envelope_200 = + insert (1, 3) (Finset.univ.biUnion childrenD_200) := by + exact envelope_eq_combination childrenD_200 (1, 3) envelope_200 + pivot_mem_200 child_envelope_sub_200 envelope_origin_200 +def checked_200 : CheckedCard where + required := required_200 + envelope := envelope_200 + height := height_200 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_200 +def height_210 : ℕ := 2 +def childrenH_210 : Fin 2 → ℕ := ![height_1, height_4] +theorem height_exact_210 : height_210 = 1 + Finset.univ.sup childrenH_210 := by decide +kernel +theorem required_origin_210 : ∀ x ∈ required_210, + (∃ j, x ∈ childrenC_210 j) ∨ ∀ j, x ∈ childrenD_210 j := by decide +kernel +theorem required_exact_210 : required_210 = + ((Finset.univ.biUnion childrenC_210) ∪ commonEnvelope childrenD_210).erase (0, 0) := by + exact required_eq_combination childrenC_210 childrenD_210 (0, 0) required_210 + (by decide +kernel) child_required_sub_210 common_sub_210 required_origin_210 +theorem envelope_origin_210 : ∀ x ∈ envelope_210, + x = (0, 0) ∨ ∃ j, x ∈ childrenD_210 j := by decide +kernel +theorem envelope_exact_210 : envelope_210 = + insert (0, 0) (Finset.univ.biUnion childrenD_210) := by + exact envelope_eq_combination childrenD_210 (0, 0) envelope_210 + pivot_mem_210 child_envelope_sub_210 envelope_origin_210 +def checked_210 : CheckedCard where + required := required_210 + envelope := envelope_210 + height := height_210 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_210 +def height_220 : ℕ := 2 +def childrenH_220 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_220 : height_220 = 1 + Finset.univ.sup childrenH_220 := by decide +kernel +theorem required_origin_220 : ∀ x ∈ required_220, + (∃ j, x ∈ childrenC_220 j) ∨ ∀ j, x ∈ childrenD_220 j := by decide +kernel +theorem required_exact_220 : required_220 = + ((Finset.univ.biUnion childrenC_220) ∪ commonEnvelope childrenD_220).erase (3, 1) := by + exact required_eq_combination childrenC_220 childrenD_220 (3, 1) required_220 + (by decide +kernel) child_required_sub_220 common_sub_220 required_origin_220 +theorem envelope_origin_220 : ∀ x ∈ envelope_220, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_220 j := by decide +kernel +theorem envelope_exact_220 : envelope_220 = + insert (3, 1) (Finset.univ.biUnion childrenD_220) := by + exact envelope_eq_combination childrenD_220 (3, 1) envelope_220 + pivot_mem_220 child_envelope_sub_220 envelope_origin_220 +def checked_220 : CheckedCard where + required := required_220 + envelope := envelope_220 + height := height_220 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_220 +def height_224 : ℕ := 2 +def childrenH_224 : Fin 2 → ℕ := ![height_5, height_5] +theorem height_exact_224 : height_224 = 1 + Finset.univ.sup childrenH_224 := by decide +kernel +theorem required_origin_224 : ∀ x ∈ required_224, + (∃ j, x ∈ childrenC_224 j) ∨ ∀ j, x ∈ childrenD_224 j := by decide +kernel +theorem required_exact_224 : required_224 = + ((Finset.univ.biUnion childrenC_224) ∪ commonEnvelope childrenD_224).erase (3, 1) := by + exact required_eq_combination childrenC_224 childrenD_224 (3, 1) required_224 + (by decide +kernel) child_required_sub_224 common_sub_224 required_origin_224 +theorem envelope_origin_224 : ∀ x ∈ envelope_224, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_224 j := by decide +kernel +theorem envelope_exact_224 : envelope_224 = + insert (3, 1) (Finset.univ.biUnion childrenD_224) := by + exact envelope_eq_combination childrenD_224 (3, 1) envelope_224 + pivot_mem_224 child_envelope_sub_224 envelope_origin_224 +def checked_224 : CheckedCard where + required := required_224 + envelope := envelope_224 + height := height_224 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_224 +def height_244 : ℕ := 2 +def childrenH_244 : Fin 2 → ℕ := ![height_5, height_5] +theorem height_exact_244 : height_244 = 1 + Finset.univ.sup childrenH_244 := by decide +kernel +theorem required_origin_244 : ∀ x ∈ required_244, + (∃ j, x ∈ childrenC_244 j) ∨ ∀ j, x ∈ childrenD_244 j := by decide +kernel +theorem required_exact_244 : required_244 = + ((Finset.univ.biUnion childrenC_244) ∪ commonEnvelope childrenD_244).erase (1, 4) := by + exact required_eq_combination childrenC_244 childrenD_244 (1, 4) required_244 + (by decide +kernel) child_required_sub_244 common_sub_244 required_origin_244 +theorem envelope_origin_244 : ∀ x ∈ envelope_244, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_244 j := by decide +kernel +theorem envelope_exact_244 : envelope_244 = + insert (1, 4) (Finset.univ.biUnion childrenD_244) := by + exact envelope_eq_combination childrenD_244 (1, 4) envelope_244 + pivot_mem_244 child_envelope_sub_244 envelope_origin_244 +def checked_244 : CheckedCard where + required := required_244 + envelope := envelope_244 + height := height_244 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_244 +def height_281 : ℕ := 2 +def childrenH_281 : Fin 2 → ℕ := ![height_2, height_3] +theorem height_exact_281 : height_281 = 1 + Finset.univ.sup childrenH_281 := by decide +kernel +theorem required_origin_281 : ∀ x ∈ required_281, + (∃ j, x ∈ childrenC_281 j) ∨ ∀ j, x ∈ childrenD_281 j := by decide +kernel +theorem required_exact_281 : required_281 = + ((Finset.univ.biUnion childrenC_281) ∪ commonEnvelope childrenD_281).erase (1, 3) := by + exact required_eq_combination childrenC_281 childrenD_281 (1, 3) required_281 + (by decide +kernel) child_required_sub_281 common_sub_281 required_origin_281 +theorem envelope_origin_281 : ∀ x ∈ envelope_281, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_281 j := by decide +kernel +theorem envelope_exact_281 : envelope_281 = + insert (1, 3) (Finset.univ.biUnion childrenD_281) := by + exact envelope_eq_combination childrenD_281 (1, 3) envelope_281 + pivot_mem_281 child_envelope_sub_281 envelope_origin_281 +def checked_281 : CheckedCard where + required := required_281 + envelope := envelope_281 + height := height_281 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_281 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part01.lean new file mode 100644 index 0000000..6fae9e5 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part01.lean @@ -0,0 +1,998 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_7 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_7 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_7 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_6), (placed21 4 (0, 5) required_6)] +def childrenD_7 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_6), (placed21 4 (0, 5) envelope_6)] +theorem common_sub_7 : commonEnvelope childrenD_7 ⊆ insert (0, 5) required_7 := by decide +kernel +theorem child_required_sub_7 : ∀ j, childrenC_7 j ⊆ insert (0, 5) required_7 := by decide +kernel +theorem child_envelope_sub_7 : ∀ j, childrenD_7 j ⊆ envelope_7 := by decide +kernel +theorem pivot_mem_7 : (0, 5) ∈ envelope_7 := by decide +kernel +theorem children_work_7 : ∀ j, Template HasSnaky 2 (childrenC_7 j) (childrenD_7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_6 4 (0, 5)).mono (by decide +kernel) +theorem row_works_7 : Template HasSnaky 3 required_7 envelope_7 := by + refine compose HasSnaky 2 childrenC_7 childrenD_7 children_work_7 (0, 5) + required_7 envelope_7 pivot_mem_7 child_required_sub_7 child_envelope_sub_7 ?_ + intro b hb + exact common_sub_7 (mem_commonEnvelope childrenD_7 b hb) +def required_8 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_8 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_8 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_6), (placed21 3 (0, 1) required_6)] +def childrenD_8 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_6), (placed21 3 (0, 1) envelope_6)] +theorem common_sub_8 : commonEnvelope childrenD_8 ⊆ insert (4, 1) required_8 := by decide +kernel +theorem child_required_sub_8 : ∀ j, childrenC_8 j ⊆ insert (4, 1) required_8 := by decide +kernel +theorem child_envelope_sub_8 : ∀ j, childrenD_8 j ⊆ envelope_8 := by decide +kernel +theorem pivot_mem_8 : (4, 1) ∈ envelope_8 := by decide +kernel +theorem children_work_8 : ∀ j, Template HasSnaky 2 (childrenC_8 j) (childrenD_8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_6 3 (0, 1)).mono (by decide +kernel) +theorem row_works_8 : Template HasSnaky 3 required_8 envelope_8 := by + refine compose HasSnaky 2 childrenC_8 childrenD_8 children_work_8 (4, 1) + required_8 envelope_8 pivot_mem_8 child_required_sub_8 child_envelope_sub_8 ?_ + intro b hb + exact common_sub_8 (mem_commonEnvelope childrenD_8 b hb) +def required_9 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_9 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_9 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) required_6), (placed21 6 (1, 5) required_6)] +def childrenD_9 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) envelope_6), (placed21 6 (1, 5) envelope_6)] +theorem common_sub_9 : commonEnvelope childrenD_9 ⊆ insert (1, 5) required_9 := by decide +kernel +theorem child_required_sub_9 : ∀ j, childrenC_9 j ⊆ insert (1, 5) required_9 := by decide +kernel +theorem child_envelope_sub_9 : ∀ j, childrenD_9 j ⊆ envelope_9 := by decide +kernel +theorem pivot_mem_9 : (1, 5) ∈ envelope_9 := by decide +kernel +theorem children_work_9 : ∀ j, Template HasSnaky 2 (childrenC_9 j) (childrenD_9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_6 6 (1, 5)).mono (by decide +kernel) +theorem row_works_9 : Template HasSnaky 3 required_9 envelope_9 := by + refine compose HasSnaky 2 childrenC_9 childrenD_9 children_work_9 (1, 5) + required_9 envelope_9 pivot_mem_9 child_required_sub_9 child_envelope_sub_9 ?_ + intro b hb + exact common_sub_9 (mem_commonEnvelope childrenD_9 b hb) +def required_16 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_16 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_16 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_4), required_6] +def childrenD_16 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_4), envelope_6] +theorem common_sub_16 : commonEnvelope childrenD_16 ⊆ insert (0, 4) required_16 := by decide +kernel +theorem child_required_sub_16 : ∀ j, childrenC_16 j ⊆ insert (0, 4) required_16 := by decide +kernel +theorem child_envelope_sub_16 : ∀ j, childrenD_16 j ⊆ envelope_16 := by decide +kernel +theorem pivot_mem_16 : (0, 4) ∈ envelope_16 := by decide +kernel +theorem children_work_16 : ∀ j, Template HasSnaky 2 (childrenC_16 j) (childrenD_16 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 3 (0, 4)).mono (by decide +kernel) + · exact row_works_6.mono (by decide +kernel) +theorem row_works_16 : Template HasSnaky 3 required_16 envelope_16 := by + refine compose HasSnaky 2 childrenC_16 childrenD_16 children_work_16 (0, 4) + required_16 envelope_16 pivot_mem_16 child_required_sub_16 child_envelope_sub_16 ?_ + intro b hb + exact common_sub_16 (mem_commonEnvelope childrenD_16 b hb) +def required_20 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_20 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_20 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), (placed21 0 (1, 0) required_6)] +def childrenD_20 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), (placed21 0 (1, 0) envelope_6)] +theorem common_sub_20 : commonEnvelope childrenD_20 ⊆ insert (1, 4) required_20 := by decide +kernel +theorem child_required_sub_20 : ∀ j, childrenC_20 j ⊆ insert (1, 4) required_20 := by decide +kernel +theorem child_envelope_sub_20 : ∀ j, childrenD_20 j ⊆ envelope_20 := by decide +kernel +theorem pivot_mem_20 : (1, 4) ∈ envelope_20 := by decide +kernel +theorem children_work_20 : ∀ j, Template HasSnaky 2 (childrenC_20 j) (childrenD_20 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_6 0 (1, 0)).mono (by decide +kernel) +theorem row_works_20 : Template HasSnaky 3 required_20 envelope_20 := by + refine compose HasSnaky 2 childrenC_20 childrenD_20 children_work_20 (1, 4) + required_20 envelope_20 pivot_mem_20 child_required_sub_20 child_envelope_sub_20 ?_ + intro b hb + exact common_sub_20 (mem_commonEnvelope childrenD_20 b hb) +def required_21 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_21 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_21 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_5), required_6] +def childrenD_21 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_5), envelope_6] +theorem common_sub_21 : commonEnvelope childrenD_21 ⊆ insert (0, 4) required_21 := by decide +kernel +theorem child_required_sub_21 : ∀ j, childrenC_21 j ⊆ insert (0, 4) required_21 := by decide +kernel +theorem child_envelope_sub_21 : ∀ j, childrenD_21 j ⊆ envelope_21 := by decide +kernel +theorem pivot_mem_21 : (0, 4) ∈ envelope_21 := by decide +kernel +theorem children_work_21 : ∀ j, Template HasSnaky 2 (childrenC_21 j) (childrenD_21 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (0, 4)).mono (by decide +kernel) + · exact row_works_6.mono (by decide +kernel) +theorem row_works_21 : Template HasSnaky 3 required_21 envelope_21 := by + refine compose HasSnaky 2 childrenC_21 childrenD_21 children_work_21 (0, 4) + required_21 envelope_21 pivot_mem_21 child_required_sub_21 child_envelope_sub_21 ?_ + intro b hb + exact common_sub_21 (mem_commonEnvelope childrenD_21 b hb) +def required_24 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_24 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_24 : Fin 2 → Finset Cell := ![(placed21 6 (4, 1) required_4), (placed21 1 (0, 1) required_6)] +def childrenD_24 : Fin 2 → Finset Cell := ![(placed21 6 (4, 1) envelope_4), (placed21 1 (0, 1) envelope_6)] +theorem common_sub_24 : commonEnvelope childrenD_24 ⊆ insert (4, 1) required_24 := by decide +kernel +theorem child_required_sub_24 : ∀ j, childrenC_24 j ⊆ insert (4, 1) required_24 := by decide +kernel +theorem child_envelope_sub_24 : ∀ j, childrenD_24 j ⊆ envelope_24 := by decide +kernel +theorem pivot_mem_24 : (4, 1) ∈ envelope_24 := by decide +kernel +theorem children_work_24 : ∀ j, Template HasSnaky 2 (childrenC_24 j) (childrenD_24 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 6 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_6 1 (0, 1)).mono (by decide +kernel) +theorem row_works_24 : Template HasSnaky 3 required_24 envelope_24 := by + refine compose HasSnaky 2 childrenC_24 childrenD_24 children_work_24 (4, 1) + required_24 envelope_24 pivot_mem_24 child_required_sub_24 child_envelope_sub_24 ?_ + intro b hb + exact common_sub_24 (mem_commonEnvelope childrenD_24 b hb) +def required_29 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1), (1, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_29 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_29 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) required_0), required_6] +def childrenD_29 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) envelope_0), envelope_6] +theorem common_sub_29 : commonEnvelope childrenD_29 ⊆ insert (0, 4) required_29 := by decide +kernel +theorem child_required_sub_29 : ∀ j, childrenC_29 j ⊆ insert (0, 4) required_29 := by decide +kernel +theorem child_envelope_sub_29 : ∀ j, childrenD_29 j ⊆ envelope_29 := by decide +kernel +theorem pivot_mem_29 : (0, 4) ∈ envelope_29 := by decide +kernel +theorem children_work_29 : ∀ j, Template HasSnaky 2 (childrenC_29 j) (childrenD_29 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (0, 5)).mono (by decide +kernel) + · exact row_works_6.mono (by decide +kernel) +theorem row_works_29 : Template HasSnaky 3 required_29 envelope_29 := by + refine compose HasSnaky 2 childrenC_29 childrenD_29 children_work_29 (0, 4) + required_29 envelope_29 pivot_mem_29 child_required_sub_29 child_envelope_sub_29 ?_ + intro b hb + exact common_sub_29 (mem_commonEnvelope childrenD_29 b hb) +def required_37 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_37 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_37 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 0 (1, 0) required_6)] +def childrenD_37 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 0 (1, 0) envelope_6)] +theorem common_sub_37 : commonEnvelope childrenD_37 ⊆ insert (1, 4) required_37 := by decide +kernel +theorem child_required_sub_37 : ∀ j, childrenC_37 j ⊆ insert (1, 4) required_37 := by decide +kernel +theorem child_envelope_sub_37 : ∀ j, childrenD_37 j ⊆ envelope_37 := by decide +kernel +theorem pivot_mem_37 : (1, 4) ∈ envelope_37 := by decide +kernel +theorem children_work_37 : ∀ j, Template HasSnaky 2 (childrenC_37 j) (childrenD_37 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_6 0 (1, 0)).mono (by decide +kernel) +theorem row_works_37 : Template HasSnaky 3 required_37 envelope_37 := by + refine compose HasSnaky 2 childrenC_37 childrenD_37 children_work_37 (1, 4) + required_37 envelope_37 pivot_mem_37 child_required_sub_37 child_envelope_sub_37 ?_ + intro b hb + exact common_sub_37 (mem_commonEnvelope childrenD_37 b hb) +def required_44 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_44 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_44 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 1) required_43)] +def childrenD_44 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 1) envelope_43)] +theorem common_sub_44 : commonEnvelope childrenD_44 ⊆ insert (1, 4) required_44 := by decide +kernel +theorem child_required_sub_44 : ∀ j, childrenC_44 j ⊆ insert (1, 4) required_44 := by decide +kernel +theorem child_envelope_sub_44 : ∀ j, childrenD_44 j ⊆ envelope_44 := by decide +kernel +theorem pivot_mem_44 : (1, 4) ∈ envelope_44 := by decide +kernel +theorem children_work_44 : ∀ j, Template HasSnaky 2 (childrenC_44 j) (childrenD_44 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_43 0 (0, 1)).mono (by decide +kernel) +theorem row_works_44 : Template HasSnaky 3 required_44 envelope_44 := by + refine compose HasSnaky 2 childrenC_44 childrenD_44 children_work_44 (1, 4) + required_44 envelope_44 pivot_mem_44 child_required_sub_44 child_envelope_sub_44 ?_ + intro b hb + exact common_sub_44 (mem_commonEnvelope childrenD_44 b hb) +def required_45 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_45 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_45 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), (placed21 2 (3, 0) required_23)] +def childrenD_45 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), (placed21 2 (3, 0) envelope_23)] +theorem common_sub_45 : commonEnvelope childrenD_45 ⊆ insert (3, 3) required_45 := by decide +kernel +theorem child_required_sub_45 : ∀ j, childrenC_45 j ⊆ insert (3, 3) required_45 := by decide +kernel +theorem child_envelope_sub_45 : ∀ j, childrenD_45 j ⊆ envelope_45 := by decide +kernel +theorem pivot_mem_45 : (3, 3) ∈ envelope_45 := by decide +kernel +theorem children_work_45 : ∀ j, Template HasSnaky 2 (childrenC_45 j) (childrenD_45 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_23 2 (3, 0)).mono (by decide +kernel) +theorem row_works_45 : Template HasSnaky 3 required_45 envelope_45 := by + refine compose HasSnaky 2 childrenC_45 childrenD_45 children_work_45 (3, 3) + required_45 envelope_45 pivot_mem_45 child_required_sub_45 child_envelope_sub_45 ?_ + intro b hb + exact common_sub_45 (mem_commonEnvelope childrenD_45 b hb) +def required_52 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_52 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_52 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 1) required_51)] +def childrenD_52 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 1) envelope_51)] +theorem common_sub_52 : commonEnvelope childrenD_52 ⊆ insert (1, 4) required_52 := by decide +kernel +theorem child_required_sub_52 : ∀ j, childrenC_52 j ⊆ insert (1, 4) required_52 := by decide +kernel +theorem child_envelope_sub_52 : ∀ j, childrenD_52 j ⊆ envelope_52 := by decide +kernel +theorem pivot_mem_52 : (1, 4) ∈ envelope_52 := by decide +kernel +theorem children_work_52 : ∀ j, Template HasSnaky 2 (childrenC_52 j) (childrenD_52 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_51 0 (0, 1)).mono (by decide +kernel) +theorem row_works_52 : Template HasSnaky 3 required_52 envelope_52 := by + refine compose HasSnaky 2 childrenC_52 childrenD_52 children_work_52 (1, 4) + required_52 envelope_52 pivot_mem_52 child_required_sub_52 child_envelope_sub_52 ?_ + intro b hb + exact common_sub_52 (mem_commonEnvelope childrenD_52 b hb) +def required_53 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_53 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_53 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 1) required_51)] +def childrenD_53 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 1) envelope_51)] +theorem common_sub_53 : commonEnvelope childrenD_53 ⊆ insert (0, 1) required_53 := by decide +kernel +theorem child_required_sub_53 : ∀ j, childrenC_53 j ⊆ insert (0, 1) required_53 := by decide +kernel +theorem child_envelope_sub_53 : ∀ j, childrenD_53 j ⊆ envelope_53 := by decide +kernel +theorem pivot_mem_53 : (0, 1) ∈ envelope_53 := by decide +kernel +theorem children_work_53 : ∀ j, Template HasSnaky 2 (childrenC_53 j) (childrenD_53 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_51 0 (0, 1)).mono (by decide +kernel) +theorem row_works_53 : Template HasSnaky 3 required_53 envelope_53 := by + refine compose HasSnaky 2 childrenC_53 childrenD_53 children_work_53 (0, 1) + required_53 envelope_53 pivot_mem_53 child_required_sub_53 child_envelope_sub_53 ?_ + intro b hb + exact common_sub_53 (mem_commonEnvelope childrenD_53 b hb) +def required_54 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_54 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_54 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 1) required_51)] +def childrenD_54 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 1) envelope_51)] +theorem common_sub_54 : commonEnvelope childrenD_54 ⊆ insert (0, 2) required_54 := by decide +kernel +theorem child_required_sub_54 : ∀ j, childrenC_54 j ⊆ insert (0, 2) required_54 := by decide +kernel +theorem child_envelope_sub_54 : ∀ j, childrenD_54 j ⊆ envelope_54 := by decide +kernel +theorem pivot_mem_54 : (0, 2) ∈ envelope_54 := by decide +kernel +theorem children_work_54 : ∀ j, Template HasSnaky 2 (childrenC_54 j) (childrenD_54 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_51 0 (0, 1)).mono (by decide +kernel) +theorem row_works_54 : Template HasSnaky 3 required_54 envelope_54 := by + refine compose HasSnaky 2 childrenC_54 childrenD_54 children_work_54 (0, 2) + required_54 envelope_54 pivot_mem_54 child_required_sub_54 child_envelope_sub_54 ?_ + intro b hb + exact common_sub_54 (mem_commonEnvelope childrenD_54 b hb) +def required_61 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_61 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_61 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 1) required_51)] +def childrenD_61 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 1) envelope_51)] +theorem common_sub_61 : commonEnvelope childrenD_61 ⊆ insert (1, 3) required_61 := by decide +kernel +theorem child_required_sub_61 : ∀ j, childrenC_61 j ⊆ insert (1, 3) required_61 := by decide +kernel +theorem child_envelope_sub_61 : ∀ j, childrenD_61 j ⊆ envelope_61 := by decide +kernel +theorem pivot_mem_61 : (1, 3) ∈ envelope_61 := by decide +kernel +theorem children_work_61 : ∀ j, Template HasSnaky 2 (childrenC_61 j) (childrenD_61 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_51 0 (0, 1)).mono (by decide +kernel) +theorem row_works_61 : Template HasSnaky 3 required_61 envelope_61 := by + refine compose HasSnaky 2 childrenC_61 childrenD_61 children_work_61 (1, 3) + required_61 envelope_61 pivot_mem_61 child_required_sub_61 child_envelope_sub_61 ?_ + intro b hb + exact common_sub_61 (mem_commonEnvelope childrenD_61 b hb) +def required_62 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_62 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_62 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) required_6), (placed21 6 (1, 5) required_6)] +def childrenD_62 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) envelope_6), (placed21 6 (1, 5) envelope_6)] +theorem common_sub_62 : commonEnvelope childrenD_62 ⊆ insert (1, 5) required_62 := by decide +kernel +theorem child_required_sub_62 : ∀ j, childrenC_62 j ⊆ insert (1, 5) required_62 := by decide +kernel +theorem child_envelope_sub_62 : ∀ j, childrenD_62 j ⊆ envelope_62 := by decide +kernel +theorem pivot_mem_62 : (1, 5) ∈ envelope_62 := by decide +kernel +theorem children_work_62 : ∀ j, Template HasSnaky 2 (childrenC_62 j) (childrenD_62 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 4 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_6 6 (1, 5)).mono (by decide +kernel) +theorem row_works_62 : Template HasSnaky 3 required_62 envelope_62 := by + refine compose HasSnaky 2 childrenC_62 childrenD_62 children_work_62 (1, 5) + required_62 envelope_62 pivot_mem_62 child_required_sub_62 child_envelope_sub_62 ?_ + intro b hb + exact common_sub_62 (mem_commonEnvelope childrenD_62 b hb) +def required_64 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_64 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_64 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 1) required_43)] +def childrenD_64 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 1) envelope_43)] +theorem common_sub_64 : commonEnvelope childrenD_64 ⊆ insert (0, 2) required_64 := by decide +kernel +theorem child_required_sub_64 : ∀ j, childrenC_64 j ⊆ insert (0, 2) required_64 := by decide +kernel +theorem child_envelope_sub_64 : ∀ j, childrenD_64 j ⊆ envelope_64 := by decide +kernel +theorem pivot_mem_64 : (0, 2) ∈ envelope_64 := by decide +kernel +theorem children_work_64 : ∀ j, Template HasSnaky 2 (childrenC_64 j) (childrenD_64 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_43 0 (0, 1)).mono (by decide +kernel) +theorem row_works_64 : Template HasSnaky 3 required_64 envelope_64 := by + refine compose HasSnaky 2 childrenC_64 childrenD_64 children_work_64 (0, 2) + required_64 envelope_64 pivot_mem_64 child_required_sub_64 child_envelope_sub_64 ?_ + intro b hb + exact common_sub_64 (mem_commonEnvelope childrenD_64 b hb) +def required_69 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_69 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_69 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_5), (placed21 2 (3, 0) required_15)] +def childrenD_69 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_5), (placed21 2 (3, 0) envelope_15)] +theorem common_sub_69 : commonEnvelope childrenD_69 ⊆ insert (3, 1) required_69 := by decide +kernel +theorem child_required_sub_69 : ∀ j, childrenC_69 j ⊆ insert (3, 1) required_69 := by decide +kernel +theorem child_envelope_sub_69 : ∀ j, childrenD_69 j ⊆ envelope_69 := by decide +kernel +theorem pivot_mem_69 : (3, 1) ∈ envelope_69 := by decide +kernel +theorem children_work_69 : ∀ j, Template HasSnaky 2 (childrenC_69 j) (childrenD_69 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_15 2 (3, 0)).mono (by decide +kernel) +theorem row_works_69 : Template HasSnaky 3 required_69 envelope_69 := by + refine compose HasSnaky 2 childrenC_69 childrenD_69 children_work_69 (3, 1) + required_69 envelope_69 pivot_mem_69 child_required_sub_69 child_envelope_sub_69 ?_ + intro b hb + exact common_sub_69 (mem_commonEnvelope childrenD_69 b hb) +def required_74 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (1, 0), (1, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_74 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_74 : Fin 4 → Finset Cell := ![required_30, (placed21 2 (1, 0) required_30), required_36, (placed21 2 (1, 0) required_36)] +def childrenD_74 : Fin 4 → Finset Cell := ![envelope_30, (placed21 2 (1, 0) envelope_30), envelope_36, (placed21 2 (1, 0) envelope_36)] +theorem common_sub_74 : commonEnvelope childrenD_74 ⊆ insert (1, 3) required_74 := by decide +kernel +theorem child_required_sub_74 : ∀ j, childrenC_74 j ⊆ insert (1, 3) required_74 := by decide +kernel +theorem child_envelope_sub_74 : ∀ j, childrenD_74 j ⊆ envelope_74 := by decide +kernel +theorem pivot_mem_74 : (1, 3) ∈ envelope_74 := by decide +kernel +theorem children_work_74 : ∀ j, Template HasSnaky 2 (childrenC_74 j) (childrenD_74 j) := by + intro j + fin_cases j + · exact row_works_30.mono (by decide +kernel) + · exact (placed21_template row_works_30 2 (1, 0)).mono (by decide +kernel) + · exact row_works_36.mono (by decide +kernel) + · exact (placed21_template row_works_36 2 (1, 0)).mono (by decide +kernel) +theorem row_works_74 : Template HasSnaky 3 required_74 envelope_74 := by + refine compose HasSnaky 2 childrenC_74 childrenD_74 children_work_74 (1, 3) + required_74 envelope_74 pivot_mem_74 child_required_sub_74 child_envelope_sub_74 ?_ + intro b hb + exact common_sub_74 (mem_commonEnvelope childrenD_74 b hb) +def required_78 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_78 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_78 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), (placed21 5 (4, 0) required_77)] +def childrenD_78 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), (placed21 5 (4, 0) envelope_77)] +theorem common_sub_78 : commonEnvelope childrenD_78 ⊆ insert (3, 0) required_78 := by decide +kernel +theorem child_required_sub_78 : ∀ j, childrenC_78 j ⊆ insert (3, 0) required_78 := by decide +kernel +theorem child_envelope_sub_78 : ∀ j, childrenD_78 j ⊆ envelope_78 := by decide +kernel +theorem pivot_mem_78 : (3, 0) ∈ envelope_78 := by decide +kernel +theorem children_work_78 : ∀ j, Template HasSnaky 2 (childrenC_78 j) (childrenD_78 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_77 5 (4, 0)).mono (by decide +kernel) +theorem row_works_78 : Template HasSnaky 3 required_78 envelope_78 := by + refine compose HasSnaky 2 childrenC_78 childrenD_78 children_work_78 (3, 0) + required_78 envelope_78 pivot_mem_78 child_required_sub_78 child_envelope_sub_78 ?_ + intro b hb + exact common_sub_78 (mem_commonEnvelope childrenD_78 b hb) +def required_87 : Finset Cell := ⟨(([(0, 1), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_87 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_87 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) required_11), (placed21 7 (4, 4) required_35)] +def childrenD_87 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) envelope_11), (placed21 7 (4, 4) envelope_35)] +theorem common_sub_87 : commonEnvelope childrenD_87 ⊆ insert (4, 2) required_87 := by decide +kernel +theorem child_required_sub_87 : ∀ j, childrenC_87 j ⊆ insert (4, 2) required_87 := by decide +kernel +theorem child_envelope_sub_87 : ∀ j, childrenD_87 j ⊆ envelope_87 := by decide +kernel +theorem pivot_mem_87 : (4, 2) ∈ envelope_87 := by decide +kernel +theorem children_work_87 : ∀ j, Template HasSnaky 2 (childrenC_87 j) (childrenD_87 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_35 7 (4, 4)).mono (by decide +kernel) +theorem row_works_87 : Template HasSnaky 3 required_87 envelope_87 := by + refine compose HasSnaky 2 childrenC_87 childrenD_87 children_work_87 (4, 2) + required_87 envelope_87 pivot_mem_87 child_required_sub_87 child_envelope_sub_87 ?_ + intro b hb + exact common_sub_87 (mem_commonEnvelope childrenD_87 b hb) +def required_101 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_101 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_101 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 1) required_51)] +def childrenD_101 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 1) envelope_51)] +theorem common_sub_101 : commonEnvelope childrenD_101 ⊆ insert (0, 3) required_101 := by decide +kernel +theorem child_required_sub_101 : ∀ j, childrenC_101 j ⊆ insert (0, 3) required_101 := by decide +kernel +theorem child_envelope_sub_101 : ∀ j, childrenD_101 j ⊆ envelope_101 := by decide +kernel +theorem pivot_mem_101 : (0, 3) ∈ envelope_101 := by decide +kernel +theorem children_work_101 : ∀ j, Template HasSnaky 2 (childrenC_101 j) (childrenD_101 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_51 0 (0, 1)).mono (by decide +kernel) +theorem row_works_101 : Template HasSnaky 3 required_101 envelope_101 := by + refine compose HasSnaky 2 childrenC_101 childrenD_101 children_work_101 (0, 3) + required_101 envelope_101 pivot_mem_101 child_required_sub_101 child_envelope_sub_101 ?_ + intro b hb + exact common_sub_101 (mem_commonEnvelope childrenD_101 b hb) +def required_103 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_103 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_103 : Fin 2 → Finset Cell := ![required_6, required_11] +def childrenD_103 : Fin 2 → Finset Cell := ![envelope_6, envelope_11] +theorem common_sub_103 : commonEnvelope childrenD_103 ⊆ insert (0, 4) required_103 := by decide +kernel +theorem child_required_sub_103 : ∀ j, childrenC_103 j ⊆ insert (0, 4) required_103 := by decide +kernel +theorem child_envelope_sub_103 : ∀ j, childrenD_103 j ⊆ envelope_103 := by decide +kernel +theorem pivot_mem_103 : (0, 4) ∈ envelope_103 := by decide +kernel +theorem children_work_103 : ∀ j, Template HasSnaky 2 (childrenC_103 j) (childrenD_103 j) := by + intro j + fin_cases j + · exact row_works_6.mono (by decide +kernel) + · exact row_works_11.mono (by decide +kernel) +theorem row_works_103 : Template HasSnaky 3 required_103 envelope_103 := by + refine compose HasSnaky 2 childrenC_103 childrenD_103 children_work_103 (0, 4) + required_103 envelope_103 pivot_mem_103 child_required_sub_103 child_envelope_sub_103 ?_ + intro b hb + exact common_sub_103 (mem_commonEnvelope childrenD_103 b hb) +def required_105 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 2), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_105 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_105 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_5), required_11] +def childrenD_105 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_5), envelope_11] +theorem common_sub_105 : commonEnvelope childrenD_105 ⊆ insert (0, 3) required_105 := by decide +kernel +theorem child_required_sub_105 : ∀ j, childrenC_105 j ⊆ insert (0, 3) required_105 := by decide +kernel +theorem child_envelope_sub_105 : ∀ j, childrenD_105 j ⊆ envelope_105 := by decide +kernel +theorem pivot_mem_105 : (0, 3) ∈ envelope_105 := by decide +kernel +theorem children_work_105 : ∀ j, Template HasSnaky 2 (childrenC_105 j) (childrenD_105 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (0, 1)).mono (by decide +kernel) + · exact row_works_11.mono (by decide +kernel) +theorem row_works_105 : Template HasSnaky 3 required_105 envelope_105 := by + refine compose HasSnaky 2 childrenC_105 childrenD_105 children_work_105 (0, 3) + required_105 envelope_105 pivot_mem_105 child_required_sub_105 child_envelope_sub_105 ?_ + intro b hb + exact common_sub_105 (mem_commonEnvelope childrenD_105 b hb) +def height_7 : ℕ := 3 +def childrenH_7 : Fin 2 → ℕ := ![height_6, height_6] +theorem height_exact_7 : height_7 = 1 + Finset.univ.sup childrenH_7 := by decide +kernel +theorem required_origin_7 : ∀ x ∈ required_7, + (∃ j, x ∈ childrenC_7 j) ∨ ∀ j, x ∈ childrenD_7 j := by decide +kernel +theorem required_exact_7 : required_7 = + ((Finset.univ.biUnion childrenC_7) ∪ commonEnvelope childrenD_7).erase (0, 5) := by + exact required_eq_combination childrenC_7 childrenD_7 (0, 5) required_7 + (by decide +kernel) child_required_sub_7 common_sub_7 required_origin_7 +theorem envelope_origin_7 : ∀ x ∈ envelope_7, + x = (0, 5) ∨ ∃ j, x ∈ childrenD_7 j := by decide +kernel +theorem envelope_exact_7 : envelope_7 = + insert (0, 5) (Finset.univ.biUnion childrenD_7) := by + exact envelope_eq_combination childrenD_7 (0, 5) envelope_7 + pivot_mem_7 child_envelope_sub_7 envelope_origin_7 +def checked_7 : CheckedCard where + required := required_7 + envelope := envelope_7 + height := height_7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_7 +def height_8 : ℕ := 3 +def childrenH_8 : Fin 2 → ℕ := ![height_6, height_6] +theorem height_exact_8 : height_8 = 1 + Finset.univ.sup childrenH_8 := by decide +kernel +theorem required_origin_8 : ∀ x ∈ required_8, + (∃ j, x ∈ childrenC_8 j) ∨ ∀ j, x ∈ childrenD_8 j := by decide +kernel +theorem required_exact_8 : required_8 = + ((Finset.univ.biUnion childrenC_8) ∪ commonEnvelope childrenD_8).erase (4, 1) := by + exact required_eq_combination childrenC_8 childrenD_8 (4, 1) required_8 + (by decide +kernel) child_required_sub_8 common_sub_8 required_origin_8 +theorem envelope_origin_8 : ∀ x ∈ envelope_8, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_8 j := by decide +kernel +theorem envelope_exact_8 : envelope_8 = + insert (4, 1) (Finset.univ.biUnion childrenD_8) := by + exact envelope_eq_combination childrenD_8 (4, 1) envelope_8 + pivot_mem_8 child_envelope_sub_8 envelope_origin_8 +def checked_8 : CheckedCard where + required := required_8 + envelope := envelope_8 + height := height_8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_8 +def height_9 : ℕ := 3 +def childrenH_9 : Fin 2 → ℕ := ![height_6, height_6] +theorem height_exact_9 : height_9 = 1 + Finset.univ.sup childrenH_9 := by decide +kernel +theorem required_origin_9 : ∀ x ∈ required_9, + (∃ j, x ∈ childrenC_9 j) ∨ ∀ j, x ∈ childrenD_9 j := by decide +kernel +theorem required_exact_9 : required_9 = + ((Finset.univ.biUnion childrenC_9) ∪ commonEnvelope childrenD_9).erase (1, 5) := by + exact required_eq_combination childrenC_9 childrenD_9 (1, 5) required_9 + (by decide +kernel) child_required_sub_9 common_sub_9 required_origin_9 +theorem envelope_origin_9 : ∀ x ∈ envelope_9, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_9 j := by decide +kernel +theorem envelope_exact_9 : envelope_9 = + insert (1, 5) (Finset.univ.biUnion childrenD_9) := by + exact envelope_eq_combination childrenD_9 (1, 5) envelope_9 + pivot_mem_9 child_envelope_sub_9 envelope_origin_9 +def checked_9 : CheckedCard where + required := required_9 + envelope := envelope_9 + height := height_9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_9 +def height_16 : ℕ := 3 +def childrenH_16 : Fin 2 → ℕ := ![height_4, height_6] +theorem height_exact_16 : height_16 = 1 + Finset.univ.sup childrenH_16 := by decide +kernel +theorem required_origin_16 : ∀ x ∈ required_16, + (∃ j, x ∈ childrenC_16 j) ∨ ∀ j, x ∈ childrenD_16 j := by decide +kernel +theorem required_exact_16 : required_16 = + ((Finset.univ.biUnion childrenC_16) ∪ commonEnvelope childrenD_16).erase (0, 4) := by + exact required_eq_combination childrenC_16 childrenD_16 (0, 4) required_16 + (by decide +kernel) child_required_sub_16 common_sub_16 required_origin_16 +theorem envelope_origin_16 : ∀ x ∈ envelope_16, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_16 j := by decide +kernel +theorem envelope_exact_16 : envelope_16 = + insert (0, 4) (Finset.univ.biUnion childrenD_16) := by + exact envelope_eq_combination childrenD_16 (0, 4) envelope_16 + pivot_mem_16 child_envelope_sub_16 envelope_origin_16 +def checked_16 : CheckedCard where + required := required_16 + envelope := envelope_16 + height := height_16 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_16 +def height_20 : ℕ := 3 +def childrenH_20 : Fin 2 → ℕ := ![height_0, height_6] +theorem height_exact_20 : height_20 = 1 + Finset.univ.sup childrenH_20 := by decide +kernel +theorem required_origin_20 : ∀ x ∈ required_20, + (∃ j, x ∈ childrenC_20 j) ∨ ∀ j, x ∈ childrenD_20 j := by decide +kernel +theorem required_exact_20 : required_20 = + ((Finset.univ.biUnion childrenC_20) ∪ commonEnvelope childrenD_20).erase (1, 4) := by + exact required_eq_combination childrenC_20 childrenD_20 (1, 4) required_20 + (by decide +kernel) child_required_sub_20 common_sub_20 required_origin_20 +theorem envelope_origin_20 : ∀ x ∈ envelope_20, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_20 j := by decide +kernel +theorem envelope_exact_20 : envelope_20 = + insert (1, 4) (Finset.univ.biUnion childrenD_20) := by + exact envelope_eq_combination childrenD_20 (1, 4) envelope_20 + pivot_mem_20 child_envelope_sub_20 envelope_origin_20 +def checked_20 : CheckedCard where + required := required_20 + envelope := envelope_20 + height := height_20 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_20 +def height_21 : ℕ := 3 +def childrenH_21 : Fin 2 → ℕ := ![height_5, height_6] +theorem height_exact_21 : height_21 = 1 + Finset.univ.sup childrenH_21 := by decide +kernel +theorem required_origin_21 : ∀ x ∈ required_21, + (∃ j, x ∈ childrenC_21 j) ∨ ∀ j, x ∈ childrenD_21 j := by decide +kernel +theorem required_exact_21 : required_21 = + ((Finset.univ.biUnion childrenC_21) ∪ commonEnvelope childrenD_21).erase (0, 4) := by + exact required_eq_combination childrenC_21 childrenD_21 (0, 4) required_21 + (by decide +kernel) child_required_sub_21 common_sub_21 required_origin_21 +theorem envelope_origin_21 : ∀ x ∈ envelope_21, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_21 j := by decide +kernel +theorem envelope_exact_21 : envelope_21 = + insert (0, 4) (Finset.univ.biUnion childrenD_21) := by + exact envelope_eq_combination childrenD_21 (0, 4) envelope_21 + pivot_mem_21 child_envelope_sub_21 envelope_origin_21 +def checked_21 : CheckedCard where + required := required_21 + envelope := envelope_21 + height := height_21 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_21 +def height_24 : ℕ := 3 +def childrenH_24 : Fin 2 → ℕ := ![height_4, height_6] +theorem height_exact_24 : height_24 = 1 + Finset.univ.sup childrenH_24 := by decide +kernel +theorem required_origin_24 : ∀ x ∈ required_24, + (∃ j, x ∈ childrenC_24 j) ∨ ∀ j, x ∈ childrenD_24 j := by decide +kernel +theorem required_exact_24 : required_24 = + ((Finset.univ.biUnion childrenC_24) ∪ commonEnvelope childrenD_24).erase (4, 1) := by + exact required_eq_combination childrenC_24 childrenD_24 (4, 1) required_24 + (by decide +kernel) child_required_sub_24 common_sub_24 required_origin_24 +theorem envelope_origin_24 : ∀ x ∈ envelope_24, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_24 j := by decide +kernel +theorem envelope_exact_24 : envelope_24 = + insert (4, 1) (Finset.univ.biUnion childrenD_24) := by + exact envelope_eq_combination childrenD_24 (4, 1) envelope_24 + pivot_mem_24 child_envelope_sub_24 envelope_origin_24 +def checked_24 : CheckedCard where + required := required_24 + envelope := envelope_24 + height := height_24 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_24 +def height_29 : ℕ := 3 +def childrenH_29 : Fin 2 → ℕ := ![height_0, height_6] +theorem height_exact_29 : height_29 = 1 + Finset.univ.sup childrenH_29 := by decide +kernel +theorem required_origin_29 : ∀ x ∈ required_29, + (∃ j, x ∈ childrenC_29 j) ∨ ∀ j, x ∈ childrenD_29 j := by decide +kernel +theorem required_exact_29 : required_29 = + ((Finset.univ.biUnion childrenC_29) ∪ commonEnvelope childrenD_29).erase (0, 4) := by + exact required_eq_combination childrenC_29 childrenD_29 (0, 4) required_29 + (by decide +kernel) child_required_sub_29 common_sub_29 required_origin_29 +theorem envelope_origin_29 : ∀ x ∈ envelope_29, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_29 j := by decide +kernel +theorem envelope_exact_29 : envelope_29 = + insert (0, 4) (Finset.univ.biUnion childrenD_29) := by + exact envelope_eq_combination childrenD_29 (0, 4) envelope_29 + pivot_mem_29 child_envelope_sub_29 envelope_origin_29 +def checked_29 : CheckedCard where + required := required_29 + envelope := envelope_29 + height := height_29 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_29 +def height_37 : ℕ := 3 +def childrenH_37 : Fin 2 → ℕ := ![height_5, height_6] +theorem height_exact_37 : height_37 = 1 + Finset.univ.sup childrenH_37 := by decide +kernel +theorem required_origin_37 : ∀ x ∈ required_37, + (∃ j, x ∈ childrenC_37 j) ∨ ∀ j, x ∈ childrenD_37 j := by decide +kernel +theorem required_exact_37 : required_37 = + ((Finset.univ.biUnion childrenC_37) ∪ commonEnvelope childrenD_37).erase (1, 4) := by + exact required_eq_combination childrenC_37 childrenD_37 (1, 4) required_37 + (by decide +kernel) child_required_sub_37 common_sub_37 required_origin_37 +theorem envelope_origin_37 : ∀ x ∈ envelope_37, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_37 j := by decide +kernel +theorem envelope_exact_37 : envelope_37 = + insert (1, 4) (Finset.univ.biUnion childrenD_37) := by + exact envelope_eq_combination childrenD_37 (1, 4) envelope_37 + pivot_mem_37 child_envelope_sub_37 envelope_origin_37 +def checked_37 : CheckedCard where + required := required_37 + envelope := envelope_37 + height := height_37 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_37 +def height_44 : ℕ := 3 +def childrenH_44 : Fin 2 → ℕ := ![height_0, height_43] +theorem height_exact_44 : height_44 = 1 + Finset.univ.sup childrenH_44 := by decide +kernel +theorem required_origin_44 : ∀ x ∈ required_44, + (∃ j, x ∈ childrenC_44 j) ∨ ∀ j, x ∈ childrenD_44 j := by decide +kernel +theorem required_exact_44 : required_44 = + ((Finset.univ.biUnion childrenC_44) ∪ commonEnvelope childrenD_44).erase (1, 4) := by + exact required_eq_combination childrenC_44 childrenD_44 (1, 4) required_44 + (by decide +kernel) child_required_sub_44 common_sub_44 required_origin_44 +theorem envelope_origin_44 : ∀ x ∈ envelope_44, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_44 j := by decide +kernel +theorem envelope_exact_44 : envelope_44 = + insert (1, 4) (Finset.univ.biUnion childrenD_44) := by + exact envelope_eq_combination childrenD_44 (1, 4) envelope_44 + pivot_mem_44 child_envelope_sub_44 envelope_origin_44 +def checked_44 : CheckedCard where + required := required_44 + envelope := envelope_44 + height := height_44 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_44 +def height_45 : ℕ := 3 +def childrenH_45 : Fin 2 → ℕ := ![height_5, height_23] +theorem height_exact_45 : height_45 = 1 + Finset.univ.sup childrenH_45 := by decide +kernel +theorem required_origin_45 : ∀ x ∈ required_45, + (∃ j, x ∈ childrenC_45 j) ∨ ∀ j, x ∈ childrenD_45 j := by decide +kernel +theorem required_exact_45 : required_45 = + ((Finset.univ.biUnion childrenC_45) ∪ commonEnvelope childrenD_45).erase (3, 3) := by + exact required_eq_combination childrenC_45 childrenD_45 (3, 3) required_45 + (by decide +kernel) child_required_sub_45 common_sub_45 required_origin_45 +theorem envelope_origin_45 : ∀ x ∈ envelope_45, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_45 j := by decide +kernel +theorem envelope_exact_45 : envelope_45 = + insert (3, 3) (Finset.univ.biUnion childrenD_45) := by + exact envelope_eq_combination childrenD_45 (3, 3) envelope_45 + pivot_mem_45 child_envelope_sub_45 envelope_origin_45 +def checked_45 : CheckedCard where + required := required_45 + envelope := envelope_45 + height := height_45 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_45 +def height_52 : ℕ := 3 +def childrenH_52 : Fin 2 → ℕ := ![height_0, height_51] +theorem height_exact_52 : height_52 = 1 + Finset.univ.sup childrenH_52 := by decide +kernel +theorem required_origin_52 : ∀ x ∈ required_52, + (∃ j, x ∈ childrenC_52 j) ∨ ∀ j, x ∈ childrenD_52 j := by decide +kernel +theorem required_exact_52 : required_52 = + ((Finset.univ.biUnion childrenC_52) ∪ commonEnvelope childrenD_52).erase (1, 4) := by + exact required_eq_combination childrenC_52 childrenD_52 (1, 4) required_52 + (by decide +kernel) child_required_sub_52 common_sub_52 required_origin_52 +theorem envelope_origin_52 : ∀ x ∈ envelope_52, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_52 j := by decide +kernel +theorem envelope_exact_52 : envelope_52 = + insert (1, 4) (Finset.univ.biUnion childrenD_52) := by + exact envelope_eq_combination childrenD_52 (1, 4) envelope_52 + pivot_mem_52 child_envelope_sub_52 envelope_origin_52 +def checked_52 : CheckedCard where + required := required_52 + envelope := envelope_52 + height := height_52 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_52 +def height_53 : ℕ := 3 +def childrenH_53 : Fin 2 → ℕ := ![height_0, height_51] +theorem height_exact_53 : height_53 = 1 + Finset.univ.sup childrenH_53 := by decide +kernel +theorem required_origin_53 : ∀ x ∈ required_53, + (∃ j, x ∈ childrenC_53 j) ∨ ∀ j, x ∈ childrenD_53 j := by decide +kernel +theorem required_exact_53 : required_53 = + ((Finset.univ.biUnion childrenC_53) ∪ commonEnvelope childrenD_53).erase (0, 1) := by + exact required_eq_combination childrenC_53 childrenD_53 (0, 1) required_53 + (by decide +kernel) child_required_sub_53 common_sub_53 required_origin_53 +theorem envelope_origin_53 : ∀ x ∈ envelope_53, + x = (0, 1) ∨ ∃ j, x ∈ childrenD_53 j := by decide +kernel +theorem envelope_exact_53 : envelope_53 = + insert (0, 1) (Finset.univ.biUnion childrenD_53) := by + exact envelope_eq_combination childrenD_53 (0, 1) envelope_53 + pivot_mem_53 child_envelope_sub_53 envelope_origin_53 +def checked_53 : CheckedCard where + required := required_53 + envelope := envelope_53 + height := height_53 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_53 +def height_54 : ℕ := 3 +def childrenH_54 : Fin 2 → ℕ := ![height_0, height_51] +theorem height_exact_54 : height_54 = 1 + Finset.univ.sup childrenH_54 := by decide +kernel +theorem required_origin_54 : ∀ x ∈ required_54, + (∃ j, x ∈ childrenC_54 j) ∨ ∀ j, x ∈ childrenD_54 j := by decide +kernel +theorem required_exact_54 : required_54 = + ((Finset.univ.biUnion childrenC_54) ∪ commonEnvelope childrenD_54).erase (0, 2) := by + exact required_eq_combination childrenC_54 childrenD_54 (0, 2) required_54 + (by decide +kernel) child_required_sub_54 common_sub_54 required_origin_54 +theorem envelope_origin_54 : ∀ x ∈ envelope_54, + x = (0, 2) ∨ ∃ j, x ∈ childrenD_54 j := by decide +kernel +theorem envelope_exact_54 : envelope_54 = + insert (0, 2) (Finset.univ.biUnion childrenD_54) := by + exact envelope_eq_combination childrenD_54 (0, 2) envelope_54 + pivot_mem_54 child_envelope_sub_54 envelope_origin_54 +def checked_54 : CheckedCard where + required := required_54 + envelope := envelope_54 + height := height_54 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_54 +def height_61 : ℕ := 3 +def childrenH_61 : Fin 2 → ℕ := ![height_0, height_51] +theorem height_exact_61 : height_61 = 1 + Finset.univ.sup childrenH_61 := by decide +kernel +theorem required_origin_61 : ∀ x ∈ required_61, + (∃ j, x ∈ childrenC_61 j) ∨ ∀ j, x ∈ childrenD_61 j := by decide +kernel +theorem required_exact_61 : required_61 = + ((Finset.univ.biUnion childrenC_61) ∪ commonEnvelope childrenD_61).erase (1, 3) := by + exact required_eq_combination childrenC_61 childrenD_61 (1, 3) required_61 + (by decide +kernel) child_required_sub_61 common_sub_61 required_origin_61 +theorem envelope_origin_61 : ∀ x ∈ envelope_61, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_61 j := by decide +kernel +theorem envelope_exact_61 : envelope_61 = + insert (1, 3) (Finset.univ.biUnion childrenD_61) := by + exact envelope_eq_combination childrenD_61 (1, 3) envelope_61 + pivot_mem_61 child_envelope_sub_61 envelope_origin_61 +def checked_61 : CheckedCard where + required := required_61 + envelope := envelope_61 + height := height_61 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_61 +def height_62 : ℕ := 3 +def childrenH_62 : Fin 2 → ℕ := ![height_6, height_6] +theorem height_exact_62 : height_62 = 1 + Finset.univ.sup childrenH_62 := by decide +kernel +theorem required_origin_62 : ∀ x ∈ required_62, + (∃ j, x ∈ childrenC_62 j) ∨ ∀ j, x ∈ childrenD_62 j := by decide +kernel +theorem required_exact_62 : required_62 = + ((Finset.univ.biUnion childrenC_62) ∪ commonEnvelope childrenD_62).erase (1, 5) := by + exact required_eq_combination childrenC_62 childrenD_62 (1, 5) required_62 + (by decide +kernel) child_required_sub_62 common_sub_62 required_origin_62 +theorem envelope_origin_62 : ∀ x ∈ envelope_62, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_62 j := by decide +kernel +theorem envelope_exact_62 : envelope_62 = + insert (1, 5) (Finset.univ.biUnion childrenD_62) := by + exact envelope_eq_combination childrenD_62 (1, 5) envelope_62 + pivot_mem_62 child_envelope_sub_62 envelope_origin_62 +def checked_62 : CheckedCard where + required := required_62 + envelope := envelope_62 + height := height_62 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_62 +def height_64 : ℕ := 3 +def childrenH_64 : Fin 2 → ℕ := ![height_0, height_43] +theorem height_exact_64 : height_64 = 1 + Finset.univ.sup childrenH_64 := by decide +kernel +theorem required_origin_64 : ∀ x ∈ required_64, + (∃ j, x ∈ childrenC_64 j) ∨ ∀ j, x ∈ childrenD_64 j := by decide +kernel +theorem required_exact_64 : required_64 = + ((Finset.univ.biUnion childrenC_64) ∪ commonEnvelope childrenD_64).erase (0, 2) := by + exact required_eq_combination childrenC_64 childrenD_64 (0, 2) required_64 + (by decide +kernel) child_required_sub_64 common_sub_64 required_origin_64 +theorem envelope_origin_64 : ∀ x ∈ envelope_64, + x = (0, 2) ∨ ∃ j, x ∈ childrenD_64 j := by decide +kernel +theorem envelope_exact_64 : envelope_64 = + insert (0, 2) (Finset.univ.biUnion childrenD_64) := by + exact envelope_eq_combination childrenD_64 (0, 2) envelope_64 + pivot_mem_64 child_envelope_sub_64 envelope_origin_64 +def checked_64 : CheckedCard where + required := required_64 + envelope := envelope_64 + height := height_64 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_64 +def height_69 : ℕ := 3 +def childrenH_69 : Fin 2 → ℕ := ![height_5, height_15] +theorem height_exact_69 : height_69 = 1 + Finset.univ.sup childrenH_69 := by decide +kernel +theorem required_origin_69 : ∀ x ∈ required_69, + (∃ j, x ∈ childrenC_69 j) ∨ ∀ j, x ∈ childrenD_69 j := by decide +kernel +theorem required_exact_69 : required_69 = + ((Finset.univ.biUnion childrenC_69) ∪ commonEnvelope childrenD_69).erase (3, 1) := by + exact required_eq_combination childrenC_69 childrenD_69 (3, 1) required_69 + (by decide +kernel) child_required_sub_69 common_sub_69 required_origin_69 +theorem envelope_origin_69 : ∀ x ∈ envelope_69, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_69 j := by decide +kernel +theorem envelope_exact_69 : envelope_69 = + insert (3, 1) (Finset.univ.biUnion childrenD_69) := by + exact envelope_eq_combination childrenD_69 (3, 1) envelope_69 + pivot_mem_69 child_envelope_sub_69 envelope_origin_69 +def checked_69 : CheckedCard where + required := required_69 + envelope := envelope_69 + height := height_69 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_69 +def height_74 : ℕ := 3 +def childrenH_74 : Fin 4 → ℕ := ![height_30, height_30, height_36, height_36] +theorem height_exact_74 : height_74 = 1 + Finset.univ.sup childrenH_74 := by decide +kernel +theorem required_origin_74 : ∀ x ∈ required_74, + (∃ j, x ∈ childrenC_74 j) ∨ ∀ j, x ∈ childrenD_74 j := by decide +kernel +theorem required_exact_74 : required_74 = + ((Finset.univ.biUnion childrenC_74) ∪ commonEnvelope childrenD_74).erase (1, 3) := by + exact required_eq_combination childrenC_74 childrenD_74 (1, 3) required_74 + (by decide +kernel) child_required_sub_74 common_sub_74 required_origin_74 +theorem envelope_origin_74 : ∀ x ∈ envelope_74, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_74 j := by decide +kernel +theorem envelope_exact_74 : envelope_74 = + insert (1, 3) (Finset.univ.biUnion childrenD_74) := by + exact envelope_eq_combination childrenD_74 (1, 3) envelope_74 + pivot_mem_74 child_envelope_sub_74 envelope_origin_74 +def checked_74 : CheckedCard where + required := required_74 + envelope := envelope_74 + height := height_74 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_74 +def height_78 : ℕ := 3 +def childrenH_78 : Fin 2 → ℕ := ![height_5, height_77] +theorem height_exact_78 : height_78 = 1 + Finset.univ.sup childrenH_78 := by decide +kernel +theorem required_origin_78 : ∀ x ∈ required_78, + (∃ j, x ∈ childrenC_78 j) ∨ ∀ j, x ∈ childrenD_78 j := by decide +kernel +theorem required_exact_78 : required_78 = + ((Finset.univ.biUnion childrenC_78) ∪ commonEnvelope childrenD_78).erase (3, 0) := by + exact required_eq_combination childrenC_78 childrenD_78 (3, 0) required_78 + (by decide +kernel) child_required_sub_78 common_sub_78 required_origin_78 +theorem envelope_origin_78 : ∀ x ∈ envelope_78, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_78 j := by decide +kernel +theorem envelope_exact_78 : envelope_78 = + insert (3, 0) (Finset.univ.biUnion childrenD_78) := by + exact envelope_eq_combination childrenD_78 (3, 0) envelope_78 + pivot_mem_78 child_envelope_sub_78 envelope_origin_78 +def checked_78 : CheckedCard where + required := required_78 + envelope := envelope_78 + height := height_78 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_78 +def height_87 : ℕ := 3 +def childrenH_87 : Fin 2 → ℕ := ![height_11, height_35] +theorem height_exact_87 : height_87 = 1 + Finset.univ.sup childrenH_87 := by decide +kernel +theorem required_origin_87 : ∀ x ∈ required_87, + (∃ j, x ∈ childrenC_87 j) ∨ ∀ j, x ∈ childrenD_87 j := by decide +kernel +theorem required_exact_87 : required_87 = + ((Finset.univ.biUnion childrenC_87) ∪ commonEnvelope childrenD_87).erase (4, 2) := by + exact required_eq_combination childrenC_87 childrenD_87 (4, 2) required_87 + (by decide +kernel) child_required_sub_87 common_sub_87 required_origin_87 +theorem envelope_origin_87 : ∀ x ∈ envelope_87, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_87 j := by decide +kernel +theorem envelope_exact_87 : envelope_87 = + insert (4, 2) (Finset.univ.biUnion childrenD_87) := by + exact envelope_eq_combination childrenD_87 (4, 2) envelope_87 + pivot_mem_87 child_envelope_sub_87 envelope_origin_87 +def checked_87 : CheckedCard where + required := required_87 + envelope := envelope_87 + height := height_87 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_87 +def height_101 : ℕ := 3 +def childrenH_101 : Fin 2 → ℕ := ![height_0, height_51] +theorem height_exact_101 : height_101 = 1 + Finset.univ.sup childrenH_101 := by decide +kernel +theorem required_origin_101 : ∀ x ∈ required_101, + (∃ j, x ∈ childrenC_101 j) ∨ ∀ j, x ∈ childrenD_101 j := by decide +kernel +theorem required_exact_101 : required_101 = + ((Finset.univ.biUnion childrenC_101) ∪ commonEnvelope childrenD_101).erase (0, 3) := by + exact required_eq_combination childrenC_101 childrenD_101 (0, 3) required_101 + (by decide +kernel) child_required_sub_101 common_sub_101 required_origin_101 +theorem envelope_origin_101 : ∀ x ∈ envelope_101, + x = (0, 3) ∨ ∃ j, x ∈ childrenD_101 j := by decide +kernel +theorem envelope_exact_101 : envelope_101 = + insert (0, 3) (Finset.univ.biUnion childrenD_101) := by + exact envelope_eq_combination childrenD_101 (0, 3) envelope_101 + pivot_mem_101 child_envelope_sub_101 envelope_origin_101 +def checked_101 : CheckedCard where + required := required_101 + envelope := envelope_101 + height := height_101 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_101 +def height_103 : ℕ := 3 +def childrenH_103 : Fin 2 → ℕ := ![height_6, height_11] +theorem height_exact_103 : height_103 = 1 + Finset.univ.sup childrenH_103 := by decide +kernel +theorem required_origin_103 : ∀ x ∈ required_103, + (∃ j, x ∈ childrenC_103 j) ∨ ∀ j, x ∈ childrenD_103 j := by decide +kernel +theorem required_exact_103 : required_103 = + ((Finset.univ.biUnion childrenC_103) ∪ commonEnvelope childrenD_103).erase (0, 4) := by + exact required_eq_combination childrenC_103 childrenD_103 (0, 4) required_103 + (by decide +kernel) child_required_sub_103 common_sub_103 required_origin_103 +theorem envelope_origin_103 : ∀ x ∈ envelope_103, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_103 j := by decide +kernel +theorem envelope_exact_103 : envelope_103 = + insert (0, 4) (Finset.univ.biUnion childrenD_103) := by + exact envelope_eq_combination childrenD_103 (0, 4) envelope_103 + pivot_mem_103 child_envelope_sub_103 envelope_origin_103 +def checked_103 : CheckedCard where + required := required_103 + envelope := envelope_103 + height := height_103 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_103 +def height_105 : ℕ := 3 +def childrenH_105 : Fin 2 → ℕ := ![height_5, height_11] +theorem height_exact_105 : height_105 = 1 + Finset.univ.sup childrenH_105 := by decide +kernel +theorem required_origin_105 : ∀ x ∈ required_105, + (∃ j, x ∈ childrenC_105 j) ∨ ∀ j, x ∈ childrenD_105 j := by decide +kernel +theorem required_exact_105 : required_105 = + ((Finset.univ.biUnion childrenC_105) ∪ commonEnvelope childrenD_105).erase (0, 3) := by + exact required_eq_combination childrenC_105 childrenD_105 (0, 3) required_105 + (by decide +kernel) child_required_sub_105 common_sub_105 required_origin_105 +theorem envelope_origin_105 : ∀ x ∈ envelope_105, + x = (0, 3) ∨ ∃ j, x ∈ childrenD_105 j := by decide +kernel +theorem envelope_exact_105 : envelope_105 = + insert (0, 3) (Finset.univ.biUnion childrenD_105) := by + exact envelope_eq_combination childrenD_105 (0, 3) envelope_105 + pivot_mem_105 child_envelope_sub_105 envelope_origin_105 +def checked_105 : CheckedCard where + required := required_105 + envelope := envelope_105 + height := height_105 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_105 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part02.lean new file mode 100644 index 0000000..859175d --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part02.lean @@ -0,0 +1,997 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_108 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 2), (2, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_108 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_108 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) required_15), (placed21 3 (0, 3) required_102)] +def childrenD_108 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) envelope_15), (placed21 3 (0, 3) envelope_102)] +theorem common_sub_108 : commonEnvelope childrenD_108 ⊆ insert (1, 1) required_108 := by decide +kernel +theorem child_required_sub_108 : ∀ j, childrenC_108 j ⊆ insert (1, 1) required_108 := by decide +kernel +theorem child_envelope_sub_108 : ∀ j, childrenD_108 j ⊆ envelope_108 := by decide +kernel +theorem pivot_mem_108 : (1, 1) ∈ envelope_108 := by decide +kernel +theorem children_work_108 : ∀ j, Template HasSnaky 2 (childrenC_108 j) (childrenD_108 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_102 3 (0, 3)).mono (by decide +kernel) +theorem row_works_108 : Template HasSnaky 3 required_108 envelope_108 := by + refine compose HasSnaky 2 childrenC_108 childrenD_108 children_work_108 (1, 1) + required_108 envelope_108 pivot_mem_108 child_required_sub_108 child_envelope_sub_108 ?_ + intro b hb + exact common_sub_108 (mem_commonEnvelope childrenD_108 b hb) +def required_113 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_113 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_113 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 2) required_23)] +def childrenD_113 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 2) envelope_23)] +theorem common_sub_113 : commonEnvelope childrenD_113 ⊆ insert (1, 3) required_113 := by decide +kernel +theorem child_required_sub_113 : ∀ j, childrenC_113 j ⊆ insert (1, 3) required_113 := by decide +kernel +theorem child_envelope_sub_113 : ∀ j, childrenD_113 j ⊆ envelope_113 := by decide +kernel +theorem pivot_mem_113 : (1, 3) ∈ envelope_113 := by decide +kernel +theorem children_work_113 : ∀ j, Template HasSnaky 2 (childrenC_113 j) (childrenD_113 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_23 0 (0, 2)).mono (by decide +kernel) +theorem row_works_113 : Template HasSnaky 3 required_113 envelope_113 := by + refine compose HasSnaky 2 childrenC_113 childrenD_113 children_work_113 (1, 3) + required_113 envelope_113 pivot_mem_113 child_required_sub_113 child_envelope_sub_113 ?_ + intro b hb + exact common_sub_113 (mem_commonEnvelope childrenD_113 b hb) +def required_124 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_124 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_124 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 1 (0, 1) required_123)] +def childrenD_124 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_123)] +theorem common_sub_124 : commonEnvelope childrenD_124 ⊆ insert (2, 1) required_124 := by decide +kernel +theorem child_required_sub_124 : ∀ j, childrenC_124 j ⊆ insert (2, 1) required_124 := by decide +kernel +theorem child_envelope_sub_124 : ∀ j, childrenD_124 j ⊆ envelope_124 := by decide +kernel +theorem pivot_mem_124 : (2, 1) ∈ envelope_124 := by decide +kernel +theorem children_work_124 : ∀ j, Template HasSnaky 2 (childrenC_124 j) (childrenD_124 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_123 1 (0, 1)).mono (by decide +kernel) +theorem row_works_124 : Template HasSnaky 3 required_124 envelope_124 := by + refine compose HasSnaky 2 childrenC_124 childrenD_124 children_work_124 (2, 1) + required_124 envelope_124 pivot_mem_124 child_required_sub_124 child_envelope_sub_124 ?_ + intro b hb + exact common_sub_124 (mem_commonEnvelope childrenD_124 b hb) +def required_126 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (1, 4), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_126 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_126 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 1 (0, 1) required_123)] +def childrenD_126 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_123)] +theorem common_sub_126 : commonEnvelope childrenD_126 ⊆ insert (1, 2) required_126 := by decide +kernel +theorem child_required_sub_126 : ∀ j, childrenC_126 j ⊆ insert (1, 2) required_126 := by decide +kernel +theorem child_envelope_sub_126 : ∀ j, childrenD_126 j ⊆ envelope_126 := by decide +kernel +theorem pivot_mem_126 : (1, 2) ∈ envelope_126 := by decide +kernel +theorem children_work_126 : ∀ j, Template HasSnaky 2 (childrenC_126 j) (childrenD_126 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_123 1 (0, 1)).mono (by decide +kernel) +theorem row_works_126 : Template HasSnaky 3 required_126 envelope_126 := by + refine compose HasSnaky 2 childrenC_126 childrenD_126 children_work_126 (1, 2) + required_126 envelope_126 pivot_mem_126 child_required_sub_126 child_envelope_sub_126 ?_ + intro b hb + exact common_sub_126 (mem_commonEnvelope childrenD_126 b hb) +def required_130 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_130 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_130 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_3), required_129] +def childrenD_130 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_3), envelope_129] +theorem common_sub_130 : commonEnvelope childrenD_130 ⊆ insert (1, 4) required_130 := by decide +kernel +theorem child_required_sub_130 : ∀ j, childrenC_130 j ⊆ insert (1, 4) required_130 := by decide +kernel +theorem child_envelope_sub_130 : ∀ j, childrenD_130 j ⊆ envelope_130 := by decide +kernel +theorem pivot_mem_130 : (1, 4) ∈ envelope_130 := by decide +kernel +theorem children_work_130 : ∀ j, Template HasSnaky 2 (childrenC_130 j) (childrenD_130 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact row_works_129.mono (by decide +kernel) +theorem row_works_130 : Template HasSnaky 3 required_130 envelope_130 := by + refine compose HasSnaky 2 childrenC_130 childrenD_130 children_work_130 (1, 4) + required_130 envelope_130 pivot_mem_130 child_required_sub_130 child_envelope_sub_130 ?_ + intro b hb + exact common_sub_130 (mem_commonEnvelope childrenD_130 b hb) +def required_131 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_131 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_131 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_0), required_15] +def childrenD_131 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_0), envelope_15] +theorem common_sub_131 : commonEnvelope childrenD_131 ⊆ insert (1, 3) required_131 := by decide +kernel +theorem child_required_sub_131 : ∀ j, childrenC_131 j ⊆ insert (1, 3) required_131 := by decide +kernel +theorem child_envelope_sub_131 : ∀ j, childrenD_131 j ⊆ envelope_131 := by decide +kernel +theorem pivot_mem_131 : (1, 3) ∈ envelope_131 := by decide +kernel +theorem children_work_131 : ∀ j, Template HasSnaky 2 (childrenC_131 j) (childrenD_131 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 2)).mono (by decide +kernel) + · exact row_works_15.mono (by decide +kernel) +theorem row_works_131 : Template HasSnaky 3 required_131 envelope_131 := by + refine compose HasSnaky 2 childrenC_131 childrenD_131 children_work_131 (1, 3) + required_131 envelope_131 pivot_mem_131 child_required_sub_131 child_envelope_sub_131 ?_ + intro b hb + exact common_sub_131 (mem_commonEnvelope childrenD_131 b hb) +def required_139 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_139 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_139 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 1) required_138)] +def childrenD_139 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 1) envelope_138)] +theorem common_sub_139 : commonEnvelope childrenD_139 ⊆ insert (1, 3) required_139 := by decide +kernel +theorem child_required_sub_139 : ∀ j, childrenC_139 j ⊆ insert (1, 3) required_139 := by decide +kernel +theorem child_envelope_sub_139 : ∀ j, childrenD_139 j ⊆ envelope_139 := by decide +kernel +theorem pivot_mem_139 : (1, 3) ∈ envelope_139 := by decide +kernel +theorem children_work_139 : ∀ j, Template HasSnaky 2 (childrenC_139 j) (childrenD_139 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_138 0 (0, 1)).mono (by decide +kernel) +theorem row_works_139 : Template HasSnaky 3 required_139 envelope_139 := by + refine compose HasSnaky 2 childrenC_139 childrenD_139 children_work_139 (1, 3) + required_139 envelope_139 pivot_mem_139 child_required_sub_139 child_envelope_sub_139 ?_ + intro b hb + exact common_sub_139 (mem_commonEnvelope childrenD_139 b hb) +def required_140 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_140 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_140 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 1) required_43)] +def childrenD_140 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 1) envelope_43)] +theorem common_sub_140 : commonEnvelope childrenD_140 ⊆ insert (1, 3) required_140 := by decide +kernel +theorem child_required_sub_140 : ∀ j, childrenC_140 j ⊆ insert (1, 3) required_140 := by decide +kernel +theorem child_envelope_sub_140 : ∀ j, childrenD_140 j ⊆ envelope_140 := by decide +kernel +theorem pivot_mem_140 : (1, 3) ∈ envelope_140 := by decide +kernel +theorem children_work_140 : ∀ j, Template HasSnaky 2 (childrenC_140 j) (childrenD_140 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_43 0 (0, 1)).mono (by decide +kernel) +theorem row_works_140 : Template HasSnaky 3 required_140 envelope_140 := by + refine compose HasSnaky 2 childrenC_140 childrenD_140 children_work_140 (1, 3) + required_140 envelope_140 pivot_mem_140 child_required_sub_140 child_envelope_sub_140 ?_ + intro b hb + exact common_sub_140 (mem_commonEnvelope childrenD_140 b hb) +def required_143 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_143 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (5, 1), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_143 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_6), (placed21 3 (0, 1) required_11)] +def childrenD_143 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_6), (placed21 3 (0, 1) envelope_11)] +theorem common_sub_143 : commonEnvelope childrenD_143 ⊆ insert (4, 1) required_143 := by decide +kernel +theorem child_required_sub_143 : ∀ j, childrenC_143 j ⊆ insert (4, 1) required_143 := by decide +kernel +theorem child_envelope_sub_143 : ∀ j, childrenD_143 j ⊆ envelope_143 := by decide +kernel +theorem pivot_mem_143 : (4, 1) ∈ envelope_143 := by decide +kernel +theorem children_work_143 : ∀ j, Template HasSnaky 2 (childrenC_143 j) (childrenD_143 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_11 3 (0, 1)).mono (by decide +kernel) +theorem row_works_143 : Template HasSnaky 3 required_143 envelope_143 := by + refine compose HasSnaky 2 childrenC_143 childrenD_143 children_work_143 (4, 1) + required_143 envelope_143 pivot_mem_143 child_required_sub_143 child_envelope_sub_143 ?_ + intro b hb + exact common_sub_143 (mem_commonEnvelope childrenD_143 b hb) +def required_157 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_157 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (5, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_157 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_4), (placed21 0 (1, 0) required_156)] +def childrenD_157 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_4), (placed21 0 (1, 0) envelope_156)] +theorem common_sub_157 : commonEnvelope childrenD_157 ⊆ insert (4, 0) required_157 := by decide +kernel +theorem child_required_sub_157 : ∀ j, childrenC_157 j ⊆ insert (4, 0) required_157 := by decide +kernel +theorem child_envelope_sub_157 : ∀ j, childrenD_157 j ⊆ envelope_157 := by decide +kernel +theorem pivot_mem_157 : (4, 0) ∈ envelope_157 := by decide +kernel +theorem children_work_157 : ∀ j, Template HasSnaky 2 (childrenC_157 j) (childrenD_157 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_156 0 (1, 0)).mono (by decide +kernel) +theorem row_works_157 : Template HasSnaky 3 required_157 envelope_157 := by + refine compose HasSnaky 2 childrenC_157 childrenD_157 children_work_157 (4, 0) + required_157 envelope_157 pivot_mem_157 child_required_sub_157 child_envelope_sub_157 ?_ + intro b hb + exact common_sub_157 (mem_commonEnvelope childrenD_157 b hb) +def required_158 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_158 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_158 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_6), (placed21 4 (0, 5) required_6)] +def childrenD_158 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_6), (placed21 4 (0, 5) envelope_6)] +theorem common_sub_158 : commonEnvelope childrenD_158 ⊆ insert (0, 4) required_158 := by decide +kernel +theorem child_required_sub_158 : ∀ j, childrenC_158 j ⊆ insert (0, 4) required_158 := by decide +kernel +theorem child_envelope_sub_158 : ∀ j, childrenD_158 j ⊆ envelope_158 := by decide +kernel +theorem pivot_mem_158 : (0, 4) ∈ envelope_158 := by decide +kernel +theorem children_work_158 : ∀ j, Template HasSnaky 2 (childrenC_158 j) (childrenD_158 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_6 4 (0, 5)).mono (by decide +kernel) +theorem row_works_158 : Template HasSnaky 3 required_158 envelope_158 := by + refine compose HasSnaky 2 childrenC_158 childrenD_158 children_work_158 (0, 4) + required_158 envelope_158 pivot_mem_158 child_required_sub_158 child_envelope_sub_158 ?_ + intro b hb + exact common_sub_158 (mem_commonEnvelope childrenD_158 b hb) +def required_159 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_159 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (4, 1), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_159 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_23), (placed21 0 (1, 0) required_66)] +def childrenD_159 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_23), (placed21 0 (1, 0) envelope_66)] +theorem common_sub_159 : commonEnvelope childrenD_159 ⊆ insert (3, 1) required_159 := by decide +kernel +theorem child_required_sub_159 : ∀ j, childrenC_159 j ⊆ insert (3, 1) required_159 := by decide +kernel +theorem child_envelope_sub_159 : ∀ j, childrenD_159 j ⊆ envelope_159 := by decide +kernel +theorem pivot_mem_159 : (3, 1) ∈ envelope_159 := by decide +kernel +theorem children_work_159 : ∀ j, Template HasSnaky 2 (childrenC_159 j) (childrenD_159 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_23 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_66 0 (1, 0)).mono (by decide +kernel) +theorem row_works_159 : Template HasSnaky 3 required_159 envelope_159 := by + refine compose HasSnaky 2 childrenC_159 childrenD_159 children_work_159 (3, 1) + required_159 envelope_159 pivot_mem_159 child_required_sub_159 child_envelope_sub_159 ?_ + intro b hb + exact common_sub_159 (mem_commonEnvelope childrenD_159 b hb) +def required_160 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (1, 4), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_160 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_160 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 4 (1, 5) required_11)] +def childrenD_160 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 4 (1, 5) envelope_11)] +theorem common_sub_160 : commonEnvelope childrenD_160 ⊆ insert (1, 2) required_160 := by decide +kernel +theorem child_required_sub_160 : ∀ j, childrenC_160 j ⊆ insert (1, 2) required_160 := by decide +kernel +theorem child_envelope_sub_160 : ∀ j, childrenD_160 j ⊆ envelope_160 := by decide +kernel +theorem pivot_mem_160 : (1, 2) ∈ envelope_160 := by decide +kernel +theorem children_work_160 : ∀ j, Template HasSnaky 2 (childrenC_160 j) (childrenD_160 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_11 4 (1, 5)).mono (by decide +kernel) +theorem row_works_160 : Template HasSnaky 3 required_160 envelope_160 := by + refine compose HasSnaky 2 childrenC_160 childrenD_160 children_work_160 (1, 2) + required_160 envelope_160 pivot_mem_160 child_required_sub_160 child_envelope_sub_160 ?_ + intro b hb + exact common_sub_160 (mem_commonEnvelope childrenD_160 b hb) +def required_163 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_163 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_163 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_3), required_129] +def childrenD_163 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_3), envelope_129] +theorem common_sub_163 : commonEnvelope childrenD_163 ⊆ insert (0, 2) required_163 := by decide +kernel +theorem child_required_sub_163 : ∀ j, childrenC_163 j ⊆ insert (0, 2) required_163 := by decide +kernel +theorem child_envelope_sub_163 : ∀ j, childrenD_163 j ⊆ envelope_163 := by decide +kernel +theorem pivot_mem_163 : (0, 2) ∈ envelope_163 := by decide +kernel +theorem children_work_163 : ∀ j, Template HasSnaky 2 (childrenC_163 j) (childrenD_163 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact row_works_129.mono (by decide +kernel) +theorem row_works_163 : Template HasSnaky 3 required_163 envelope_163 := by + refine compose HasSnaky 2 childrenC_163 childrenD_163 children_work_163 (0, 2) + required_163 envelope_163 pivot_mem_163 child_required_sub_163 child_envelope_sub_163 ?_ + intro b hb + exact common_sub_163 (mem_commonEnvelope childrenD_163 b hb) +def required_177 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_177 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_177 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_0), required_23] +def childrenD_177 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_0), envelope_23] +theorem common_sub_177 : commonEnvelope childrenD_177 ⊆ insert (1, 1) required_177 := by decide +kernel +theorem child_required_sub_177 : ∀ j, childrenC_177 j ⊆ insert (1, 1) required_177 := by decide +kernel +theorem child_envelope_sub_177 : ∀ j, childrenD_177 j ⊆ envelope_177 := by decide +kernel +theorem pivot_mem_177 : (1, 1) ∈ envelope_177 := by decide +kernel +theorem children_work_177 : ∀ j, Template HasSnaky 2 (childrenC_177 j) (childrenD_177 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 2)).mono (by decide +kernel) + · exact row_works_23.mono (by decide +kernel) +theorem row_works_177 : Template HasSnaky 3 required_177 envelope_177 := by + refine compose HasSnaky 2 childrenC_177 childrenD_177 children_work_177 (1, 1) + required_177 envelope_177 pivot_mem_177 child_required_sub_177 child_envelope_sub_177 ?_ + intro b hb + exact common_sub_177 (mem_commonEnvelope childrenD_177 b hb) +def required_198 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_198 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_198 : Fin 2 → Finset Cell := ![(placed21 7 (1, 6) required_0), (placed21 4 (1, 5) required_6)] +def childrenD_198 : Fin 2 → Finset Cell := ![(placed21 7 (1, 6) envelope_0), (placed21 4 (1, 5) envelope_6)] +theorem common_sub_198 : commonEnvelope childrenD_198 ⊆ insert (1, 5) required_198 := by decide +kernel +theorem child_required_sub_198 : ∀ j, childrenC_198 j ⊆ insert (1, 5) required_198 := by decide +kernel +theorem child_envelope_sub_198 : ∀ j, childrenD_198 j ⊆ envelope_198 := by decide +kernel +theorem pivot_mem_198 : (1, 5) ∈ envelope_198 := by decide +kernel +theorem children_work_198 : ∀ j, Template HasSnaky 2 (childrenC_198 j) (childrenD_198 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_6 4 (1, 5)).mono (by decide +kernel) +theorem row_works_198 : Template HasSnaky 3 required_198 envelope_198 := by + refine compose HasSnaky 2 childrenC_198 childrenD_198 children_work_198 (1, 5) + required_198 envelope_198 pivot_mem_198 child_required_sub_198 child_envelope_sub_198 ?_ + intro b hb + exact common_sub_198 (mem_commonEnvelope childrenD_198 b hb) +def required_201 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (3, 1), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_201 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_201 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), (placed21 5 (4, 0) required_146)] +def childrenD_201 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), (placed21 5 (4, 0) envelope_146)] +theorem common_sub_201 : commonEnvelope childrenD_201 ⊆ insert (3, 0) required_201 := by decide +kernel +theorem child_required_sub_201 : ∀ j, childrenC_201 j ⊆ insert (3, 0) required_201 := by decide +kernel +theorem child_envelope_sub_201 : ∀ j, childrenD_201 j ⊆ envelope_201 := by decide +kernel +theorem pivot_mem_201 : (3, 0) ∈ envelope_201 := by decide +kernel +theorem children_work_201 : ∀ j, Template HasSnaky 2 (childrenC_201 j) (childrenD_201 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_146 5 (4, 0)).mono (by decide +kernel) +theorem row_works_201 : Template HasSnaky 3 required_201 envelope_201 := by + refine compose HasSnaky 2 childrenC_201 childrenD_201 children_work_201 (3, 0) + required_201 envelope_201 pivot_mem_201 child_required_sub_201 child_envelope_sub_201 ?_ + intro b hb + exact common_sub_201 (mem_commonEnvelope childrenD_201 b hb) +def required_205 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_205 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_205 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) required_6), (placed21 2 (1, 2) required_23)] +def childrenD_205 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) envelope_6), (placed21 2 (1, 2) envelope_23)] +theorem common_sub_205 : commonEnvelope childrenD_205 ⊆ insert (1, 5) required_205 := by decide +kernel +theorem child_required_sub_205 : ∀ j, childrenC_205 j ⊆ insert (1, 5) required_205 := by decide +kernel +theorem child_envelope_sub_205 : ∀ j, childrenD_205 j ⊆ envelope_205 := by decide +kernel +theorem pivot_mem_205 : (1, 5) ∈ envelope_205 := by decide +kernel +theorem children_work_205 : ∀ j, Template HasSnaky 2 (childrenC_205 j) (childrenD_205 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 4 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_23 2 (1, 2)).mono (by decide +kernel) +theorem row_works_205 : Template HasSnaky 3 required_205 envelope_205 := by + refine compose HasSnaky 2 childrenC_205 childrenD_205 children_work_205 (1, 5) + required_205 envelope_205 pivot_mem_205 child_required_sub_205 child_envelope_sub_205 ?_ + intro b hb + exact common_sub_205 (mem_commonEnvelope childrenD_205 b hb) +def required_207 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (3, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_207 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_207 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), (placed21 5 (4, 0) required_77)] +def childrenD_207 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), (placed21 5 (4, 0) envelope_77)] +theorem common_sub_207 : commonEnvelope childrenD_207 ⊆ insert (3, 1) required_207 := by decide +kernel +theorem child_required_sub_207 : ∀ j, childrenC_207 j ⊆ insert (3, 1) required_207 := by decide +kernel +theorem child_envelope_sub_207 : ∀ j, childrenD_207 j ⊆ envelope_207 := by decide +kernel +theorem pivot_mem_207 : (3, 1) ∈ envelope_207 := by decide +kernel +theorem children_work_207 : ∀ j, Template HasSnaky 2 (childrenC_207 j) (childrenD_207 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_77 5 (4, 0)).mono (by decide +kernel) +theorem row_works_207 : Template HasSnaky 3 required_207 envelope_207 := by + refine compose HasSnaky 2 childrenC_207 childrenD_207 children_work_207 (3, 1) + required_207 envelope_207 pivot_mem_207 child_required_sub_207 child_envelope_sub_207 ?_ + intro b hb + exact common_sub_207 (mem_commonEnvelope childrenD_207 b hb) +def required_209 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_209 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_209 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), (placed21 6 (1, 4) required_138)] +def childrenD_209 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), (placed21 6 (1, 4) envelope_138)] +theorem common_sub_209 : commonEnvelope childrenD_209 ⊆ insert (1, 4) required_209 := by decide +kernel +theorem child_required_sub_209 : ∀ j, childrenC_209 j ⊆ insert (1, 4) required_209 := by decide +kernel +theorem child_envelope_sub_209 : ∀ j, childrenD_209 j ⊆ envelope_209 := by decide +kernel +theorem pivot_mem_209 : (1, 4) ∈ envelope_209 := by decide +kernel +theorem children_work_209 : ∀ j, Template HasSnaky 2 (childrenC_209 j) (childrenD_209 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_138 6 (1, 4)).mono (by decide +kernel) +theorem row_works_209 : Template HasSnaky 3 required_209 envelope_209 := by + refine compose HasSnaky 2 childrenC_209 childrenD_209 children_work_209 (1, 4) + required_209 envelope_209 pivot_mem_209 child_required_sub_209 child_envelope_sub_209 ?_ + intro b hb + exact common_sub_209 (mem_commonEnvelope childrenD_209 b hb) +def required_212 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_212 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_212 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 0 (0, 1) required_76)] +def childrenD_212 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 0 (0, 1) envelope_76)] +theorem common_sub_212 : commonEnvelope childrenD_212 ⊆ insert (1, 4) required_212 := by decide +kernel +theorem child_required_sub_212 : ∀ j, childrenC_212 j ⊆ insert (1, 4) required_212 := by decide +kernel +theorem child_envelope_sub_212 : ∀ j, childrenD_212 j ⊆ envelope_212 := by decide +kernel +theorem pivot_mem_212 : (1, 4) ∈ envelope_212 := by decide +kernel +theorem children_work_212 : ∀ j, Template HasSnaky 2 (childrenC_212 j) (childrenD_212 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_76 0 (0, 1)).mono (by decide +kernel) +theorem row_works_212 : Template HasSnaky 3 required_212 envelope_212 := by + refine compose HasSnaky 2 childrenC_212 childrenD_212 children_work_212 (1, 4) + required_212 envelope_212 pivot_mem_212 child_required_sub_212 child_envelope_sub_212 ?_ + intro b hb + exact common_sub_212 (mem_commonEnvelope childrenD_212 b hb) +def required_215 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_215 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_215 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_5), (placed21 2 (3, 0) required_11)] +def childrenD_215 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_5), (placed21 2 (3, 0) envelope_11)] +theorem common_sub_215 : commonEnvelope childrenD_215 ⊆ insert (3, 1) required_215 := by decide +kernel +theorem child_required_sub_215 : ∀ j, childrenC_215 j ⊆ insert (3, 1) required_215 := by decide +kernel +theorem child_envelope_sub_215 : ∀ j, childrenD_215 j ⊆ envelope_215 := by decide +kernel +theorem pivot_mem_215 : (3, 1) ∈ envelope_215 := by decide +kernel +theorem children_work_215 : ∀ j, Template HasSnaky 2 (childrenC_215 j) (childrenD_215 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_11 2 (3, 0)).mono (by decide +kernel) +theorem row_works_215 : Template HasSnaky 3 required_215 envelope_215 := by + refine compose HasSnaky 2 childrenC_215 childrenD_215 children_work_215 (3, 1) + required_215 envelope_215 pivot_mem_215 child_required_sub_215 child_envelope_sub_215 ?_ + intro b hb + exact common_sub_215 (mem_commonEnvelope childrenD_215 b hb) +def required_218 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (1, 1), (1, 3), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_218 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_218 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_0), (placed21 4 (0, 4) required_83)] +def childrenD_218 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_0), (placed21 4 (0, 4) envelope_83)] +theorem common_sub_218 : commonEnvelope childrenD_218 ⊆ insert (1, 2) required_218 := by decide +kernel +theorem child_required_sub_218 : ∀ j, childrenC_218 j ⊆ insert (1, 2) required_218 := by decide +kernel +theorem child_envelope_sub_218 : ∀ j, childrenD_218 j ⊆ envelope_218 := by decide +kernel +theorem pivot_mem_218 : (1, 2) ∈ envelope_218 := by decide +kernel +theorem children_work_218 : ∀ j, Template HasSnaky 2 (childrenC_218 j) (childrenD_218 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_83 4 (0, 4)).mono (by decide +kernel) +theorem row_works_218 : Template HasSnaky 3 required_218 envelope_218 := by + refine compose HasSnaky 2 childrenC_218 childrenD_218 children_work_218 (1, 2) + required_218 envelope_218 pivot_mem_218 child_required_sub_218 child_envelope_sub_218 ?_ + intro b hb + exact common_sub_218 (mem_commonEnvelope childrenD_218 b hb) +def required_219 : Finset Cell := ⟨(([(0, 0), (0, 3), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_219 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_219 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_4), (placed21 6 (1, 5) required_11)] +def childrenD_219 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_4), (placed21 6 (1, 5) envelope_11)] +theorem common_sub_219 : commonEnvelope childrenD_219 ⊆ insert (1, 1) required_219 := by decide +kernel +theorem child_required_sub_219 : ∀ j, childrenC_219 j ⊆ insert (1, 1) required_219 := by decide +kernel +theorem child_envelope_sub_219 : ∀ j, childrenD_219 j ⊆ envelope_219 := by decide +kernel +theorem pivot_mem_219 : (1, 1) ∈ envelope_219 := by decide +kernel +theorem children_work_219 : ∀ j, Template HasSnaky 2 (childrenC_219 j) (childrenD_219 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_11 6 (1, 5)).mono (by decide +kernel) +theorem row_works_219 : Template HasSnaky 3 required_219 envelope_219 := by + refine compose HasSnaky 2 childrenC_219 childrenD_219 children_work_219 (1, 1) + required_219 envelope_219 pivot_mem_219 child_required_sub_219 child_envelope_sub_219 ?_ + intro b hb + exact common_sub_219 (mem_commonEnvelope childrenD_219 b hb) +def height_108 : ℕ := 3 +def childrenH_108 : Fin 2 → ℕ := ![height_15, height_102] +theorem height_exact_108 : height_108 = 1 + Finset.univ.sup childrenH_108 := by decide +kernel +theorem required_origin_108 : ∀ x ∈ required_108, + (∃ j, x ∈ childrenC_108 j) ∨ ∀ j, x ∈ childrenD_108 j := by decide +kernel +theorem required_exact_108 : required_108 = + ((Finset.univ.biUnion childrenC_108) ∪ commonEnvelope childrenD_108).erase (1, 1) := by + exact required_eq_combination childrenC_108 childrenD_108 (1, 1) required_108 + (by decide +kernel) child_required_sub_108 common_sub_108 required_origin_108 +theorem envelope_origin_108 : ∀ x ∈ envelope_108, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_108 j := by decide +kernel +theorem envelope_exact_108 : envelope_108 = + insert (1, 1) (Finset.univ.biUnion childrenD_108) := by + exact envelope_eq_combination childrenD_108 (1, 1) envelope_108 + pivot_mem_108 child_envelope_sub_108 envelope_origin_108 +def checked_108 : CheckedCard where + required := required_108 + envelope := envelope_108 + height := height_108 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_108 +def height_113 : ℕ := 3 +def childrenH_113 : Fin 2 → ℕ := ![height_0, height_23] +theorem height_exact_113 : height_113 = 1 + Finset.univ.sup childrenH_113 := by decide +kernel +theorem required_origin_113 : ∀ x ∈ required_113, + (∃ j, x ∈ childrenC_113 j) ∨ ∀ j, x ∈ childrenD_113 j := by decide +kernel +theorem required_exact_113 : required_113 = + ((Finset.univ.biUnion childrenC_113) ∪ commonEnvelope childrenD_113).erase (1, 3) := by + exact required_eq_combination childrenC_113 childrenD_113 (1, 3) required_113 + (by decide +kernel) child_required_sub_113 common_sub_113 required_origin_113 +theorem envelope_origin_113 : ∀ x ∈ envelope_113, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_113 j := by decide +kernel +theorem envelope_exact_113 : envelope_113 = + insert (1, 3) (Finset.univ.biUnion childrenD_113) := by + exact envelope_eq_combination childrenD_113 (1, 3) envelope_113 + pivot_mem_113 child_envelope_sub_113 envelope_origin_113 +def checked_113 : CheckedCard where + required := required_113 + envelope := envelope_113 + height := height_113 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_113 +def height_124 : ℕ := 3 +def childrenH_124 : Fin 2 → ℕ := ![height_5, height_123] +theorem height_exact_124 : height_124 = 1 + Finset.univ.sup childrenH_124 := by decide +kernel +theorem required_origin_124 : ∀ x ∈ required_124, + (∃ j, x ∈ childrenC_124 j) ∨ ∀ j, x ∈ childrenD_124 j := by decide +kernel +theorem required_exact_124 : required_124 = + ((Finset.univ.biUnion childrenC_124) ∪ commonEnvelope childrenD_124).erase (2, 1) := by + exact required_eq_combination childrenC_124 childrenD_124 (2, 1) required_124 + (by decide +kernel) child_required_sub_124 common_sub_124 required_origin_124 +theorem envelope_origin_124 : ∀ x ∈ envelope_124, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_124 j := by decide +kernel +theorem envelope_exact_124 : envelope_124 = + insert (2, 1) (Finset.univ.biUnion childrenD_124) := by + exact envelope_eq_combination childrenD_124 (2, 1) envelope_124 + pivot_mem_124 child_envelope_sub_124 envelope_origin_124 +def checked_124 : CheckedCard where + required := required_124 + envelope := envelope_124 + height := height_124 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_124 +def height_126 : ℕ := 3 +def childrenH_126 : Fin 2 → ℕ := ![height_5, height_123] +theorem height_exact_126 : height_126 = 1 + Finset.univ.sup childrenH_126 := by decide +kernel +theorem required_origin_126 : ∀ x ∈ required_126, + (∃ j, x ∈ childrenC_126 j) ∨ ∀ j, x ∈ childrenD_126 j := by decide +kernel +theorem required_exact_126 : required_126 = + ((Finset.univ.biUnion childrenC_126) ∪ commonEnvelope childrenD_126).erase (1, 2) := by + exact required_eq_combination childrenC_126 childrenD_126 (1, 2) required_126 + (by decide +kernel) child_required_sub_126 common_sub_126 required_origin_126 +theorem envelope_origin_126 : ∀ x ∈ envelope_126, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_126 j := by decide +kernel +theorem envelope_exact_126 : envelope_126 = + insert (1, 2) (Finset.univ.biUnion childrenD_126) := by + exact envelope_eq_combination childrenD_126 (1, 2) envelope_126 + pivot_mem_126 child_envelope_sub_126 envelope_origin_126 +def checked_126 : CheckedCard where + required := required_126 + envelope := envelope_126 + height := height_126 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_126 +def height_130 : ℕ := 3 +def childrenH_130 : Fin 2 → ℕ := ![height_3, height_129] +theorem height_exact_130 : height_130 = 1 + Finset.univ.sup childrenH_130 := by decide +kernel +theorem required_origin_130 : ∀ x ∈ required_130, + (∃ j, x ∈ childrenC_130 j) ∨ ∀ j, x ∈ childrenD_130 j := by decide +kernel +theorem required_exact_130 : required_130 = + ((Finset.univ.biUnion childrenC_130) ∪ commonEnvelope childrenD_130).erase (1, 4) := by + exact required_eq_combination childrenC_130 childrenD_130 (1, 4) required_130 + (by decide +kernel) child_required_sub_130 common_sub_130 required_origin_130 +theorem envelope_origin_130 : ∀ x ∈ envelope_130, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_130 j := by decide +kernel +theorem envelope_exact_130 : envelope_130 = + insert (1, 4) (Finset.univ.biUnion childrenD_130) := by + exact envelope_eq_combination childrenD_130 (1, 4) envelope_130 + pivot_mem_130 child_envelope_sub_130 envelope_origin_130 +def checked_130 : CheckedCard where + required := required_130 + envelope := envelope_130 + height := height_130 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_130 +def height_131 : ℕ := 3 +def childrenH_131 : Fin 2 → ℕ := ![height_0, height_15] +theorem height_exact_131 : height_131 = 1 + Finset.univ.sup childrenH_131 := by decide +kernel +theorem required_origin_131 : ∀ x ∈ required_131, + (∃ j, x ∈ childrenC_131 j) ∨ ∀ j, x ∈ childrenD_131 j := by decide +kernel +theorem required_exact_131 : required_131 = + ((Finset.univ.biUnion childrenC_131) ∪ commonEnvelope childrenD_131).erase (1, 3) := by + exact required_eq_combination childrenC_131 childrenD_131 (1, 3) required_131 + (by decide +kernel) child_required_sub_131 common_sub_131 required_origin_131 +theorem envelope_origin_131 : ∀ x ∈ envelope_131, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_131 j := by decide +kernel +theorem envelope_exact_131 : envelope_131 = + insert (1, 3) (Finset.univ.biUnion childrenD_131) := by + exact envelope_eq_combination childrenD_131 (1, 3) envelope_131 + pivot_mem_131 child_envelope_sub_131 envelope_origin_131 +def checked_131 : CheckedCard where + required := required_131 + envelope := envelope_131 + height := height_131 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_131 +def height_139 : ℕ := 3 +def childrenH_139 : Fin 2 → ℕ := ![height_0, height_138] +theorem height_exact_139 : height_139 = 1 + Finset.univ.sup childrenH_139 := by decide +kernel +theorem required_origin_139 : ∀ x ∈ required_139, + (∃ j, x ∈ childrenC_139 j) ∨ ∀ j, x ∈ childrenD_139 j := by decide +kernel +theorem required_exact_139 : required_139 = + ((Finset.univ.biUnion childrenC_139) ∪ commonEnvelope childrenD_139).erase (1, 3) := by + exact required_eq_combination childrenC_139 childrenD_139 (1, 3) required_139 + (by decide +kernel) child_required_sub_139 common_sub_139 required_origin_139 +theorem envelope_origin_139 : ∀ x ∈ envelope_139, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_139 j := by decide +kernel +theorem envelope_exact_139 : envelope_139 = + insert (1, 3) (Finset.univ.biUnion childrenD_139) := by + exact envelope_eq_combination childrenD_139 (1, 3) envelope_139 + pivot_mem_139 child_envelope_sub_139 envelope_origin_139 +def checked_139 : CheckedCard where + required := required_139 + envelope := envelope_139 + height := height_139 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_139 +def height_140 : ℕ := 3 +def childrenH_140 : Fin 2 → ℕ := ![height_0, height_43] +theorem height_exact_140 : height_140 = 1 + Finset.univ.sup childrenH_140 := by decide +kernel +theorem required_origin_140 : ∀ x ∈ required_140, + (∃ j, x ∈ childrenC_140 j) ∨ ∀ j, x ∈ childrenD_140 j := by decide +kernel +theorem required_exact_140 : required_140 = + ((Finset.univ.biUnion childrenC_140) ∪ commonEnvelope childrenD_140).erase (1, 3) := by + exact required_eq_combination childrenC_140 childrenD_140 (1, 3) required_140 + (by decide +kernel) child_required_sub_140 common_sub_140 required_origin_140 +theorem envelope_origin_140 : ∀ x ∈ envelope_140, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_140 j := by decide +kernel +theorem envelope_exact_140 : envelope_140 = + insert (1, 3) (Finset.univ.biUnion childrenD_140) := by + exact envelope_eq_combination childrenD_140 (1, 3) envelope_140 + pivot_mem_140 child_envelope_sub_140 envelope_origin_140 +def checked_140 : CheckedCard where + required := required_140 + envelope := envelope_140 + height := height_140 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_140 +def height_143 : ℕ := 3 +def childrenH_143 : Fin 2 → ℕ := ![height_6, height_11] +theorem height_exact_143 : height_143 = 1 + Finset.univ.sup childrenH_143 := by decide +kernel +theorem required_origin_143 : ∀ x ∈ required_143, + (∃ j, x ∈ childrenC_143 j) ∨ ∀ j, x ∈ childrenD_143 j := by decide +kernel +theorem required_exact_143 : required_143 = + ((Finset.univ.biUnion childrenC_143) ∪ commonEnvelope childrenD_143).erase (4, 1) := by + exact required_eq_combination childrenC_143 childrenD_143 (4, 1) required_143 + (by decide +kernel) child_required_sub_143 common_sub_143 required_origin_143 +theorem envelope_origin_143 : ∀ x ∈ envelope_143, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_143 j := by decide +kernel +theorem envelope_exact_143 : envelope_143 = + insert (4, 1) (Finset.univ.biUnion childrenD_143) := by + exact envelope_eq_combination childrenD_143 (4, 1) envelope_143 + pivot_mem_143 child_envelope_sub_143 envelope_origin_143 +def checked_143 : CheckedCard where + required := required_143 + envelope := envelope_143 + height := height_143 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_143 +def height_157 : ℕ := 3 +def childrenH_157 : Fin 2 → ℕ := ![height_4, height_156] +theorem height_exact_157 : height_157 = 1 + Finset.univ.sup childrenH_157 := by decide +kernel +theorem required_origin_157 : ∀ x ∈ required_157, + (∃ j, x ∈ childrenC_157 j) ∨ ∀ j, x ∈ childrenD_157 j := by decide +kernel +theorem required_exact_157 : required_157 = + ((Finset.univ.biUnion childrenC_157) ∪ commonEnvelope childrenD_157).erase (4, 0) := by + exact required_eq_combination childrenC_157 childrenD_157 (4, 0) required_157 + (by decide +kernel) child_required_sub_157 common_sub_157 required_origin_157 +theorem envelope_origin_157 : ∀ x ∈ envelope_157, + x = (4, 0) ∨ ∃ j, x ∈ childrenD_157 j := by decide +kernel +theorem envelope_exact_157 : envelope_157 = + insert (4, 0) (Finset.univ.biUnion childrenD_157) := by + exact envelope_eq_combination childrenD_157 (4, 0) envelope_157 + pivot_mem_157 child_envelope_sub_157 envelope_origin_157 +def checked_157 : CheckedCard where + required := required_157 + envelope := envelope_157 + height := height_157 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_157 +def height_158 : ℕ := 3 +def childrenH_158 : Fin 2 → ℕ := ![height_6, height_6] +theorem height_exact_158 : height_158 = 1 + Finset.univ.sup childrenH_158 := by decide +kernel +theorem required_origin_158 : ∀ x ∈ required_158, + (∃ j, x ∈ childrenC_158 j) ∨ ∀ j, x ∈ childrenD_158 j := by decide +kernel +theorem required_exact_158 : required_158 = + ((Finset.univ.biUnion childrenC_158) ∪ commonEnvelope childrenD_158).erase (0, 4) := by + exact required_eq_combination childrenC_158 childrenD_158 (0, 4) required_158 + (by decide +kernel) child_required_sub_158 common_sub_158 required_origin_158 +theorem envelope_origin_158 : ∀ x ∈ envelope_158, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_158 j := by decide +kernel +theorem envelope_exact_158 : envelope_158 = + insert (0, 4) (Finset.univ.biUnion childrenD_158) := by + exact envelope_eq_combination childrenD_158 (0, 4) envelope_158 + pivot_mem_158 child_envelope_sub_158 envelope_origin_158 +def checked_158 : CheckedCard where + required := required_158 + envelope := envelope_158 + height := height_158 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_158 +def height_159 : ℕ := 3 +def childrenH_159 : Fin 2 → ℕ := ![height_23, height_66] +theorem height_exact_159 : height_159 = 1 + Finset.univ.sup childrenH_159 := by decide +kernel +theorem required_origin_159 : ∀ x ∈ required_159, + (∃ j, x ∈ childrenC_159 j) ∨ ∀ j, x ∈ childrenD_159 j := by decide +kernel +theorem required_exact_159 : required_159 = + ((Finset.univ.biUnion childrenC_159) ∪ commonEnvelope childrenD_159).erase (3, 1) := by + exact required_eq_combination childrenC_159 childrenD_159 (3, 1) required_159 + (by decide +kernel) child_required_sub_159 common_sub_159 required_origin_159 +theorem envelope_origin_159 : ∀ x ∈ envelope_159, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_159 j := by decide +kernel +theorem envelope_exact_159 : envelope_159 = + insert (3, 1) (Finset.univ.biUnion childrenD_159) := by + exact envelope_eq_combination childrenD_159 (3, 1) envelope_159 + pivot_mem_159 child_envelope_sub_159 envelope_origin_159 +def checked_159 : CheckedCard where + required := required_159 + envelope := envelope_159 + height := height_159 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_159 +def height_160 : ℕ := 3 +def childrenH_160 : Fin 2 → ℕ := ![height_5, height_11] +theorem height_exact_160 : height_160 = 1 + Finset.univ.sup childrenH_160 := by decide +kernel +theorem required_origin_160 : ∀ x ∈ required_160, + (∃ j, x ∈ childrenC_160 j) ∨ ∀ j, x ∈ childrenD_160 j := by decide +kernel +theorem required_exact_160 : required_160 = + ((Finset.univ.biUnion childrenC_160) ∪ commonEnvelope childrenD_160).erase (1, 2) := by + exact required_eq_combination childrenC_160 childrenD_160 (1, 2) required_160 + (by decide +kernel) child_required_sub_160 common_sub_160 required_origin_160 +theorem envelope_origin_160 : ∀ x ∈ envelope_160, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_160 j := by decide +kernel +theorem envelope_exact_160 : envelope_160 = + insert (1, 2) (Finset.univ.biUnion childrenD_160) := by + exact envelope_eq_combination childrenD_160 (1, 2) envelope_160 + pivot_mem_160 child_envelope_sub_160 envelope_origin_160 +def checked_160 : CheckedCard where + required := required_160 + envelope := envelope_160 + height := height_160 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_160 +def height_163 : ℕ := 3 +def childrenH_163 : Fin 2 → ℕ := ![height_3, height_129] +theorem height_exact_163 : height_163 = 1 + Finset.univ.sup childrenH_163 := by decide +kernel +theorem required_origin_163 : ∀ x ∈ required_163, + (∃ j, x ∈ childrenC_163 j) ∨ ∀ j, x ∈ childrenD_163 j := by decide +kernel +theorem required_exact_163 : required_163 = + ((Finset.univ.biUnion childrenC_163) ∪ commonEnvelope childrenD_163).erase (0, 2) := by + exact required_eq_combination childrenC_163 childrenD_163 (0, 2) required_163 + (by decide +kernel) child_required_sub_163 common_sub_163 required_origin_163 +theorem envelope_origin_163 : ∀ x ∈ envelope_163, + x = (0, 2) ∨ ∃ j, x ∈ childrenD_163 j := by decide +kernel +theorem envelope_exact_163 : envelope_163 = + insert (0, 2) (Finset.univ.biUnion childrenD_163) := by + exact envelope_eq_combination childrenD_163 (0, 2) envelope_163 + pivot_mem_163 child_envelope_sub_163 envelope_origin_163 +def checked_163 : CheckedCard where + required := required_163 + envelope := envelope_163 + height := height_163 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_163 +def height_177 : ℕ := 3 +def childrenH_177 : Fin 2 → ℕ := ![height_0, height_23] +theorem height_exact_177 : height_177 = 1 + Finset.univ.sup childrenH_177 := by decide +kernel +theorem required_origin_177 : ∀ x ∈ required_177, + (∃ j, x ∈ childrenC_177 j) ∨ ∀ j, x ∈ childrenD_177 j := by decide +kernel +theorem required_exact_177 : required_177 = + ((Finset.univ.biUnion childrenC_177) ∪ commonEnvelope childrenD_177).erase (1, 1) := by + exact required_eq_combination childrenC_177 childrenD_177 (1, 1) required_177 + (by decide +kernel) child_required_sub_177 common_sub_177 required_origin_177 +theorem envelope_origin_177 : ∀ x ∈ envelope_177, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_177 j := by decide +kernel +theorem envelope_exact_177 : envelope_177 = + insert (1, 1) (Finset.univ.biUnion childrenD_177) := by + exact envelope_eq_combination childrenD_177 (1, 1) envelope_177 + pivot_mem_177 child_envelope_sub_177 envelope_origin_177 +def checked_177 : CheckedCard where + required := required_177 + envelope := envelope_177 + height := height_177 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_177 +def height_198 : ℕ := 3 +def childrenH_198 : Fin 2 → ℕ := ![height_0, height_6] +theorem height_exact_198 : height_198 = 1 + Finset.univ.sup childrenH_198 := by decide +kernel +theorem required_origin_198 : ∀ x ∈ required_198, + (∃ j, x ∈ childrenC_198 j) ∨ ∀ j, x ∈ childrenD_198 j := by decide +kernel +theorem required_exact_198 : required_198 = + ((Finset.univ.biUnion childrenC_198) ∪ commonEnvelope childrenD_198).erase (1, 5) := by + exact required_eq_combination childrenC_198 childrenD_198 (1, 5) required_198 + (by decide +kernel) child_required_sub_198 common_sub_198 required_origin_198 +theorem envelope_origin_198 : ∀ x ∈ envelope_198, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_198 j := by decide +kernel +theorem envelope_exact_198 : envelope_198 = + insert (1, 5) (Finset.univ.biUnion childrenD_198) := by + exact envelope_eq_combination childrenD_198 (1, 5) envelope_198 + pivot_mem_198 child_envelope_sub_198 envelope_origin_198 +def checked_198 : CheckedCard where + required := required_198 + envelope := envelope_198 + height := height_198 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_198 +def height_201 : ℕ := 3 +def childrenH_201 : Fin 2 → ℕ := ![height_5, height_146] +theorem height_exact_201 : height_201 = 1 + Finset.univ.sup childrenH_201 := by decide +kernel +theorem required_origin_201 : ∀ x ∈ required_201, + (∃ j, x ∈ childrenC_201 j) ∨ ∀ j, x ∈ childrenD_201 j := by decide +kernel +theorem required_exact_201 : required_201 = + ((Finset.univ.biUnion childrenC_201) ∪ commonEnvelope childrenD_201).erase (3, 0) := by + exact required_eq_combination childrenC_201 childrenD_201 (3, 0) required_201 + (by decide +kernel) child_required_sub_201 common_sub_201 required_origin_201 +theorem envelope_origin_201 : ∀ x ∈ envelope_201, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_201 j := by decide +kernel +theorem envelope_exact_201 : envelope_201 = + insert (3, 0) (Finset.univ.biUnion childrenD_201) := by + exact envelope_eq_combination childrenD_201 (3, 0) envelope_201 + pivot_mem_201 child_envelope_sub_201 envelope_origin_201 +def checked_201 : CheckedCard where + required := required_201 + envelope := envelope_201 + height := height_201 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_201 +def height_205 : ℕ := 3 +def childrenH_205 : Fin 2 → ℕ := ![height_6, height_23] +theorem height_exact_205 : height_205 = 1 + Finset.univ.sup childrenH_205 := by decide +kernel +theorem required_origin_205 : ∀ x ∈ required_205, + (∃ j, x ∈ childrenC_205 j) ∨ ∀ j, x ∈ childrenD_205 j := by decide +kernel +theorem required_exact_205 : required_205 = + ((Finset.univ.biUnion childrenC_205) ∪ commonEnvelope childrenD_205).erase (1, 5) := by + exact required_eq_combination childrenC_205 childrenD_205 (1, 5) required_205 + (by decide +kernel) child_required_sub_205 common_sub_205 required_origin_205 +theorem envelope_origin_205 : ∀ x ∈ envelope_205, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_205 j := by decide +kernel +theorem envelope_exact_205 : envelope_205 = + insert (1, 5) (Finset.univ.biUnion childrenD_205) := by + exact envelope_eq_combination childrenD_205 (1, 5) envelope_205 + pivot_mem_205 child_envelope_sub_205 envelope_origin_205 +def checked_205 : CheckedCard where + required := required_205 + envelope := envelope_205 + height := height_205 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_205 +def height_207 : ℕ := 3 +def childrenH_207 : Fin 2 → ℕ := ![height_5, height_77] +theorem height_exact_207 : height_207 = 1 + Finset.univ.sup childrenH_207 := by decide +kernel +theorem required_origin_207 : ∀ x ∈ required_207, + (∃ j, x ∈ childrenC_207 j) ∨ ∀ j, x ∈ childrenD_207 j := by decide +kernel +theorem required_exact_207 : required_207 = + ((Finset.univ.biUnion childrenC_207) ∪ commonEnvelope childrenD_207).erase (3, 1) := by + exact required_eq_combination childrenC_207 childrenD_207 (3, 1) required_207 + (by decide +kernel) child_required_sub_207 common_sub_207 required_origin_207 +theorem envelope_origin_207 : ∀ x ∈ envelope_207, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_207 j := by decide +kernel +theorem envelope_exact_207 : envelope_207 = + insert (3, 1) (Finset.univ.biUnion childrenD_207) := by + exact envelope_eq_combination childrenD_207 (3, 1) envelope_207 + pivot_mem_207 child_envelope_sub_207 envelope_origin_207 +def checked_207 : CheckedCard where + required := required_207 + envelope := envelope_207 + height := height_207 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_207 +def height_209 : ℕ := 3 +def childrenH_209 : Fin 2 → ℕ := ![height_0, height_138] +theorem height_exact_209 : height_209 = 1 + Finset.univ.sup childrenH_209 := by decide +kernel +theorem required_origin_209 : ∀ x ∈ required_209, + (∃ j, x ∈ childrenC_209 j) ∨ ∀ j, x ∈ childrenD_209 j := by decide +kernel +theorem required_exact_209 : required_209 = + ((Finset.univ.biUnion childrenC_209) ∪ commonEnvelope childrenD_209).erase (1, 4) := by + exact required_eq_combination childrenC_209 childrenD_209 (1, 4) required_209 + (by decide +kernel) child_required_sub_209 common_sub_209 required_origin_209 +theorem envelope_origin_209 : ∀ x ∈ envelope_209, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_209 j := by decide +kernel +theorem envelope_exact_209 : envelope_209 = + insert (1, 4) (Finset.univ.biUnion childrenD_209) := by + exact envelope_eq_combination childrenD_209 (1, 4) envelope_209 + pivot_mem_209 child_envelope_sub_209 envelope_origin_209 +def checked_209 : CheckedCard where + required := required_209 + envelope := envelope_209 + height := height_209 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_209 +def height_212 : ℕ := 3 +def childrenH_212 : Fin 2 → ℕ := ![height_5, height_76] +theorem height_exact_212 : height_212 = 1 + Finset.univ.sup childrenH_212 := by decide +kernel +theorem required_origin_212 : ∀ x ∈ required_212, + (∃ j, x ∈ childrenC_212 j) ∨ ∀ j, x ∈ childrenD_212 j := by decide +kernel +theorem required_exact_212 : required_212 = + ((Finset.univ.biUnion childrenC_212) ∪ commonEnvelope childrenD_212).erase (1, 4) := by + exact required_eq_combination childrenC_212 childrenD_212 (1, 4) required_212 + (by decide +kernel) child_required_sub_212 common_sub_212 required_origin_212 +theorem envelope_origin_212 : ∀ x ∈ envelope_212, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_212 j := by decide +kernel +theorem envelope_exact_212 : envelope_212 = + insert (1, 4) (Finset.univ.biUnion childrenD_212) := by + exact envelope_eq_combination childrenD_212 (1, 4) envelope_212 + pivot_mem_212 child_envelope_sub_212 envelope_origin_212 +def checked_212 : CheckedCard where + required := required_212 + envelope := envelope_212 + height := height_212 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_212 +def height_215 : ℕ := 3 +def childrenH_215 : Fin 2 → ℕ := ![height_5, height_11] +theorem height_exact_215 : height_215 = 1 + Finset.univ.sup childrenH_215 := by decide +kernel +theorem required_origin_215 : ∀ x ∈ required_215, + (∃ j, x ∈ childrenC_215 j) ∨ ∀ j, x ∈ childrenD_215 j := by decide +kernel +theorem required_exact_215 : required_215 = + ((Finset.univ.biUnion childrenC_215) ∪ commonEnvelope childrenD_215).erase (3, 1) := by + exact required_eq_combination childrenC_215 childrenD_215 (3, 1) required_215 + (by decide +kernel) child_required_sub_215 common_sub_215 required_origin_215 +theorem envelope_origin_215 : ∀ x ∈ envelope_215, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_215 j := by decide +kernel +theorem envelope_exact_215 : envelope_215 = + insert (3, 1) (Finset.univ.biUnion childrenD_215) := by + exact envelope_eq_combination childrenD_215 (3, 1) envelope_215 + pivot_mem_215 child_envelope_sub_215 envelope_origin_215 +def checked_215 : CheckedCard where + required := required_215 + envelope := envelope_215 + height := height_215 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_215 +def height_218 : ℕ := 3 +def childrenH_218 : Fin 2 → ℕ := ![height_0, height_83] +theorem height_exact_218 : height_218 = 1 + Finset.univ.sup childrenH_218 := by decide +kernel +theorem required_origin_218 : ∀ x ∈ required_218, + (∃ j, x ∈ childrenC_218 j) ∨ ∀ j, x ∈ childrenD_218 j := by decide +kernel +theorem required_exact_218 : required_218 = + ((Finset.univ.biUnion childrenC_218) ∪ commonEnvelope childrenD_218).erase (1, 2) := by + exact required_eq_combination childrenC_218 childrenD_218 (1, 2) required_218 + (by decide +kernel) child_required_sub_218 common_sub_218 required_origin_218 +theorem envelope_origin_218 : ∀ x ∈ envelope_218, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_218 j := by decide +kernel +theorem envelope_exact_218 : envelope_218 = + insert (1, 2) (Finset.univ.biUnion childrenD_218) := by + exact envelope_eq_combination childrenD_218 (1, 2) envelope_218 + pivot_mem_218 child_envelope_sub_218 envelope_origin_218 +def checked_218 : CheckedCard where + required := required_218 + envelope := envelope_218 + height := height_218 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_218 +def height_219 : ℕ := 3 +def childrenH_219 : Fin 2 → ℕ := ![height_4, height_11] +theorem height_exact_219 : height_219 = 1 + Finset.univ.sup childrenH_219 := by decide +kernel +theorem required_origin_219 : ∀ x ∈ required_219, + (∃ j, x ∈ childrenC_219 j) ∨ ∀ j, x ∈ childrenD_219 j := by decide +kernel +theorem required_exact_219 : required_219 = + ((Finset.univ.biUnion childrenC_219) ∪ commonEnvelope childrenD_219).erase (1, 1) := by + exact required_eq_combination childrenC_219 childrenD_219 (1, 1) required_219 + (by decide +kernel) child_required_sub_219 common_sub_219 required_origin_219 +theorem envelope_origin_219 : ∀ x ∈ envelope_219, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_219 j := by decide +kernel +theorem envelope_exact_219 : envelope_219 = + insert (1, 1) (Finset.univ.biUnion childrenD_219) := by + exact envelope_eq_combination childrenD_219 (1, 1) envelope_219 + pivot_mem_219 child_envelope_sub_219 envelope_origin_219 +def checked_219 : CheckedCard where + required := required_219 + envelope := envelope_219 + height := height_219 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_219 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part03.lean new file mode 100644 index 0000000..4c1647d --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part03.lean @@ -0,0 +1,915 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_221 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_221 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_221 : Fin 2 → Finset Cell := ![(placed21 5 (2, 0) required_5), (placed21 4 (0, 4) required_220)] +def childrenD_221 : Fin 2 → Finset Cell := ![(placed21 5 (2, 0) envelope_5), (placed21 4 (0, 4) envelope_220)] +theorem common_sub_221 : commonEnvelope childrenD_221 ⊆ insert (1, 3) required_221 := by decide +kernel +theorem child_required_sub_221 : ∀ j, childrenC_221 j ⊆ insert (1, 3) required_221 := by decide +kernel +theorem child_envelope_sub_221 : ∀ j, childrenD_221 j ⊆ envelope_221 := by decide +kernel +theorem pivot_mem_221 : (1, 3) ∈ envelope_221 := by decide +kernel +theorem children_work_221 : ∀ j, Template HasSnaky 2 (childrenC_221 j) (childrenD_221 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_220 4 (0, 4)).mono (by decide +kernel) +theorem row_works_221 : Template HasSnaky 3 required_221 envelope_221 := by + refine compose HasSnaky 2 childrenC_221 childrenD_221 children_work_221 (1, 3) + required_221 envelope_221 pivot_mem_221 child_required_sub_221 child_envelope_sub_221 ?_ + intro b hb + exact common_sub_221 (mem_commonEnvelope childrenD_221 b hb) +def required_222 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 4), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_222 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_222 : Fin 2 → Finset Cell := ![(placed21 5 (2, 1) required_5), required_220] +def childrenD_222 : Fin 2 → Finset Cell := ![(placed21 5 (2, 1) envelope_5), envelope_220] +theorem common_sub_222 : commonEnvelope childrenD_222 ⊆ insert (2, 1) required_222 := by decide +kernel +theorem child_required_sub_222 : ∀ j, childrenC_222 j ⊆ insert (2, 1) required_222 := by decide +kernel +theorem child_envelope_sub_222 : ∀ j, childrenD_222 j ⊆ envelope_222 := by decide +kernel +theorem pivot_mem_222 : (2, 1) ∈ envelope_222 := by decide +kernel +theorem children_work_222 : ∀ j, Template HasSnaky 2 (childrenC_222 j) (childrenD_222 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (2, 1)).mono (by decide +kernel) + · exact row_works_220.mono (by decide +kernel) +theorem row_works_222 : Template HasSnaky 3 required_222 envelope_222 := by + refine compose HasSnaky 2 childrenC_222 childrenD_222 children_work_222 (2, 1) + required_222 envelope_222 pivot_mem_222 child_required_sub_222 child_envelope_sub_222 ?_ + intro b hb + exact common_sub_222 (mem_commonEnvelope childrenD_222 b hb) +def required_223 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_223 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_223 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), (placed21 0 (3, 0) required_6)] +def childrenD_223 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), (placed21 0 (3, 0) envelope_6)] +theorem common_sub_223 : commonEnvelope childrenD_223 ⊆ insert (3, 0) required_223 := by decide +kernel +theorem child_required_sub_223 : ∀ j, childrenC_223 j ⊆ insert (3, 0) required_223 := by decide +kernel +theorem child_envelope_sub_223 : ∀ j, childrenD_223 j ⊆ envelope_223 := by decide +kernel +theorem pivot_mem_223 : (3, 0) ∈ envelope_223 := by decide +kernel +theorem children_work_223 : ∀ j, Template HasSnaky 2 (childrenC_223 j) (childrenD_223 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_6 0 (3, 0)).mono (by decide +kernel) +theorem row_works_223 : Template HasSnaky 3 required_223 envelope_223 := by + refine compose HasSnaky 2 childrenC_223 childrenD_223 children_work_223 (3, 0) + required_223 envelope_223 pivot_mem_223 child_required_sub_223 child_envelope_sub_223 ?_ + intro b hb + exact common_sub_223 (mem_commonEnvelope childrenD_223 b hb) +def required_226 : Finset Cell := ⟨(([(0, 2), (1, 1), (2, 1), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_226 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (5, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_226 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_4), (placed21 0 (1, 0) required_32)] +def childrenD_226 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_4), (placed21 0 (1, 0) envelope_32)] +theorem common_sub_226 : commonEnvelope childrenD_226 ⊆ insert (4, 1) required_226 := by decide +kernel +theorem child_required_sub_226 : ∀ j, childrenC_226 j ⊆ insert (4, 1) required_226 := by decide +kernel +theorem child_envelope_sub_226 : ∀ j, childrenD_226 j ⊆ envelope_226 := by decide +kernel +theorem pivot_mem_226 : (4, 1) ∈ envelope_226 := by decide +kernel +theorem children_work_226 : ∀ j, Template HasSnaky 2 (childrenC_226 j) (childrenD_226 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_32 0 (1, 0)).mono (by decide +kernel) +theorem row_works_226 : Template HasSnaky 3 required_226 envelope_226 := by + refine compose HasSnaky 2 childrenC_226 childrenD_226 children_work_226 (4, 1) + required_226 envelope_226 pivot_mem_226 child_required_sub_226 child_envelope_sub_226 ?_ + intro b hb + exact common_sub_226 (mem_commonEnvelope childrenD_226 b hb) +def required_236 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 4), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_236 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_236 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) required_6), (placed21 1 (0, 2) required_32)] +def childrenD_236 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) envelope_6), (placed21 1 (0, 2) envelope_32)] +theorem common_sub_236 : commonEnvelope childrenD_236 ⊆ insert (1, 5) required_236 := by decide +kernel +theorem child_required_sub_236 : ∀ j, childrenC_236 j ⊆ insert (1, 5) required_236 := by decide +kernel +theorem child_envelope_sub_236 : ∀ j, childrenD_236 j ⊆ envelope_236 := by decide +kernel +theorem pivot_mem_236 : (1, 5) ∈ envelope_236 := by decide +kernel +theorem children_work_236 : ∀ j, Template HasSnaky 2 (childrenC_236 j) (childrenD_236 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_32 1 (0, 2)).mono (by decide +kernel) +theorem row_works_236 : Template HasSnaky 3 required_236 envelope_236 := by + refine compose HasSnaky 2 childrenC_236 childrenD_236 children_work_236 (1, 5) + required_236 envelope_236 pivot_mem_236 child_required_sub_236 child_envelope_sub_236 ?_ + intro b hb + exact common_sub_236 (mem_commonEnvelope childrenD_236 b hb) +def required_239 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 3), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_239 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_239 : Fin 2 → Finset Cell := ![(placed21 6 (3, 5) required_11), (placed21 7 (4, 4) required_25)] +def childrenD_239 : Fin 2 → Finset Cell := ![(placed21 6 (3, 5) envelope_11), (placed21 7 (4, 4) envelope_25)] +theorem common_sub_239 : commonEnvelope childrenD_239 ⊆ insert (3, 1) required_239 := by decide +kernel +theorem child_required_sub_239 : ∀ j, childrenC_239 j ⊆ insert (3, 1) required_239 := by decide +kernel +theorem child_envelope_sub_239 : ∀ j, childrenD_239 j ⊆ envelope_239 := by decide +kernel +theorem pivot_mem_239 : (3, 1) ∈ envelope_239 := by decide +kernel +theorem children_work_239 : ∀ j, Template HasSnaky 2 (childrenC_239 j) (childrenD_239 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 6 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_25 7 (4, 4)).mono (by decide +kernel) +theorem row_works_239 : Template HasSnaky 3 required_239 envelope_239 := by + refine compose HasSnaky 2 childrenC_239 childrenD_239 children_work_239 (3, 1) + required_239 envelope_239 pivot_mem_239 child_required_sub_239 child_envelope_sub_239 ?_ + intro b hb + exact common_sub_239 (mem_commonEnvelope childrenD_239 b hb) +def required_245 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 1), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_245 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_245 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 1 (0, 1) required_32)] +def childrenD_245 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_32)] +theorem common_sub_245 : commonEnvelope childrenD_245 ⊆ insert (1, 4) required_245 := by decide +kernel +theorem child_required_sub_245 : ∀ j, childrenC_245 j ⊆ insert (1, 4) required_245 := by decide +kernel +theorem child_envelope_sub_245 : ∀ j, childrenD_245 j ⊆ envelope_245 := by decide +kernel +theorem pivot_mem_245 : (1, 4) ∈ envelope_245 := by decide +kernel +theorem children_work_245 : ∀ j, Template HasSnaky 2 (childrenC_245 j) (childrenD_245 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_32 1 (0, 1)).mono (by decide +kernel) +theorem row_works_245 : Template HasSnaky 3 required_245 envelope_245 := by + refine compose HasSnaky 2 childrenC_245 childrenD_245 children_work_245 (1, 4) + required_245 envelope_245 pivot_mem_245 child_required_sub_245 child_envelope_sub_245 ?_ + intro b hb + exact common_sub_245 (mem_commonEnvelope childrenD_245 b hb) +def required_246 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_246 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_246 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 1 (0, 1) required_25)] +def childrenD_246 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_25)] +theorem common_sub_246 : commonEnvelope childrenD_246 ⊆ insert (1, 4) required_246 := by decide +kernel +theorem child_required_sub_246 : ∀ j, childrenC_246 j ⊆ insert (1, 4) required_246 := by decide +kernel +theorem child_envelope_sub_246 : ∀ j, childrenD_246 j ⊆ envelope_246 := by decide +kernel +theorem pivot_mem_246 : (1, 4) ∈ envelope_246 := by decide +kernel +theorem children_work_246 : ∀ j, Template HasSnaky 2 (childrenC_246 j) (childrenD_246 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_25 1 (0, 1)).mono (by decide +kernel) +theorem row_works_246 : Template HasSnaky 3 required_246 envelope_246 := by + refine compose HasSnaky 2 childrenC_246 childrenD_246 children_work_246 (1, 4) + required_246 envelope_246 pivot_mem_246 child_required_sub_246 child_envelope_sub_246 ?_ + intro b hb + exact common_sub_246 (mem_commonEnvelope childrenD_246 b hb) +def required_247 : Finset Cell := ⟨(([(0, 1), (3, 1), (3, 2), (3, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_247 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_247 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) required_11), (placed21 7 (4, 4) required_35)] +def childrenD_247 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) envelope_11), (placed21 7 (4, 4) envelope_35)] +theorem common_sub_247 : commonEnvelope childrenD_247 ⊆ insert (3, 4) required_247 := by decide +kernel +theorem child_required_sub_247 : ∀ j, childrenC_247 j ⊆ insert (3, 4) required_247 := by decide +kernel +theorem child_envelope_sub_247 : ∀ j, childrenD_247 j ⊆ envelope_247 := by decide +kernel +theorem pivot_mem_247 : (3, 4) ∈ envelope_247 := by decide +kernel +theorem children_work_247 : ∀ j, Template HasSnaky 2 (childrenC_247 j) (childrenD_247 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_35 7 (4, 4)).mono (by decide +kernel) +theorem row_works_247 : Template HasSnaky 3 required_247 envelope_247 := by + refine compose HasSnaky 2 childrenC_247 childrenD_247 children_work_247 (3, 4) + required_247 envelope_247 pivot_mem_247 child_required_sub_247 child_envelope_sub_247 ?_ + intro b hb + exact common_sub_247 (mem_commonEnvelope childrenD_247 b hb) +def required_251 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_251 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_251 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_4), (placed21 0 (1, 0) required_224)] +def childrenD_251 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_4), (placed21 0 (1, 0) envelope_224)] +theorem common_sub_251 : commonEnvelope childrenD_251 ⊆ insert (4, 2) required_251 := by decide +kernel +theorem child_required_sub_251 : ∀ j, childrenC_251 j ⊆ insert (4, 2) required_251 := by decide +kernel +theorem child_envelope_sub_251 : ∀ j, childrenD_251 j ⊆ envelope_251 := by decide +kernel +theorem pivot_mem_251 : (4, 2) ∈ envelope_251 := by decide +kernel +theorem children_work_251 : ∀ j, Template HasSnaky 2 (childrenC_251 j) (childrenD_251 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_224 0 (1, 0)).mono (by decide +kernel) +theorem row_works_251 : Template HasSnaky 3 required_251 envelope_251 := by + refine compose HasSnaky 2 childrenC_251 childrenD_251 children_work_251 (4, 2) + required_251 envelope_251 pivot_mem_251 child_required_sub_251 child_envelope_sub_251 ?_ + intro b hb + exact common_sub_251 (mem_commonEnvelope childrenD_251 b hb) +def required_261 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_261 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_261 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_3), required_129] +def childrenD_261 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_3), envelope_129] +theorem common_sub_261 : commonEnvelope childrenD_261 ⊆ insert (1, 3) required_261 := by decide +kernel +theorem child_required_sub_261 : ∀ j, childrenC_261 j ⊆ insert (1, 3) required_261 := by decide +kernel +theorem child_envelope_sub_261 : ∀ j, childrenD_261 j ⊆ envelope_261 := by decide +kernel +theorem pivot_mem_261 : (1, 3) ∈ envelope_261 := by decide +kernel +theorem children_work_261 : ∀ j, Template HasSnaky 2 (childrenC_261 j) (childrenD_261 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact row_works_129.mono (by decide +kernel) +theorem row_works_261 : Template HasSnaky 3 required_261 envelope_261 := by + refine compose HasSnaky 2 childrenC_261 childrenD_261 children_work_261 (1, 3) + required_261 envelope_261 pivot_mem_261 child_required_sub_261 child_envelope_sub_261 ?_ + intro b hb + exact common_sub_261 (mem_commonEnvelope childrenD_261 b hb) +def required_262 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 2), (2, 3), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_262 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_262 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) required_15), (placed21 3 (0, 3) required_66)] +def childrenD_262 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) envelope_15), (placed21 3 (0, 3) envelope_66)] +theorem common_sub_262 : commonEnvelope childrenD_262 ⊆ insert (1, 1) required_262 := by decide +kernel +theorem child_required_sub_262 : ∀ j, childrenC_262 j ⊆ insert (1, 1) required_262 := by decide +kernel +theorem child_envelope_sub_262 : ∀ j, childrenD_262 j ⊆ envelope_262 := by decide +kernel +theorem pivot_mem_262 : (1, 1) ∈ envelope_262 := by decide +kernel +theorem children_work_262 : ∀ j, Template HasSnaky 2 (childrenC_262 j) (childrenD_262 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_66 3 (0, 3)).mono (by decide +kernel) +theorem row_works_262 : Template HasSnaky 3 required_262 envelope_262 := by + refine compose HasSnaky 2 childrenC_262 childrenD_262 children_work_262 (1, 1) + required_262 envelope_262 pivot_mem_262 child_required_sub_262 child_envelope_sub_262 ?_ + intro b hb + exact common_sub_262 (mem_commonEnvelope childrenD_262 b hb) +def required_280 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_280 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_280 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_3), (placed21 0 (1, 2) required_6)] +def childrenD_280 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_3), (placed21 0 (1, 2) envelope_6)] +theorem common_sub_280 : commonEnvelope childrenD_280 ⊆ insert (1, 2) required_280 := by decide +kernel +theorem child_required_sub_280 : ∀ j, childrenC_280 j ⊆ insert (1, 2) required_280 := by decide +kernel +theorem child_envelope_sub_280 : ∀ j, childrenD_280 j ⊆ envelope_280 := by decide +kernel +theorem pivot_mem_280 : (1, 2) ∈ envelope_280 := by decide +kernel +theorem children_work_280 : ∀ j, Template HasSnaky 2 (childrenC_280 j) (childrenD_280 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_6 0 (1, 2)).mono (by decide +kernel) +theorem row_works_280 : Template HasSnaky 3 required_280 envelope_280 := by + refine compose HasSnaky 2 childrenC_280 childrenD_280 children_work_280 (1, 2) + required_280 envelope_280 pivot_mem_280 child_required_sub_280 child_envelope_sub_280 ?_ + intro b hb + exact common_sub_280 (mem_commonEnvelope childrenD_280 b hb) +def required_310 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 4), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_310 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_310 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 0 (0, 1) required_76)] +def childrenD_310 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 0 (0, 1) envelope_76)] +theorem common_sub_310 : commonEnvelope childrenD_310 ⊆ insert (1, 3) required_310 := by decide +kernel +theorem child_required_sub_310 : ∀ j, childrenC_310 j ⊆ insert (1, 3) required_310 := by decide +kernel +theorem child_envelope_sub_310 : ∀ j, childrenD_310 j ⊆ envelope_310 := by decide +kernel +theorem pivot_mem_310 : (1, 3) ∈ envelope_310 := by decide +kernel +theorem children_work_310 : ∀ j, Template HasSnaky 2 (childrenC_310 j) (childrenD_310 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_76 0 (0, 1)).mono (by decide +kernel) +theorem row_works_310 : Template HasSnaky 3 required_310 envelope_310 := by + refine compose HasSnaky 2 childrenC_310 childrenD_310 children_work_310 (1, 3) + required_310 envelope_310 pivot_mem_310 child_required_sub_310 child_envelope_sub_310 ?_ + intro b hb + exact common_sub_310 (mem_commonEnvelope childrenD_310 b hb) +def required_333_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_333_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_333_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), (placed21 1 (0, 0) required_3)] +def childrenD_333_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), (placed21 1 (0, 0) envelope_3)] +theorem common_sub_333_i0 : commonEnvelope childrenD_333_i0 ⊆ insert (0, 2) required_333_i0 := by decide +kernel +theorem child_required_sub_333_i0 : ∀ j, childrenC_333_i0 j ⊆ insert (0, 2) required_333_i0 := by decide +kernel +theorem child_envelope_sub_333_i0 : ∀ j, childrenD_333_i0 j ⊆ envelope_333_i0 := by decide +kernel +theorem pivot_mem_333_i0 : (0, 2) ∈ envelope_333_i0 := by decide +kernel +theorem children_work_333_i0 : ∀ j, Template HasSnaky 1 (childrenC_333_i0 j) (childrenD_333_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_3 1 (0, 0)).mono (by decide +kernel) +theorem row_works_333_i0 : Template HasSnaky 2 required_333_i0 envelope_333_i0 := by + refine compose HasSnaky 1 childrenC_333_i0 childrenD_333_i0 children_work_333_i0 (0, 2) + required_333_i0 envelope_333_i0 pivot_mem_333_i0 child_required_sub_333_i0 child_envelope_sub_333_i0 ?_ + intro b hb + exact common_sub_333_i0 (mem_commonEnvelope childrenD_333_i0 b hb) +def required_333 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_333 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_333 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_3), required_333_i0] +def childrenD_333 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_3), envelope_333_i0] +theorem common_sub_333 : commonEnvelope childrenD_333 ⊆ insert (1, 4) required_333 := by decide +kernel +theorem child_required_sub_333 : ∀ j, childrenC_333 j ⊆ insert (1, 4) required_333 := by decide +kernel +theorem child_envelope_sub_333 : ∀ j, childrenD_333 j ⊆ envelope_333 := by decide +kernel +theorem pivot_mem_333 : (1, 4) ∈ envelope_333 := by decide +kernel +theorem children_work_333 : ∀ j, Template HasSnaky 2 (childrenC_333 j) (childrenD_333 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 7 (1, 4)).mono (by decide +kernel) + · exact row_works_333_i0.mono (by decide +kernel) +theorem row_works_333 : Template HasSnaky 3 required_333 envelope_333 := by + refine compose HasSnaky 2 childrenC_333 childrenD_333 children_work_333 (1, 4) + required_333 envelope_333 pivot_mem_333 child_required_sub_333 child_envelope_sub_333 ?_ + intro b hb + exact common_sub_333 (mem_commonEnvelope childrenD_333 b hb) +def required_350_i0 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (3, 2), (3, 4), (4, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_350_i0 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (5, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_350_i0 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) required_1), (placed21 4 (1, 1) required_5)] +def childrenD_350_i0 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) envelope_1), (placed21 4 (1, 1) envelope_5)] +theorem common_sub_350_i0 : commonEnvelope childrenD_350_i0 ⊆ insert (4, 1) required_350_i0 := by decide +kernel +theorem child_required_sub_350_i0 : ∀ j, childrenC_350_i0 j ⊆ insert (4, 1) required_350_i0 := by decide +kernel +theorem child_envelope_sub_350_i0 : ∀ j, childrenD_350_i0 j ⊆ envelope_350_i0 := by decide +kernel +theorem pivot_mem_350_i0 : (4, 1) ∈ envelope_350_i0 := by decide +kernel +theorem children_work_350_i0 : ∀ j, Template HasSnaky 1 (childrenC_350_i0 j) (childrenD_350_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 3 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 4 (1, 1)).mono (by decide +kernel) +theorem row_works_350_i0 : Template HasSnaky 2 required_350_i0 envelope_350_i0 := by + refine compose HasSnaky 1 childrenC_350_i0 childrenD_350_i0 children_work_350_i0 (4, 1) + required_350_i0 envelope_350_i0 pivot_mem_350_i0 child_required_sub_350_i0 child_envelope_sub_350_i0 ?_ + intro b hb + exact common_sub_350_i0 (mem_commonEnvelope childrenD_350_i0 b hb) +def required_350 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_350 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (5, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_350 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_4), required_350_i0] +def childrenD_350 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_4), envelope_350_i0] +theorem common_sub_350 : commonEnvelope childrenD_350 ⊆ insert (4, 0) required_350 := by decide +kernel +theorem child_required_sub_350 : ∀ j, childrenC_350 j ⊆ insert (4, 0) required_350 := by decide +kernel +theorem child_envelope_sub_350 : ∀ j, childrenD_350 j ⊆ envelope_350 := by decide +kernel +theorem pivot_mem_350 : (4, 0) ∈ envelope_350 := by decide +kernel +theorem children_work_350 : ∀ j, Template HasSnaky 2 (childrenC_350 j) (childrenD_350 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact row_works_350_i0.mono (by decide +kernel) +theorem row_works_350 : Template HasSnaky 3 required_350 envelope_350 := by + refine compose HasSnaky 2 childrenC_350 childrenD_350 children_work_350 (4, 0) + required_350 envelope_350 pivot_mem_350 child_required_sub_350 child_envelope_sub_350 ?_ + intro b hb + exact common_sub_350 (mem_commonEnvelope childrenD_350 b hb) +def required_374_i0 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 0), (3, 1), (4, 2), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_374_i0 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 0), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_374_i0 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) required_1), (placed21 0 (1, 1) required_5)] +def childrenD_374_i0 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) envelope_1), (placed21 0 (1, 1) envelope_5)] +theorem common_sub_374_i0 : commonEnvelope childrenD_374_i0 ⊆ insert (4, 1) required_374_i0 := by decide +kernel +theorem child_required_sub_374_i0 : ∀ j, childrenC_374_i0 j ⊆ insert (4, 1) required_374_i0 := by decide +kernel +theorem child_envelope_sub_374_i0 : ∀ j, childrenD_374_i0 j ⊆ envelope_374_i0 := by decide +kernel +theorem pivot_mem_374_i0 : (4, 1) ∈ envelope_374_i0 := by decide +kernel +theorem children_work_374_i0 : ∀ j, Template HasSnaky 1 (childrenC_374_i0 j) (childrenD_374_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 7 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 0 (1, 1)).mono (by decide +kernel) +theorem row_works_374_i0 : Template HasSnaky 2 required_374_i0 envelope_374_i0 := by + refine compose HasSnaky 1 childrenC_374_i0 childrenD_374_i0 children_work_374_i0 (4, 1) + required_374_i0 envelope_374_i0 pivot_mem_374_i0 child_required_sub_374_i0 child_envelope_sub_374_i0 ?_ + intro b hb + exact common_sub_374_i0 (mem_commonEnvelope childrenD_374_i0 b hb) +def required_374 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_374 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_374 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_4), required_374_i0] +def childrenD_374 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_4), envelope_374_i0] +theorem common_sub_374 : commonEnvelope childrenD_374 ⊆ insert (4, 2) required_374 := by decide +kernel +theorem child_required_sub_374 : ∀ j, childrenC_374 j ⊆ insert (4, 2) required_374 := by decide +kernel +theorem child_envelope_sub_374 : ∀ j, childrenD_374 j ⊆ envelope_374 := by decide +kernel +theorem pivot_mem_374 : (4, 2) ∈ envelope_374 := by decide +kernel +theorem children_work_374 : ∀ j, Template HasSnaky 2 (childrenC_374 j) (childrenD_374 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 0 (0, 1)).mono (by decide +kernel) + · exact row_works_374_i0.mono (by decide +kernel) +theorem row_works_374 : Template HasSnaky 3 required_374 envelope_374 := by + refine compose HasSnaky 2 childrenC_374 childrenD_374 children_work_374 (4, 2) + required_374 envelope_374 pivot_mem_374 child_required_sub_374 child_envelope_sub_374 ?_ + intro b hb + exact common_sub_374 (mem_commonEnvelope childrenD_374 b hb) +def required_402_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_402_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_402_i0 : Fin 2 → Finset Cell := ![(placed21 5 (3, 0) required_0), (placed21 1 (1, 1) required_5)] +def childrenD_402_i0 : Fin 2 → Finset Cell := ![(placed21 5 (3, 0) envelope_0), (placed21 1 (1, 1) envelope_5)] +theorem common_sub_402_i0 : commonEnvelope childrenD_402_i0 ⊆ insert (2, 4) required_402_i0 := by decide +kernel +theorem child_required_sub_402_i0 : ∀ j, childrenC_402_i0 j ⊆ insert (2, 4) required_402_i0 := by decide +kernel +theorem child_envelope_sub_402_i0 : ∀ j, childrenD_402_i0 j ⊆ envelope_402_i0 := by decide +kernel +theorem pivot_mem_402_i0 : (2, 4) ∈ envelope_402_i0 := by decide +kernel +theorem children_work_402_i0 : ∀ j, Template HasSnaky 1 (childrenC_402_i0 j) (childrenD_402_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 5 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) +theorem row_works_402_i0 : Template HasSnaky 2 required_402_i0 envelope_402_i0 := by + refine compose HasSnaky 1 childrenC_402_i0 childrenD_402_i0 children_work_402_i0 (2, 4) + required_402_i0 envelope_402_i0 pivot_mem_402_i0 child_required_sub_402_i0 child_envelope_sub_402_i0 ?_ + intro b hb + exact common_sub_402_i0 (mem_commonEnvelope childrenD_402_i0 b hb) +def required_402 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_402 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_402 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_38), required_402_i0] +def childrenD_402 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_38), envelope_402_i0] +theorem common_sub_402 : commonEnvelope childrenD_402 ⊆ insert (3, 1) required_402 := by decide +kernel +theorem child_required_sub_402 : ∀ j, childrenC_402 j ⊆ insert (3, 1) required_402 := by decide +kernel +theorem child_envelope_sub_402 : ∀ j, childrenD_402 j ⊆ envelope_402 := by decide +kernel +theorem pivot_mem_402 : (3, 1) ∈ envelope_402 := by decide +kernel +theorem children_work_402 : ∀ j, Template HasSnaky 2 (childrenC_402 j) (childrenD_402 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_38 3 (0, 4)).mono (by decide +kernel) + · exact row_works_402_i0.mono (by decide +kernel) +theorem row_works_402 : Template HasSnaky 3 required_402 envelope_402 := by + refine compose HasSnaky 2 childrenC_402 childrenD_402 children_work_402 (3, 1) + required_402 envelope_402 pivot_mem_402 child_required_sub_402 child_envelope_sub_402 ?_ + intro b hb + exact common_sub_402 (mem_commonEnvelope childrenD_402 b hb) +def height_221 : ℕ := 3 +def childrenH_221 : Fin 2 → ℕ := ![height_5, height_220] +theorem height_exact_221 : height_221 = 1 + Finset.univ.sup childrenH_221 := by decide +kernel +theorem required_origin_221 : ∀ x ∈ required_221, + (∃ j, x ∈ childrenC_221 j) ∨ ∀ j, x ∈ childrenD_221 j := by decide +kernel +theorem required_exact_221 : required_221 = + ((Finset.univ.biUnion childrenC_221) ∪ commonEnvelope childrenD_221).erase (1, 3) := by + exact required_eq_combination childrenC_221 childrenD_221 (1, 3) required_221 + (by decide +kernel) child_required_sub_221 common_sub_221 required_origin_221 +theorem envelope_origin_221 : ∀ x ∈ envelope_221, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_221 j := by decide +kernel +theorem envelope_exact_221 : envelope_221 = + insert (1, 3) (Finset.univ.biUnion childrenD_221) := by + exact envelope_eq_combination childrenD_221 (1, 3) envelope_221 + pivot_mem_221 child_envelope_sub_221 envelope_origin_221 +def checked_221 : CheckedCard where + required := required_221 + envelope := envelope_221 + height := height_221 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_221 +def height_222 : ℕ := 3 +def childrenH_222 : Fin 2 → ℕ := ![height_5, height_220] +theorem height_exact_222 : height_222 = 1 + Finset.univ.sup childrenH_222 := by decide +kernel +theorem required_origin_222 : ∀ x ∈ required_222, + (∃ j, x ∈ childrenC_222 j) ∨ ∀ j, x ∈ childrenD_222 j := by decide +kernel +theorem required_exact_222 : required_222 = + ((Finset.univ.biUnion childrenC_222) ∪ commonEnvelope childrenD_222).erase (2, 1) := by + exact required_eq_combination childrenC_222 childrenD_222 (2, 1) required_222 + (by decide +kernel) child_required_sub_222 common_sub_222 required_origin_222 +theorem envelope_origin_222 : ∀ x ∈ envelope_222, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_222 j := by decide +kernel +theorem envelope_exact_222 : envelope_222 = + insert (2, 1) (Finset.univ.biUnion childrenD_222) := by + exact envelope_eq_combination childrenD_222 (2, 1) envelope_222 + pivot_mem_222 child_envelope_sub_222 envelope_origin_222 +def checked_222 : CheckedCard where + required := required_222 + envelope := envelope_222 + height := height_222 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_222 +def height_223 : ℕ := 3 +def childrenH_223 : Fin 2 → ℕ := ![height_5, height_6] +theorem height_exact_223 : height_223 = 1 + Finset.univ.sup childrenH_223 := by decide +kernel +theorem required_origin_223 : ∀ x ∈ required_223, + (∃ j, x ∈ childrenC_223 j) ∨ ∀ j, x ∈ childrenD_223 j := by decide +kernel +theorem required_exact_223 : required_223 = + ((Finset.univ.biUnion childrenC_223) ∪ commonEnvelope childrenD_223).erase (3, 0) := by + exact required_eq_combination childrenC_223 childrenD_223 (3, 0) required_223 + (by decide +kernel) child_required_sub_223 common_sub_223 required_origin_223 +theorem envelope_origin_223 : ∀ x ∈ envelope_223, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_223 j := by decide +kernel +theorem envelope_exact_223 : envelope_223 = + insert (3, 0) (Finset.univ.biUnion childrenD_223) := by + exact envelope_eq_combination childrenD_223 (3, 0) envelope_223 + pivot_mem_223 child_envelope_sub_223 envelope_origin_223 +def checked_223 : CheckedCard where + required := required_223 + envelope := envelope_223 + height := height_223 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_223 +def height_226 : ℕ := 3 +def childrenH_226 : Fin 2 → ℕ := ![height_4, height_32] +theorem height_exact_226 : height_226 = 1 + Finset.univ.sup childrenH_226 := by decide +kernel +theorem required_origin_226 : ∀ x ∈ required_226, + (∃ j, x ∈ childrenC_226 j) ∨ ∀ j, x ∈ childrenD_226 j := by decide +kernel +theorem required_exact_226 : required_226 = + ((Finset.univ.biUnion childrenC_226) ∪ commonEnvelope childrenD_226).erase (4, 1) := by + exact required_eq_combination childrenC_226 childrenD_226 (4, 1) required_226 + (by decide +kernel) child_required_sub_226 common_sub_226 required_origin_226 +theorem envelope_origin_226 : ∀ x ∈ envelope_226, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_226 j := by decide +kernel +theorem envelope_exact_226 : envelope_226 = + insert (4, 1) (Finset.univ.biUnion childrenD_226) := by + exact envelope_eq_combination childrenD_226 (4, 1) envelope_226 + pivot_mem_226 child_envelope_sub_226 envelope_origin_226 +def checked_226 : CheckedCard where + required := required_226 + envelope := envelope_226 + height := height_226 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_226 +def height_236 : ℕ := 3 +def childrenH_236 : Fin 2 → ℕ := ![height_6, height_32] +theorem height_exact_236 : height_236 = 1 + Finset.univ.sup childrenH_236 := by decide +kernel +theorem required_origin_236 : ∀ x ∈ required_236, + (∃ j, x ∈ childrenC_236 j) ∨ ∀ j, x ∈ childrenD_236 j := by decide +kernel +theorem required_exact_236 : required_236 = + ((Finset.univ.biUnion childrenC_236) ∪ commonEnvelope childrenD_236).erase (1, 5) := by + exact required_eq_combination childrenC_236 childrenD_236 (1, 5) required_236 + (by decide +kernel) child_required_sub_236 common_sub_236 required_origin_236 +theorem envelope_origin_236 : ∀ x ∈ envelope_236, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_236 j := by decide +kernel +theorem envelope_exact_236 : envelope_236 = + insert (1, 5) (Finset.univ.biUnion childrenD_236) := by + exact envelope_eq_combination childrenD_236 (1, 5) envelope_236 + pivot_mem_236 child_envelope_sub_236 envelope_origin_236 +def checked_236 : CheckedCard where + required := required_236 + envelope := envelope_236 + height := height_236 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_236 +def height_239 : ℕ := 3 +def childrenH_239 : Fin 2 → ℕ := ![height_11, height_25] +theorem height_exact_239 : height_239 = 1 + Finset.univ.sup childrenH_239 := by decide +kernel +theorem required_origin_239 : ∀ x ∈ required_239, + (∃ j, x ∈ childrenC_239 j) ∨ ∀ j, x ∈ childrenD_239 j := by decide +kernel +theorem required_exact_239 : required_239 = + ((Finset.univ.biUnion childrenC_239) ∪ commonEnvelope childrenD_239).erase (3, 1) := by + exact required_eq_combination childrenC_239 childrenD_239 (3, 1) required_239 + (by decide +kernel) child_required_sub_239 common_sub_239 required_origin_239 +theorem envelope_origin_239 : ∀ x ∈ envelope_239, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_239 j := by decide +kernel +theorem envelope_exact_239 : envelope_239 = + insert (3, 1) (Finset.univ.biUnion childrenD_239) := by + exact envelope_eq_combination childrenD_239 (3, 1) envelope_239 + pivot_mem_239 child_envelope_sub_239 envelope_origin_239 +def checked_239 : CheckedCard where + required := required_239 + envelope := envelope_239 + height := height_239 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_239 +def height_245 : ℕ := 3 +def childrenH_245 : Fin 2 → ℕ := ![height_5, height_32] +theorem height_exact_245 : height_245 = 1 + Finset.univ.sup childrenH_245 := by decide +kernel +theorem required_origin_245 : ∀ x ∈ required_245, + (∃ j, x ∈ childrenC_245 j) ∨ ∀ j, x ∈ childrenD_245 j := by decide +kernel +theorem required_exact_245 : required_245 = + ((Finset.univ.biUnion childrenC_245) ∪ commonEnvelope childrenD_245).erase (1, 4) := by + exact required_eq_combination childrenC_245 childrenD_245 (1, 4) required_245 + (by decide +kernel) child_required_sub_245 common_sub_245 required_origin_245 +theorem envelope_origin_245 : ∀ x ∈ envelope_245, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_245 j := by decide +kernel +theorem envelope_exact_245 : envelope_245 = + insert (1, 4) (Finset.univ.biUnion childrenD_245) := by + exact envelope_eq_combination childrenD_245 (1, 4) envelope_245 + pivot_mem_245 child_envelope_sub_245 envelope_origin_245 +def checked_245 : CheckedCard where + required := required_245 + envelope := envelope_245 + height := height_245 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_245 +def height_246 : ℕ := 3 +def childrenH_246 : Fin 2 → ℕ := ![height_5, height_25] +theorem height_exact_246 : height_246 = 1 + Finset.univ.sup childrenH_246 := by decide +kernel +theorem required_origin_246 : ∀ x ∈ required_246, + (∃ j, x ∈ childrenC_246 j) ∨ ∀ j, x ∈ childrenD_246 j := by decide +kernel +theorem required_exact_246 : required_246 = + ((Finset.univ.biUnion childrenC_246) ∪ commonEnvelope childrenD_246).erase (1, 4) := by + exact required_eq_combination childrenC_246 childrenD_246 (1, 4) required_246 + (by decide +kernel) child_required_sub_246 common_sub_246 required_origin_246 +theorem envelope_origin_246 : ∀ x ∈ envelope_246, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_246 j := by decide +kernel +theorem envelope_exact_246 : envelope_246 = + insert (1, 4) (Finset.univ.biUnion childrenD_246) := by + exact envelope_eq_combination childrenD_246 (1, 4) envelope_246 + pivot_mem_246 child_envelope_sub_246 envelope_origin_246 +def checked_246 : CheckedCard where + required := required_246 + envelope := envelope_246 + height := height_246 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_246 +def height_247 : ℕ := 3 +def childrenH_247 : Fin 2 → ℕ := ![height_11, height_35] +theorem height_exact_247 : height_247 = 1 + Finset.univ.sup childrenH_247 := by decide +kernel +theorem required_origin_247 : ∀ x ∈ required_247, + (∃ j, x ∈ childrenC_247 j) ∨ ∀ j, x ∈ childrenD_247 j := by decide +kernel +theorem required_exact_247 : required_247 = + ((Finset.univ.biUnion childrenC_247) ∪ commonEnvelope childrenD_247).erase (3, 4) := by + exact required_eq_combination childrenC_247 childrenD_247 (3, 4) required_247 + (by decide +kernel) child_required_sub_247 common_sub_247 required_origin_247 +theorem envelope_origin_247 : ∀ x ∈ envelope_247, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_247 j := by decide +kernel +theorem envelope_exact_247 : envelope_247 = + insert (3, 4) (Finset.univ.biUnion childrenD_247) := by + exact envelope_eq_combination childrenD_247 (3, 4) envelope_247 + pivot_mem_247 child_envelope_sub_247 envelope_origin_247 +def checked_247 : CheckedCard where + required := required_247 + envelope := envelope_247 + height := height_247 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_247 +def height_251 : ℕ := 3 +def childrenH_251 : Fin 2 → ℕ := ![height_4, height_224] +theorem height_exact_251 : height_251 = 1 + Finset.univ.sup childrenH_251 := by decide +kernel +theorem required_origin_251 : ∀ x ∈ required_251, + (∃ j, x ∈ childrenC_251 j) ∨ ∀ j, x ∈ childrenD_251 j := by decide +kernel +theorem required_exact_251 : required_251 = + ((Finset.univ.biUnion childrenC_251) ∪ commonEnvelope childrenD_251).erase (4, 2) := by + exact required_eq_combination childrenC_251 childrenD_251 (4, 2) required_251 + (by decide +kernel) child_required_sub_251 common_sub_251 required_origin_251 +theorem envelope_origin_251 : ∀ x ∈ envelope_251, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_251 j := by decide +kernel +theorem envelope_exact_251 : envelope_251 = + insert (4, 2) (Finset.univ.biUnion childrenD_251) := by + exact envelope_eq_combination childrenD_251 (4, 2) envelope_251 + pivot_mem_251 child_envelope_sub_251 envelope_origin_251 +def checked_251 : CheckedCard where + required := required_251 + envelope := envelope_251 + height := height_251 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_251 +def height_261 : ℕ := 3 +def childrenH_261 : Fin 2 → ℕ := ![height_3, height_129] +theorem height_exact_261 : height_261 = 1 + Finset.univ.sup childrenH_261 := by decide +kernel +theorem required_origin_261 : ∀ x ∈ required_261, + (∃ j, x ∈ childrenC_261 j) ∨ ∀ j, x ∈ childrenD_261 j := by decide +kernel +theorem required_exact_261 : required_261 = + ((Finset.univ.biUnion childrenC_261) ∪ commonEnvelope childrenD_261).erase (1, 3) := by + exact required_eq_combination childrenC_261 childrenD_261 (1, 3) required_261 + (by decide +kernel) child_required_sub_261 common_sub_261 required_origin_261 +theorem envelope_origin_261 : ∀ x ∈ envelope_261, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_261 j := by decide +kernel +theorem envelope_exact_261 : envelope_261 = + insert (1, 3) (Finset.univ.biUnion childrenD_261) := by + exact envelope_eq_combination childrenD_261 (1, 3) envelope_261 + pivot_mem_261 child_envelope_sub_261 envelope_origin_261 +def checked_261 : CheckedCard where + required := required_261 + envelope := envelope_261 + height := height_261 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_261 +def height_262 : ℕ := 3 +def childrenH_262 : Fin 2 → ℕ := ![height_15, height_66] +theorem height_exact_262 : height_262 = 1 + Finset.univ.sup childrenH_262 := by decide +kernel +theorem required_origin_262 : ∀ x ∈ required_262, + (∃ j, x ∈ childrenC_262 j) ∨ ∀ j, x ∈ childrenD_262 j := by decide +kernel +theorem required_exact_262 : required_262 = + ((Finset.univ.biUnion childrenC_262) ∪ commonEnvelope childrenD_262).erase (1, 1) := by + exact required_eq_combination childrenC_262 childrenD_262 (1, 1) required_262 + (by decide +kernel) child_required_sub_262 common_sub_262 required_origin_262 +theorem envelope_origin_262 : ∀ x ∈ envelope_262, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_262 j := by decide +kernel +theorem envelope_exact_262 : envelope_262 = + insert (1, 1) (Finset.univ.biUnion childrenD_262) := by + exact envelope_eq_combination childrenD_262 (1, 1) envelope_262 + pivot_mem_262 child_envelope_sub_262 envelope_origin_262 +def checked_262 : CheckedCard where + required := required_262 + envelope := envelope_262 + height := height_262 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_262 +def height_280 : ℕ := 3 +def childrenH_280 : Fin 2 → ℕ := ![height_3, height_6] +theorem height_exact_280 : height_280 = 1 + Finset.univ.sup childrenH_280 := by decide +kernel +theorem required_origin_280 : ∀ x ∈ required_280, + (∃ j, x ∈ childrenC_280 j) ∨ ∀ j, x ∈ childrenD_280 j := by decide +kernel +theorem required_exact_280 : required_280 = + ((Finset.univ.biUnion childrenC_280) ∪ commonEnvelope childrenD_280).erase (1, 2) := by + exact required_eq_combination childrenC_280 childrenD_280 (1, 2) required_280 + (by decide +kernel) child_required_sub_280 common_sub_280 required_origin_280 +theorem envelope_origin_280 : ∀ x ∈ envelope_280, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_280 j := by decide +kernel +theorem envelope_exact_280 : envelope_280 = + insert (1, 2) (Finset.univ.biUnion childrenD_280) := by + exact envelope_eq_combination childrenD_280 (1, 2) envelope_280 + pivot_mem_280 child_envelope_sub_280 envelope_origin_280 +def checked_280 : CheckedCard where + required := required_280 + envelope := envelope_280 + height := height_280 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_280 +def height_310 : ℕ := 3 +def childrenH_310 : Fin 2 → ℕ := ![height_5, height_76] +theorem height_exact_310 : height_310 = 1 + Finset.univ.sup childrenH_310 := by decide +kernel +theorem required_origin_310 : ∀ x ∈ required_310, + (∃ j, x ∈ childrenC_310 j) ∨ ∀ j, x ∈ childrenD_310 j := by decide +kernel +theorem required_exact_310 : required_310 = + ((Finset.univ.biUnion childrenC_310) ∪ commonEnvelope childrenD_310).erase (1, 3) := by + exact required_eq_combination childrenC_310 childrenD_310 (1, 3) required_310 + (by decide +kernel) child_required_sub_310 common_sub_310 required_origin_310 +theorem envelope_origin_310 : ∀ x ∈ envelope_310, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_310 j := by decide +kernel +theorem envelope_exact_310 : envelope_310 = + insert (1, 3) (Finset.univ.biUnion childrenD_310) := by + exact envelope_eq_combination childrenD_310 (1, 3) envelope_310 + pivot_mem_310 child_envelope_sub_310 envelope_origin_310 +def checked_310 : CheckedCard where + required := required_310 + envelope := envelope_310 + height := height_310 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_310 +def height_333_i0 : ℕ := 2 +def childrenH_333_i0 : Fin 2 → ℕ := ![height_0, height_3] +theorem height_exact_333_i0 : height_333_i0 = 1 + Finset.univ.sup childrenH_333_i0 := by decide +kernel +theorem required_origin_333_i0 : ∀ x ∈ required_333_i0, + (∃ j, x ∈ childrenC_333_i0 j) ∨ ∀ j, x ∈ childrenD_333_i0 j := by decide +kernel +theorem required_exact_333_i0 : required_333_i0 = + ((Finset.univ.biUnion childrenC_333_i0) ∪ commonEnvelope childrenD_333_i0).erase (0, 2) := by + exact required_eq_combination childrenC_333_i0 childrenD_333_i0 (0, 2) required_333_i0 + (by decide +kernel) child_required_sub_333_i0 common_sub_333_i0 required_origin_333_i0 +theorem envelope_origin_333_i0 : ∀ x ∈ envelope_333_i0, + x = (0, 2) ∨ ∃ j, x ∈ childrenD_333_i0 j := by decide +kernel +theorem envelope_exact_333_i0 : envelope_333_i0 = + insert (0, 2) (Finset.univ.biUnion childrenD_333_i0) := by + exact envelope_eq_combination childrenD_333_i0 (0, 2) envelope_333_i0 + pivot_mem_333_i0 child_envelope_sub_333_i0 envelope_origin_333_i0 +def checked_333_i0 : CheckedCard where + required := required_333_i0 + envelope := envelope_333_i0 + height := height_333_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_333_i0 +def height_333 : ℕ := 3 +def childrenH_333 : Fin 2 → ℕ := ![height_3, height_333_i0] +theorem height_exact_333 : height_333 = 1 + Finset.univ.sup childrenH_333 := by decide +kernel +theorem required_origin_333 : ∀ x ∈ required_333, + (∃ j, x ∈ childrenC_333 j) ∨ ∀ j, x ∈ childrenD_333 j := by decide +kernel +theorem required_exact_333 : required_333 = + ((Finset.univ.biUnion childrenC_333) ∪ commonEnvelope childrenD_333).erase (1, 4) := by + exact required_eq_combination childrenC_333 childrenD_333 (1, 4) required_333 + (by decide +kernel) child_required_sub_333 common_sub_333 required_origin_333 +theorem envelope_origin_333 : ∀ x ∈ envelope_333, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_333 j := by decide +kernel +theorem envelope_exact_333 : envelope_333 = + insert (1, 4) (Finset.univ.biUnion childrenD_333) := by + exact envelope_eq_combination childrenD_333 (1, 4) envelope_333 + pivot_mem_333 child_envelope_sub_333 envelope_origin_333 +def checked_333 : CheckedCard where + required := required_333 + envelope := envelope_333 + height := height_333 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_333 +def height_350_i0 : ℕ := 2 +def childrenH_350_i0 : Fin 2 → ℕ := ![height_1, height_5] +theorem height_exact_350_i0 : height_350_i0 = 1 + Finset.univ.sup childrenH_350_i0 := by decide +kernel +theorem required_origin_350_i0 : ∀ x ∈ required_350_i0, + (∃ j, x ∈ childrenC_350_i0 j) ∨ ∀ j, x ∈ childrenD_350_i0 j := by decide +kernel +theorem required_exact_350_i0 : required_350_i0 = + ((Finset.univ.biUnion childrenC_350_i0) ∪ commonEnvelope childrenD_350_i0).erase (4, 1) := by + exact required_eq_combination childrenC_350_i0 childrenD_350_i0 (4, 1) required_350_i0 + (by decide +kernel) child_required_sub_350_i0 common_sub_350_i0 required_origin_350_i0 +theorem envelope_origin_350_i0 : ∀ x ∈ envelope_350_i0, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_350_i0 j := by decide +kernel +theorem envelope_exact_350_i0 : envelope_350_i0 = + insert (4, 1) (Finset.univ.biUnion childrenD_350_i0) := by + exact envelope_eq_combination childrenD_350_i0 (4, 1) envelope_350_i0 + pivot_mem_350_i0 child_envelope_sub_350_i0 envelope_origin_350_i0 +def checked_350_i0 : CheckedCard where + required := required_350_i0 + envelope := envelope_350_i0 + height := height_350_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_350_i0 +def height_350 : ℕ := 3 +def childrenH_350 : Fin 2 → ℕ := ![height_4, height_350_i0] +theorem height_exact_350 : height_350 = 1 + Finset.univ.sup childrenH_350 := by decide +kernel +theorem required_origin_350 : ∀ x ∈ required_350, + (∃ j, x ∈ childrenC_350 j) ∨ ∀ j, x ∈ childrenD_350 j := by decide +kernel +theorem required_exact_350 : required_350 = + ((Finset.univ.biUnion childrenC_350) ∪ commonEnvelope childrenD_350).erase (4, 0) := by + exact required_eq_combination childrenC_350 childrenD_350 (4, 0) required_350 + (by decide +kernel) child_required_sub_350 common_sub_350 required_origin_350 +theorem envelope_origin_350 : ∀ x ∈ envelope_350, + x = (4, 0) ∨ ∃ j, x ∈ childrenD_350 j := by decide +kernel +theorem envelope_exact_350 : envelope_350 = + insert (4, 0) (Finset.univ.biUnion childrenD_350) := by + exact envelope_eq_combination childrenD_350 (4, 0) envelope_350 + pivot_mem_350 child_envelope_sub_350 envelope_origin_350 +def checked_350 : CheckedCard where + required := required_350 + envelope := envelope_350 + height := height_350 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_350 +def height_374_i0 : ℕ := 2 +def childrenH_374_i0 : Fin 2 → ℕ := ![height_1, height_5] +theorem height_exact_374_i0 : height_374_i0 = 1 + Finset.univ.sup childrenH_374_i0 := by decide +kernel +theorem required_origin_374_i0 : ∀ x ∈ required_374_i0, + (∃ j, x ∈ childrenC_374_i0 j) ∨ ∀ j, x ∈ childrenD_374_i0 j := by decide +kernel +theorem required_exact_374_i0 : required_374_i0 = + ((Finset.univ.biUnion childrenC_374_i0) ∪ commonEnvelope childrenD_374_i0).erase (4, 1) := by + exact required_eq_combination childrenC_374_i0 childrenD_374_i0 (4, 1) required_374_i0 + (by decide +kernel) child_required_sub_374_i0 common_sub_374_i0 required_origin_374_i0 +theorem envelope_origin_374_i0 : ∀ x ∈ envelope_374_i0, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_374_i0 j := by decide +kernel +theorem envelope_exact_374_i0 : envelope_374_i0 = + insert (4, 1) (Finset.univ.biUnion childrenD_374_i0) := by + exact envelope_eq_combination childrenD_374_i0 (4, 1) envelope_374_i0 + pivot_mem_374_i0 child_envelope_sub_374_i0 envelope_origin_374_i0 +def checked_374_i0 : CheckedCard where + required := required_374_i0 + envelope := envelope_374_i0 + height := height_374_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_374_i0 +def height_374 : ℕ := 3 +def childrenH_374 : Fin 2 → ℕ := ![height_4, height_374_i0] +theorem height_exact_374 : height_374 = 1 + Finset.univ.sup childrenH_374 := by decide +kernel +theorem required_origin_374 : ∀ x ∈ required_374, + (∃ j, x ∈ childrenC_374 j) ∨ ∀ j, x ∈ childrenD_374 j := by decide +kernel +theorem required_exact_374 : required_374 = + ((Finset.univ.biUnion childrenC_374) ∪ commonEnvelope childrenD_374).erase (4, 2) := by + exact required_eq_combination childrenC_374 childrenD_374 (4, 2) required_374 + (by decide +kernel) child_required_sub_374 common_sub_374 required_origin_374 +theorem envelope_origin_374 : ∀ x ∈ envelope_374, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_374 j := by decide +kernel +theorem envelope_exact_374 : envelope_374 = + insert (4, 2) (Finset.univ.biUnion childrenD_374) := by + exact envelope_eq_combination childrenD_374 (4, 2) envelope_374 + pivot_mem_374 child_envelope_sub_374 envelope_origin_374 +def checked_374 : CheckedCard where + required := required_374 + envelope := envelope_374 + height := height_374 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_374 +def height_402_i0 : ℕ := 2 +def childrenH_402_i0 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_402_i0 : height_402_i0 = 1 + Finset.univ.sup childrenH_402_i0 := by decide +kernel +theorem required_origin_402_i0 : ∀ x ∈ required_402_i0, + (∃ j, x ∈ childrenC_402_i0 j) ∨ ∀ j, x ∈ childrenD_402_i0 j := by decide +kernel +theorem required_exact_402_i0 : required_402_i0 = + ((Finset.univ.biUnion childrenC_402_i0) ∪ commonEnvelope childrenD_402_i0).erase (2, 4) := by + exact required_eq_combination childrenC_402_i0 childrenD_402_i0 (2, 4) required_402_i0 + (by decide +kernel) child_required_sub_402_i0 common_sub_402_i0 required_origin_402_i0 +theorem envelope_origin_402_i0 : ∀ x ∈ envelope_402_i0, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_402_i0 j := by decide +kernel +theorem envelope_exact_402_i0 : envelope_402_i0 = + insert (2, 4) (Finset.univ.biUnion childrenD_402_i0) := by + exact envelope_eq_combination childrenD_402_i0 (2, 4) envelope_402_i0 + pivot_mem_402_i0 child_envelope_sub_402_i0 envelope_origin_402_i0 +def checked_402_i0 : CheckedCard where + required := required_402_i0 + envelope := envelope_402_i0 + height := height_402_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_402_i0 +def height_402 : ℕ := 3 +def childrenH_402 : Fin 2 → ℕ := ![height_38, height_402_i0] +theorem height_exact_402 : height_402 = 1 + Finset.univ.sup childrenH_402 := by decide +kernel +theorem required_origin_402 : ∀ x ∈ required_402, + (∃ j, x ∈ childrenC_402 j) ∨ ∀ j, x ∈ childrenD_402 j := by decide +kernel +theorem required_exact_402 : required_402 = + ((Finset.univ.biUnion childrenC_402) ∪ commonEnvelope childrenD_402).erase (3, 1) := by + exact required_eq_combination childrenC_402 childrenD_402 (3, 1) required_402 + (by decide +kernel) child_required_sub_402 common_sub_402 required_origin_402 +theorem envelope_origin_402 : ∀ x ∈ envelope_402, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_402 j := by decide +kernel +theorem envelope_exact_402 : envelope_402 = + insert (3, 1) (Finset.univ.biUnion childrenD_402) := by + exact envelope_eq_combination childrenD_402 (3, 1) envelope_402 + pivot_mem_402 child_envelope_sub_402 envelope_origin_402 +def checked_402 : CheckedCard where + required := required_402 + envelope := envelope_402 + height := height_402 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_402 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part01.lean new file mode 100644 index 0000000..9a58ed0 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part01.lean @@ -0,0 +1,1002 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_10 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_10 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_10 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 1 (0, 1) required_8)] +def childrenD_10 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_8)] +theorem common_sub_10 : commonEnvelope childrenD_10 ⊆ insert (1, 4) required_10 := by decide +kernel +theorem child_required_sub_10 : ∀ j, childrenC_10 j ⊆ insert (1, 4) required_10 := by decide +kernel +theorem child_envelope_sub_10 : ∀ j, childrenD_10 j ⊆ envelope_10 := by decide +kernel +theorem pivot_mem_10 : (1, 4) ∈ envelope_10 := by decide +kernel +theorem children_work_10 : ∀ j, Template HasSnaky 3 (childrenC_10 j) (childrenD_10 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) +theorem row_works_10 : Template HasSnaky 4 required_10 envelope_10 := by + refine compose HasSnaky 3 childrenC_10 childrenD_10 children_work_10 (1, 4) + required_10 envelope_10 pivot_mem_10 child_required_sub_10 child_envelope_sub_10 ?_ + intro b hb + exact common_sub_10 (mem_commonEnvelope childrenD_10 b hb) +def required_12 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_12 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_12 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) required_7), (placed21 1 (0, 2) required_8), (placed21 6 (2, 6) required_9)] +def childrenD_12 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) envelope_7), (placed21 1 (0, 2) envelope_8), (placed21 6 (2, 6) envelope_9)] +theorem common_sub_12 : commonEnvelope childrenD_12 ⊆ insert (1, 5) required_12 := by decide +kernel +theorem child_required_sub_12 : ∀ j, childrenC_12 j ⊆ insert (1, 5) required_12 := by decide +kernel +theorem child_envelope_sub_12 : ∀ j, childrenD_12 j ⊆ envelope_12 := by decide +kernel +theorem pivot_mem_12 : (1, 5) ∈ envelope_12 := by decide +kernel +theorem children_work_12 : ∀ j, Template HasSnaky 3 (childrenC_12 j) (childrenD_12 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 6 (2, 6)).mono (by decide +kernel) +theorem row_works_12 : Template HasSnaky 4 required_12 envelope_12 := by + refine compose HasSnaky 3 childrenC_12 childrenD_12 children_work_12 (1, 5) + required_12 envelope_12 pivot_mem_12 child_required_sub_12 child_envelope_sub_12 ?_ + intro b hb + exact common_sub_12 (mem_commonEnvelope childrenD_12 b hb) +def required_13 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_13 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_13 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) required_7), (placed21 1 (0, 2) required_8), (placed21 6 (2, 6) required_9)] +def childrenD_13 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) envelope_7), (placed21 1 (0, 2) envelope_8), (placed21 6 (2, 6) envelope_9)] +theorem common_sub_13 : commonEnvelope childrenD_13 ⊆ insert (1, 5) required_13 := by decide +kernel +theorem child_required_sub_13 : ∀ j, childrenC_13 j ⊆ insert (1, 5) required_13 := by decide +kernel +theorem child_envelope_sub_13 : ∀ j, childrenD_13 j ⊆ envelope_13 := by decide +kernel +theorem pivot_mem_13 : (1, 5) ∈ envelope_13 := by decide +kernel +theorem children_work_13 : ∀ j, Template HasSnaky 3 (childrenC_13 j) (childrenD_13 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 6 (2, 6)).mono (by decide +kernel) +theorem row_works_13 : Template HasSnaky 4 required_13 envelope_13 := by + refine compose HasSnaky 3 childrenC_13 childrenD_13 children_work_13 (1, 5) + required_13 envelope_13 pivot_mem_13 child_required_sub_13 child_envelope_sub_13 ?_ + intro b hb + exact common_sub_13 (mem_commonEnvelope childrenD_13 b hb) +def required_14 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_14 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_14 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) required_7), (placed21 1 (0, 2) required_8), (placed21 0 (0, 1) required_9)] +def childrenD_14 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) envelope_7), (placed21 1 (0, 2) envelope_8), (placed21 0 (0, 1) envelope_9)] +theorem common_sub_14 : commonEnvelope childrenD_14 ⊆ insert (1, 5) required_14 := by decide +kernel +theorem child_required_sub_14 : ∀ j, childrenC_14 j ⊆ insert (1, 5) required_14 := by decide +kernel +theorem child_envelope_sub_14 : ∀ j, childrenD_14 j ⊆ envelope_14 := by decide +kernel +theorem pivot_mem_14 : (1, 5) ∈ envelope_14 := by decide +kernel +theorem children_work_14 : ∀ j, Template HasSnaky 3 (childrenC_14 j) (childrenD_14 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 0 (0, 1)).mono (by decide +kernel) +theorem row_works_14 : Template HasSnaky 4 required_14 envelope_14 := by + refine compose HasSnaky 3 childrenC_14 childrenD_14 children_work_14 (1, 5) + required_14 envelope_14 pivot_mem_14 child_required_sub_14 child_envelope_sub_14 ?_ + intro b hb + exact common_sub_14 (mem_commonEnvelope childrenD_14 b hb) +def required_17 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_17 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_17 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) required_6), (placed21 2 (1, 1) required_16)] +def childrenD_17 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) envelope_6), (placed21 2 (1, 1) envelope_16)] +theorem common_sub_17 : commonEnvelope childrenD_17 ⊆ insert (1, 4) required_17 := by decide +kernel +theorem child_required_sub_17 : ∀ j, childrenC_17 j ⊆ insert (1, 4) required_17 := by decide +kernel +theorem child_envelope_sub_17 : ∀ j, childrenD_17 j ⊆ envelope_17 := by decide +kernel +theorem pivot_mem_17 : (1, 4) ∈ envelope_17 := by decide +kernel +theorem children_work_17 : ∀ j, Template HasSnaky 3 (childrenC_17 j) (childrenD_17 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_16 2 (1, 1)).mono (by decide +kernel) +theorem row_works_17 : Template HasSnaky 4 required_17 envelope_17 := by + refine compose HasSnaky 3 childrenC_17 childrenD_17 children_work_17 (1, 4) + required_17 envelope_17 pivot_mem_17 child_required_sub_17 child_envelope_sub_17 ?_ + intro b hb + exact common_sub_17 (mem_commonEnvelope childrenD_17 b hb) +def required_18 : Finset Cell := ⟨(([(0, 0), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_18 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_18 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_4), (placed21 1 (0, 1) required_8)] +def childrenD_18 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_4), (placed21 1 (0, 1) envelope_8)] +theorem common_sub_18 : commonEnvelope childrenD_18 ⊆ insert (1, 4) required_18 := by decide +kernel +theorem child_required_sub_18 : ∀ j, childrenC_18 j ⊆ insert (1, 4) required_18 := by decide +kernel +theorem child_envelope_sub_18 : ∀ j, childrenD_18 j ⊆ envelope_18 := by decide +kernel +theorem pivot_mem_18 : (1, 4) ∈ envelope_18 := by decide +kernel +theorem children_work_18 : ∀ j, Template HasSnaky 3 (childrenC_18 j) (childrenD_18 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) +theorem row_works_18 : Template HasSnaky 4 required_18 envelope_18 := by + refine compose HasSnaky 3 childrenC_18 childrenD_18 children_work_18 (1, 4) + required_18 envelope_18 pivot_mem_18 child_required_sub_18 child_envelope_sub_18 ?_ + intro b hb + exact common_sub_18 (mem_commonEnvelope childrenD_18 b hb) +def required_26 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_26 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_26 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_6), (placed21 3 (0, 1) required_7)] +def childrenD_26 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_6), (placed21 3 (0, 1) envelope_7)] +theorem common_sub_26 : commonEnvelope childrenD_26 ⊆ insert (4, 1) required_26 := by decide +kernel +theorem child_required_sub_26 : ∀ j, childrenC_26 j ⊆ insert (4, 1) required_26 := by decide +kernel +theorem child_envelope_sub_26 : ∀ j, childrenD_26 j ⊆ envelope_26 := by decide +kernel +theorem pivot_mem_26 : (4, 1) ∈ envelope_26 := by decide +kernel +theorem children_work_26 : ∀ j, Template HasSnaky 3 (childrenC_26 j) (childrenD_26 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_7 3 (0, 1)).mono (by decide +kernel) +theorem row_works_26 : Template HasSnaky 4 required_26 envelope_26 := by + refine compose HasSnaky 3 childrenC_26 childrenD_26 children_work_26 (4, 1) + required_26 envelope_26 pivot_mem_26 child_required_sub_26 child_envelope_sub_26 ?_ + intro b hb + exact common_sub_26 (mem_commonEnvelope childrenD_26 b hb) +def required_27 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_27 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_27 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_5), (placed21 0 (0, 1) required_16)] +def childrenD_27 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_5), (placed21 0 (0, 1) envelope_16)] +theorem common_sub_27 : commonEnvelope childrenD_27 ⊆ insert (0, 4) required_27 := by decide +kernel +theorem child_required_sub_27 : ∀ j, childrenC_27 j ⊆ insert (0, 4) required_27 := by decide +kernel +theorem child_envelope_sub_27 : ∀ j, childrenD_27 j ⊆ envelope_27 := by decide +kernel +theorem pivot_mem_27 : (0, 4) ∈ envelope_27 := by decide +kernel +theorem children_work_27 : ∀ j, Template HasSnaky 3 (childrenC_27 j) (childrenD_27 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_16 0 (0, 1)).mono (by decide +kernel) +theorem row_works_27 : Template HasSnaky 4 required_27 envelope_27 := by + refine compose HasSnaky 3 childrenC_27 childrenD_27 children_work_27 (0, 4) + required_27 envelope_27 pivot_mem_27 child_required_sub_27 child_envelope_sub_27 ?_ + intro b hb + exact common_sub_27 (mem_commonEnvelope childrenD_27 b hb) +def required_31 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_31 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_31 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) required_8), (placed21 3 (0, 5) required_8)] +def childrenD_31 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) envelope_8), (placed21 3 (0, 5) envelope_8)] +theorem common_sub_31 : commonEnvelope childrenD_31 ⊆ insert (1, 5) required_31 := by decide +kernel +theorem child_required_sub_31 : ∀ j, childrenC_31 j ⊆ insert (1, 5) required_31 := by decide +kernel +theorem child_envelope_sub_31 : ∀ j, childrenD_31 j ⊆ envelope_31 := by decide +kernel +theorem pivot_mem_31 : (1, 5) ∈ envelope_31 := by decide +kernel +theorem children_work_31 : ∀ j, Template HasSnaky 3 (childrenC_31 j) (childrenD_31 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_8 3 (0, 5)).mono (by decide +kernel) +theorem row_works_31 : Template HasSnaky 4 required_31 envelope_31 := by + refine compose HasSnaky 3 childrenC_31 childrenD_31 children_work_31 (1, 5) + required_31 envelope_31 pivot_mem_31 child_required_sub_31 child_envelope_sub_31 ?_ + intro b hb + exact common_sub_31 (mem_commonEnvelope childrenD_31 b hb) +def required_33 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_33 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_33 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) required_7), (placed21 3 (0, 5) required_8), (placed21 2 (2, 1) required_9)] +def childrenD_33 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) envelope_7), (placed21 3 (0, 5) envelope_8), (placed21 2 (2, 1) envelope_9)] +theorem common_sub_33 : commonEnvelope childrenD_33 ⊆ insert (1, 5) required_33 := by decide +kernel +theorem child_required_sub_33 : ∀ j, childrenC_33 j ⊆ insert (1, 5) required_33 := by decide +kernel +theorem child_envelope_sub_33 : ∀ j, childrenD_33 j ⊆ envelope_33 := by decide +kernel +theorem pivot_mem_33 : (1, 5) ∈ envelope_33 := by decide +kernel +theorem children_work_33 : ∀ j, Template HasSnaky 3 (childrenC_33 j) (childrenD_33 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_8 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (2, 1)).mono (by decide +kernel) +theorem row_works_33 : Template HasSnaky 4 required_33 envelope_33 := by + refine compose HasSnaky 3 childrenC_33 childrenD_33 children_work_33 (1, 5) + required_33 envelope_33 pivot_mem_33 child_required_sub_33 child_envelope_sub_33 ?_ + intro b hb + exact common_sub_33 (mem_commonEnvelope childrenD_33 b hb) +def required_39 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_39 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_39 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 1 (0, 1) required_8)] +def childrenD_39 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_8)] +theorem common_sub_39 : commonEnvelope childrenD_39 ⊆ insert (1, 3) required_39 := by decide +kernel +theorem child_required_sub_39 : ∀ j, childrenC_39 j ⊆ insert (1, 3) required_39 := by decide +kernel +theorem child_envelope_sub_39 : ∀ j, childrenD_39 j ⊆ envelope_39 := by decide +kernel +theorem pivot_mem_39 : (1, 3) ∈ envelope_39 := by decide +kernel +theorem children_work_39 : ∀ j, Template HasSnaky 3 (childrenC_39 j) (childrenD_39 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) +theorem row_works_39 : Template HasSnaky 4 required_39 envelope_39 := by + refine compose HasSnaky 3 childrenC_39 childrenD_39 children_work_39 (1, 3) + required_39 envelope_39 pivot_mem_39 child_required_sub_39 child_envelope_sub_39 ?_ + intro b hb + exact common_sub_39 (mem_commonEnvelope childrenD_39 b hb) +def required_41 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_41 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_41 : Fin 2 → Finset Cell := ![(placed21 2 (1, 0) required_6), (placed21 1 (0, 1) required_24)] +def childrenD_41 : Fin 2 → Finset Cell := ![(placed21 2 (1, 0) envelope_6), (placed21 1 (0, 1) envelope_24)] +theorem common_sub_41 : commonEnvelope childrenD_41 ⊆ insert (1, 4) required_41 := by decide +kernel +theorem child_required_sub_41 : ∀ j, childrenC_41 j ⊆ insert (1, 4) required_41 := by decide +kernel +theorem child_envelope_sub_41 : ∀ j, childrenD_41 j ⊆ envelope_41 := by decide +kernel +theorem pivot_mem_41 : (1, 4) ∈ envelope_41 := by decide +kernel +theorem children_work_41 : ∀ j, Template HasSnaky 3 (childrenC_41 j) (childrenD_41 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 2 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_24 1 (0, 1)).mono (by decide +kernel) +theorem row_works_41 : Template HasSnaky 4 required_41 envelope_41 := by + refine compose HasSnaky 3 childrenC_41 childrenD_41 children_work_41 (1, 4) + required_41 envelope_41 pivot_mem_41 child_required_sub_41 child_envelope_sub_41 ?_ + intro b hb + exact common_sub_41 (mem_commonEnvelope childrenD_41 b hb) +def required_42 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_42 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_42 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 1 (0, 1) required_24)] +def childrenD_42 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_24)] +theorem common_sub_42 : commonEnvelope childrenD_42 ⊆ insert (1, 3) required_42 := by decide +kernel +theorem child_required_sub_42 : ∀ j, childrenC_42 j ⊆ insert (1, 3) required_42 := by decide +kernel +theorem child_envelope_sub_42 : ∀ j, childrenD_42 j ⊆ envelope_42 := by decide +kernel +theorem pivot_mem_42 : (1, 3) ∈ envelope_42 := by decide +kernel +theorem children_work_42 : ∀ j, Template HasSnaky 3 (childrenC_42 j) (childrenD_42 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_24 1 (0, 1)).mono (by decide +kernel) +theorem row_works_42 : Template HasSnaky 4 required_42 envelope_42 := by + refine compose HasSnaky 3 childrenC_42 childrenD_42 children_work_42 (1, 3) + required_42 envelope_42 pivot_mem_42 child_required_sub_42 child_envelope_sub_42 ?_ + intro b hb + exact common_sub_42 (mem_commonEnvelope childrenD_42 b hb) +def required_46 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_46 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_46 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_5), required_45] +def childrenD_46 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_5), envelope_45] +theorem common_sub_46 : commonEnvelope childrenD_46 ⊆ insert (3, 1) required_46 := by decide +kernel +theorem child_required_sub_46 : ∀ j, childrenC_46 j ⊆ insert (3, 1) required_46 := by decide +kernel +theorem child_envelope_sub_46 : ∀ j, childrenD_46 j ⊆ envelope_46 := by decide +kernel +theorem pivot_mem_46 : (3, 1) ∈ envelope_46 := by decide +kernel +theorem children_work_46 : ∀ j, Template HasSnaky 3 (childrenC_46 j) (childrenD_46 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact row_works_45.mono (by decide +kernel) +theorem row_works_46 : Template HasSnaky 4 required_46 envelope_46 := by + refine compose HasSnaky 3 childrenC_46 childrenD_46 children_work_46 (3, 1) + required_46 envelope_46 pivot_mem_46 child_required_sub_46 child_envelope_sub_46 ?_ + intro b hb + exact common_sub_46 (mem_commonEnvelope childrenD_46 b hb) +def required_48 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_48 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_48 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 1 (0, 1) required_24)] +def childrenD_48 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_24)] +theorem common_sub_48 : commonEnvelope childrenD_48 ⊆ insert (1, 4) required_48 := by decide +kernel +theorem child_required_sub_48 : ∀ j, childrenC_48 j ⊆ insert (1, 4) required_48 := by decide +kernel +theorem child_envelope_sub_48 : ∀ j, childrenD_48 j ⊆ envelope_48 := by decide +kernel +theorem pivot_mem_48 : (1, 4) ∈ envelope_48 := by decide +kernel +theorem children_work_48 : ∀ j, Template HasSnaky 3 (childrenC_48 j) (childrenD_48 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_24 1 (0, 1)).mono (by decide +kernel) +theorem row_works_48 : Template HasSnaky 4 required_48 envelope_48 := by + refine compose HasSnaky 3 childrenC_48 childrenD_48 children_work_48 (1, 4) + required_48 envelope_48 pivot_mem_48 child_required_sub_48 child_envelope_sub_48 ?_ + intro b hb + exact common_sub_48 (mem_commonEnvelope childrenD_48 b hb) +def required_49 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_49 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_49 : Fin 2 → Finset Cell := ![(placed21 3 (0, 1) required_6), (placed21 1 (0, 0) required_9)] +def childrenD_49 : Fin 2 → Finset Cell := ![(placed21 3 (0, 1) envelope_6), (placed21 1 (0, 0) envelope_9)] +theorem common_sub_49 : commonEnvelope childrenD_49 ⊆ insert (4, 1) required_49 := by decide +kernel +theorem child_required_sub_49 : ∀ j, childrenC_49 j ⊆ insert (4, 1) required_49 := by decide +kernel +theorem child_envelope_sub_49 : ∀ j, childrenD_49 j ⊆ envelope_49 := by decide +kernel +theorem pivot_mem_49 : (4, 1) ∈ envelope_49 := by decide +kernel +theorem children_work_49 : ∀ j, Template HasSnaky 3 (childrenC_49 j) (childrenD_49 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (0, 0)).mono (by decide +kernel) +theorem row_works_49 : Template HasSnaky 4 required_49 envelope_49 := by + refine compose HasSnaky 3 childrenC_49 childrenD_49 children_work_49 (4, 1) + required_49 envelope_49 pivot_mem_49 child_required_sub_49 child_envelope_sub_49 ?_ + intro b hb + exact common_sub_49 (mem_commonEnvelope childrenD_49 b hb) +def required_50 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_50 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_50 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 1 (0, 1) required_8)] +def childrenD_50 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_8)] +theorem common_sub_50 : commonEnvelope childrenD_50 ⊆ insert (1, 2) required_50 := by decide +kernel +theorem child_required_sub_50 : ∀ j, childrenC_50 j ⊆ insert (1, 2) required_50 := by decide +kernel +theorem child_envelope_sub_50 : ∀ j, childrenD_50 j ⊆ envelope_50 := by decide +kernel +theorem pivot_mem_50 : (1, 2) ∈ envelope_50 := by decide +kernel +theorem children_work_50 : ∀ j, Template HasSnaky 3 (childrenC_50 j) (childrenD_50 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) +theorem row_works_50 : Template HasSnaky 4 required_50 envelope_50 := by + refine compose HasSnaky 3 childrenC_50 childrenD_50 children_work_50 (1, 2) + required_50 envelope_50 pivot_mem_50 child_required_sub_50 child_envelope_sub_50 ?_ + intro b hb + exact common_sub_50 (mem_commonEnvelope childrenD_50 b hb) +def required_55 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_55 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_55 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_5), (placed21 0 (2, 0) required_53)] +def childrenD_55 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_5), (placed21 0 (2, 0) envelope_53)] +theorem common_sub_55 : commonEnvelope childrenD_55 ⊆ insert (3, 4) required_55 := by decide +kernel +theorem child_required_sub_55 : ∀ j, childrenC_55 j ⊆ insert (3, 4) required_55 := by decide +kernel +theorem child_envelope_sub_55 : ∀ j, childrenD_55 j ⊆ envelope_55 := by decide +kernel +theorem pivot_mem_55 : (3, 4) ∈ envelope_55 := by decide +kernel +theorem children_work_55 : ∀ j, Template HasSnaky 3 (childrenC_55 j) (childrenD_55 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_53 0 (2, 0)).mono (by decide +kernel) +theorem row_works_55 : Template HasSnaky 4 required_55 envelope_55 := by + refine compose HasSnaky 3 childrenC_55 childrenD_55 children_work_55 (3, 4) + required_55 envelope_55 pivot_mem_55 child_required_sub_55 child_envelope_sub_55 ?_ + intro b hb + exact common_sub_55 (mem_commonEnvelope childrenD_55 b hb) +def required_56 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_56 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_56 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_5), (placed21 6 (3, 6) required_53)] +def childrenD_56 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_5), (placed21 6 (3, 6) envelope_53)] +theorem common_sub_56 : commonEnvelope childrenD_56 ⊆ insert (3, 4) required_56 := by decide +kernel +theorem child_required_sub_56 : ∀ j, childrenC_56 j ⊆ insert (3, 4) required_56 := by decide +kernel +theorem child_envelope_sub_56 : ∀ j, childrenD_56 j ⊆ envelope_56 := by decide +kernel +theorem pivot_mem_56 : (3, 4) ∈ envelope_56 := by decide +kernel +theorem children_work_56 : ∀ j, Template HasSnaky 3 (childrenC_56 j) (childrenD_56 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_53 6 (3, 6)).mono (by decide +kernel) +theorem row_works_56 : Template HasSnaky 4 required_56 envelope_56 := by + refine compose HasSnaky 3 childrenC_56 childrenD_56 children_work_56 (3, 4) + required_56 envelope_56 pivot_mem_56 child_required_sub_56 child_envelope_sub_56 ?_ + intro b hb + exact common_sub_56 (mem_commonEnvelope childrenD_56 b hb) +def required_57 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_57 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_57 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) required_52), (placed21 6 (3, 6) required_53)] +def childrenD_57 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) envelope_52), (placed21 6 (3, 6) envelope_53)] +theorem common_sub_57 : commonEnvelope childrenD_57 ⊆ insert (3, 4) required_57 := by decide +kernel +theorem child_required_sub_57 : ∀ j, childrenC_57 j ⊆ insert (3, 4) required_57 := by decide +kernel +theorem child_envelope_sub_57 : ∀ j, childrenD_57 j ⊆ envelope_57 := by decide +kernel +theorem pivot_mem_57 : (3, 4) ∈ envelope_57 := by decide +kernel +theorem children_work_57 : ∀ j, Template HasSnaky 3 (childrenC_57 j) (childrenD_57 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_53 6 (3, 6)).mono (by decide +kernel) +theorem row_works_57 : Template HasSnaky 4 required_57 envelope_57 := by + refine compose HasSnaky 3 childrenC_57 childrenD_57 children_work_57 (3, 4) + required_57 envelope_57 pivot_mem_57 child_required_sub_57 child_envelope_sub_57 ?_ + intro b hb + exact common_sub_57 (mem_commonEnvelope childrenD_57 b hb) +def required_58 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_58 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_58 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_2), (placed21 0 (3, 0) required_52)] +def childrenD_58 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_2), (placed21 0 (3, 0) envelope_52)] +theorem common_sub_58 : commonEnvelope childrenD_58 ⊆ insert (4, 3) required_58 := by decide +kernel +theorem child_required_sub_58 : ∀ j, childrenC_58 j ⊆ insert (4, 3) required_58 := by decide +kernel +theorem child_envelope_sub_58 : ∀ j, childrenD_58 j ⊆ envelope_58 := by decide +kernel +theorem pivot_mem_58 : (4, 3) ∈ envelope_58 := by decide +kernel +theorem children_work_58 : ∀ j, Template HasSnaky 3 (childrenC_58 j) (childrenD_58 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (3, 0)).mono (by decide +kernel) +theorem row_works_58 : Template HasSnaky 4 required_58 envelope_58 := by + refine compose HasSnaky 3 childrenC_58 childrenD_58 children_work_58 (4, 3) + required_58 envelope_58 pivot_mem_58 child_required_sub_58 child_envelope_sub_58 ?_ + intro b hb + exact common_sub_58 (mem_commonEnvelope childrenD_58 b hb) +def required_60 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_60 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_60 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_0), (placed21 2 (1, 0) required_52)] +def childrenD_60 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_0), (placed21 2 (1, 0) envelope_52)] +theorem common_sub_60 : commonEnvelope childrenD_60 ⊆ insert (0, 3) required_60 := by decide +kernel +theorem child_required_sub_60 : ∀ j, childrenC_60 j ⊆ insert (0, 3) required_60 := by decide +kernel +theorem child_envelope_sub_60 : ∀ j, childrenD_60 j ⊆ envelope_60 := by decide +kernel +theorem pivot_mem_60 : (0, 3) ∈ envelope_60 := by decide +kernel +theorem children_work_60 : ∀ j, Template HasSnaky 3 (childrenC_60 j) (childrenD_60 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (1, 0)).mono (by decide +kernel) +theorem row_works_60 : Template HasSnaky 4 required_60 envelope_60 := by + refine compose HasSnaky 3 childrenC_60 childrenD_60 children_work_60 (0, 3) + required_60 envelope_60 pivot_mem_60 child_required_sub_60 child_envelope_sub_60 ?_ + intro b hb + exact common_sub_60 (mem_commonEnvelope childrenD_60 b hb) +def required_63 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_63 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_63 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) required_16), (placed21 1 (0, 1) required_24), (placed21 4 (0, 5) required_62)] +def childrenD_63 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) envelope_16), (placed21 1 (0, 1) envelope_24), (placed21 4 (0, 5) envelope_62)] +theorem common_sub_63 : commonEnvelope childrenD_63 ⊆ insert (1, 4) required_63 := by decide +kernel +theorem child_required_sub_63 : ∀ j, childrenC_63 j ⊆ insert (1, 4) required_63 := by decide +kernel +theorem child_envelope_sub_63 : ∀ j, childrenD_63 j ⊆ envelope_63 := by decide +kernel +theorem pivot_mem_63 : (1, 4) ∈ envelope_63 := by decide +kernel +theorem children_work_63 : ∀ j, Template HasSnaky 3 (childrenC_63 j) (childrenD_63 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_16 2 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_24 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_62 4 (0, 5)).mono (by decide +kernel) +theorem row_works_63 : Template HasSnaky 4 required_63 envelope_63 := by + refine compose HasSnaky 3 childrenC_63 childrenD_63 children_work_63 (1, 4) + required_63 envelope_63 pivot_mem_63 child_required_sub_63 child_envelope_sub_63 ?_ + intro b hb + exact common_sub_63 (mem_commonEnvelope childrenD_63 b hb) +def required_65 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_65 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_65 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_20), (placed21 4 (0, 5) required_20)] +def childrenD_65 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_20), (placed21 4 (0, 5) envelope_20)] +theorem common_sub_65 : commonEnvelope childrenD_65 ⊆ insert (1, 5) required_65 := by decide +kernel +theorem child_required_sub_65 : ∀ j, childrenC_65 j ⊆ insert (1, 5) required_65 := by decide +kernel +theorem child_envelope_sub_65 : ∀ j, childrenD_65 j ⊆ envelope_65 := by decide +kernel +theorem pivot_mem_65 : (1, 5) ∈ envelope_65 := by decide +kernel +theorem children_work_65 : ∀ j, Template HasSnaky 3 (childrenC_65 j) (childrenD_65 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_20 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_20 4 (0, 5)).mono (by decide +kernel) +theorem row_works_65 : Template HasSnaky 4 required_65 envelope_65 := by + refine compose HasSnaky 3 childrenC_65 childrenD_65 children_work_65 (1, 5) + required_65 envelope_65 pivot_mem_65 child_required_sub_65 child_envelope_sub_65 ?_ + intro b hb + exact common_sub_65 (mem_commonEnvelope childrenD_65 b hb) +def height_10 : ℕ := 4 +def childrenH_10 : Fin 2 → ℕ := ![height_5, height_8] +theorem height_exact_10 : height_10 = 1 + Finset.univ.sup childrenH_10 := by decide +kernel +theorem required_origin_10 : ∀ x ∈ required_10, + (∃ j, x ∈ childrenC_10 j) ∨ ∀ j, x ∈ childrenD_10 j := by decide +kernel +theorem required_exact_10 : required_10 = + ((Finset.univ.biUnion childrenC_10) ∪ commonEnvelope childrenD_10).erase (1, 4) := by + exact required_eq_combination childrenC_10 childrenD_10 (1, 4) required_10 + (by decide +kernel) child_required_sub_10 common_sub_10 required_origin_10 +theorem envelope_origin_10 : ∀ x ∈ envelope_10, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_10 j := by decide +kernel +theorem envelope_exact_10 : envelope_10 = + insert (1, 4) (Finset.univ.biUnion childrenD_10) := by + exact envelope_eq_combination childrenD_10 (1, 4) envelope_10 + pivot_mem_10 child_envelope_sub_10 envelope_origin_10 +def checked_10 : CheckedCard where + required := required_10 + envelope := envelope_10 + height := height_10 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_10 +def height_12 : ℕ := 4 +def childrenH_12 : Fin 3 → ℕ := ![height_7, height_8, height_9] +theorem height_exact_12 : height_12 = 1 + Finset.univ.sup childrenH_12 := by decide +kernel +theorem required_origin_12 : ∀ x ∈ required_12, + (∃ j, x ∈ childrenC_12 j) ∨ ∀ j, x ∈ childrenD_12 j := by decide +kernel +theorem required_exact_12 : required_12 = + ((Finset.univ.biUnion childrenC_12) ∪ commonEnvelope childrenD_12).erase (1, 5) := by + exact required_eq_combination childrenC_12 childrenD_12 (1, 5) required_12 + (by decide +kernel) child_required_sub_12 common_sub_12 required_origin_12 +theorem envelope_origin_12 : ∀ x ∈ envelope_12, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_12 j := by decide +kernel +theorem envelope_exact_12 : envelope_12 = + insert (1, 5) (Finset.univ.biUnion childrenD_12) := by + exact envelope_eq_combination childrenD_12 (1, 5) envelope_12 + pivot_mem_12 child_envelope_sub_12 envelope_origin_12 +def checked_12 : CheckedCard where + required := required_12 + envelope := envelope_12 + height := height_12 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_12 +def height_13 : ℕ := 4 +def childrenH_13 : Fin 3 → ℕ := ![height_7, height_8, height_9] +theorem height_exact_13 : height_13 = 1 + Finset.univ.sup childrenH_13 := by decide +kernel +theorem required_origin_13 : ∀ x ∈ required_13, + (∃ j, x ∈ childrenC_13 j) ∨ ∀ j, x ∈ childrenD_13 j := by decide +kernel +theorem required_exact_13 : required_13 = + ((Finset.univ.biUnion childrenC_13) ∪ commonEnvelope childrenD_13).erase (1, 5) := by + exact required_eq_combination childrenC_13 childrenD_13 (1, 5) required_13 + (by decide +kernel) child_required_sub_13 common_sub_13 required_origin_13 +theorem envelope_origin_13 : ∀ x ∈ envelope_13, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_13 j := by decide +kernel +theorem envelope_exact_13 : envelope_13 = + insert (1, 5) (Finset.univ.biUnion childrenD_13) := by + exact envelope_eq_combination childrenD_13 (1, 5) envelope_13 + pivot_mem_13 child_envelope_sub_13 envelope_origin_13 +def checked_13 : CheckedCard where + required := required_13 + envelope := envelope_13 + height := height_13 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_13 +def height_14 : ℕ := 4 +def childrenH_14 : Fin 3 → ℕ := ![height_7, height_8, height_9] +theorem height_exact_14 : height_14 = 1 + Finset.univ.sup childrenH_14 := by decide +kernel +theorem required_origin_14 : ∀ x ∈ required_14, + (∃ j, x ∈ childrenC_14 j) ∨ ∀ j, x ∈ childrenD_14 j := by decide +kernel +theorem required_exact_14 : required_14 = + ((Finset.univ.biUnion childrenC_14) ∪ commonEnvelope childrenD_14).erase (1, 5) := by + exact required_eq_combination childrenC_14 childrenD_14 (1, 5) required_14 + (by decide +kernel) child_required_sub_14 common_sub_14 required_origin_14 +theorem envelope_origin_14 : ∀ x ∈ envelope_14, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_14 j := by decide +kernel +theorem envelope_exact_14 : envelope_14 = + insert (1, 5) (Finset.univ.biUnion childrenD_14) := by + exact envelope_eq_combination childrenD_14 (1, 5) envelope_14 + pivot_mem_14 child_envelope_sub_14 envelope_origin_14 +def checked_14 : CheckedCard where + required := required_14 + envelope := envelope_14 + height := height_14 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_14 +def height_17 : ℕ := 4 +def childrenH_17 : Fin 2 → ℕ := ![height_6, height_16] +theorem height_exact_17 : height_17 = 1 + Finset.univ.sup childrenH_17 := by decide +kernel +theorem required_origin_17 : ∀ x ∈ required_17, + (∃ j, x ∈ childrenC_17 j) ∨ ∀ j, x ∈ childrenD_17 j := by decide +kernel +theorem required_exact_17 : required_17 = + ((Finset.univ.biUnion childrenC_17) ∪ commonEnvelope childrenD_17).erase (1, 4) := by + exact required_eq_combination childrenC_17 childrenD_17 (1, 4) required_17 + (by decide +kernel) child_required_sub_17 common_sub_17 required_origin_17 +theorem envelope_origin_17 : ∀ x ∈ envelope_17, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_17 j := by decide +kernel +theorem envelope_exact_17 : envelope_17 = + insert (1, 4) (Finset.univ.biUnion childrenD_17) := by + exact envelope_eq_combination childrenD_17 (1, 4) envelope_17 + pivot_mem_17 child_envelope_sub_17 envelope_origin_17 +def checked_17 : CheckedCard where + required := required_17 + envelope := envelope_17 + height := height_17 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_17 +def height_18 : ℕ := 4 +def childrenH_18 : Fin 2 → ℕ := ![height_4, height_8] +theorem height_exact_18 : height_18 = 1 + Finset.univ.sup childrenH_18 := by decide +kernel +theorem required_origin_18 : ∀ x ∈ required_18, + (∃ j, x ∈ childrenC_18 j) ∨ ∀ j, x ∈ childrenD_18 j := by decide +kernel +theorem required_exact_18 : required_18 = + ((Finset.univ.biUnion childrenC_18) ∪ commonEnvelope childrenD_18).erase (1, 4) := by + exact required_eq_combination childrenC_18 childrenD_18 (1, 4) required_18 + (by decide +kernel) child_required_sub_18 common_sub_18 required_origin_18 +theorem envelope_origin_18 : ∀ x ∈ envelope_18, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_18 j := by decide +kernel +theorem envelope_exact_18 : envelope_18 = + insert (1, 4) (Finset.univ.biUnion childrenD_18) := by + exact envelope_eq_combination childrenD_18 (1, 4) envelope_18 + pivot_mem_18 child_envelope_sub_18 envelope_origin_18 +def checked_18 : CheckedCard where + required := required_18 + envelope := envelope_18 + height := height_18 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_18 +def height_26 : ℕ := 4 +def childrenH_26 : Fin 2 → ℕ := ![height_6, height_7] +theorem height_exact_26 : height_26 = 1 + Finset.univ.sup childrenH_26 := by decide +kernel +theorem required_origin_26 : ∀ x ∈ required_26, + (∃ j, x ∈ childrenC_26 j) ∨ ∀ j, x ∈ childrenD_26 j := by decide +kernel +theorem required_exact_26 : required_26 = + ((Finset.univ.biUnion childrenC_26) ∪ commonEnvelope childrenD_26).erase (4, 1) := by + exact required_eq_combination childrenC_26 childrenD_26 (4, 1) required_26 + (by decide +kernel) child_required_sub_26 common_sub_26 required_origin_26 +theorem envelope_origin_26 : ∀ x ∈ envelope_26, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_26 j := by decide +kernel +theorem envelope_exact_26 : envelope_26 = + insert (4, 1) (Finset.univ.biUnion childrenD_26) := by + exact envelope_eq_combination childrenD_26 (4, 1) envelope_26 + pivot_mem_26 child_envelope_sub_26 envelope_origin_26 +def checked_26 : CheckedCard where + required := required_26 + envelope := envelope_26 + height := height_26 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_26 +def height_27 : ℕ := 4 +def childrenH_27 : Fin 2 → ℕ := ![height_5, height_16] +theorem height_exact_27 : height_27 = 1 + Finset.univ.sup childrenH_27 := by decide +kernel +theorem required_origin_27 : ∀ x ∈ required_27, + (∃ j, x ∈ childrenC_27 j) ∨ ∀ j, x ∈ childrenD_27 j := by decide +kernel +theorem required_exact_27 : required_27 = + ((Finset.univ.biUnion childrenC_27) ∪ commonEnvelope childrenD_27).erase (0, 4) := by + exact required_eq_combination childrenC_27 childrenD_27 (0, 4) required_27 + (by decide +kernel) child_required_sub_27 common_sub_27 required_origin_27 +theorem envelope_origin_27 : ∀ x ∈ envelope_27, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_27 j := by decide +kernel +theorem envelope_exact_27 : envelope_27 = + insert (0, 4) (Finset.univ.biUnion childrenD_27) := by + exact envelope_eq_combination childrenD_27 (0, 4) envelope_27 + pivot_mem_27 child_envelope_sub_27 envelope_origin_27 +def checked_27 : CheckedCard where + required := required_27 + envelope := envelope_27 + height := height_27 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_27 +def height_31 : ℕ := 4 +def childrenH_31 : Fin 2 → ℕ := ![height_8, height_8] +theorem height_exact_31 : height_31 = 1 + Finset.univ.sup childrenH_31 := by decide +kernel +theorem required_origin_31 : ∀ x ∈ required_31, + (∃ j, x ∈ childrenC_31 j) ∨ ∀ j, x ∈ childrenD_31 j := by decide +kernel +theorem required_exact_31 : required_31 = + ((Finset.univ.biUnion childrenC_31) ∪ commonEnvelope childrenD_31).erase (1, 5) := by + exact required_eq_combination childrenC_31 childrenD_31 (1, 5) required_31 + (by decide +kernel) child_required_sub_31 common_sub_31 required_origin_31 +theorem envelope_origin_31 : ∀ x ∈ envelope_31, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_31 j := by decide +kernel +theorem envelope_exact_31 : envelope_31 = + insert (1, 5) (Finset.univ.biUnion childrenD_31) := by + exact envelope_eq_combination childrenD_31 (1, 5) envelope_31 + pivot_mem_31 child_envelope_sub_31 envelope_origin_31 +def checked_31 : CheckedCard where + required := required_31 + envelope := envelope_31 + height := height_31 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_31 +def height_33 : ℕ := 4 +def childrenH_33 : Fin 3 → ℕ := ![height_7, height_8, height_9] +theorem height_exact_33 : height_33 = 1 + Finset.univ.sup childrenH_33 := by decide +kernel +theorem required_origin_33 : ∀ x ∈ required_33, + (∃ j, x ∈ childrenC_33 j) ∨ ∀ j, x ∈ childrenD_33 j := by decide +kernel +theorem required_exact_33 : required_33 = + ((Finset.univ.biUnion childrenC_33) ∪ commonEnvelope childrenD_33).erase (1, 5) := by + exact required_eq_combination childrenC_33 childrenD_33 (1, 5) required_33 + (by decide +kernel) child_required_sub_33 common_sub_33 required_origin_33 +theorem envelope_origin_33 : ∀ x ∈ envelope_33, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_33 j := by decide +kernel +theorem envelope_exact_33 : envelope_33 = + insert (1, 5) (Finset.univ.biUnion childrenD_33) := by + exact envelope_eq_combination childrenD_33 (1, 5) envelope_33 + pivot_mem_33 child_envelope_sub_33 envelope_origin_33 +def checked_33 : CheckedCard where + required := required_33 + envelope := envelope_33 + height := height_33 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_33 +def height_39 : ℕ := 4 +def childrenH_39 : Fin 2 → ℕ := ![height_5, height_8] +theorem height_exact_39 : height_39 = 1 + Finset.univ.sup childrenH_39 := by decide +kernel +theorem required_origin_39 : ∀ x ∈ required_39, + (∃ j, x ∈ childrenC_39 j) ∨ ∀ j, x ∈ childrenD_39 j := by decide +kernel +theorem required_exact_39 : required_39 = + ((Finset.univ.biUnion childrenC_39) ∪ commonEnvelope childrenD_39).erase (1, 3) := by + exact required_eq_combination childrenC_39 childrenD_39 (1, 3) required_39 + (by decide +kernel) child_required_sub_39 common_sub_39 required_origin_39 +theorem envelope_origin_39 : ∀ x ∈ envelope_39, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_39 j := by decide +kernel +theorem envelope_exact_39 : envelope_39 = + insert (1, 3) (Finset.univ.biUnion childrenD_39) := by + exact envelope_eq_combination childrenD_39 (1, 3) envelope_39 + pivot_mem_39 child_envelope_sub_39 envelope_origin_39 +def checked_39 : CheckedCard where + required := required_39 + envelope := envelope_39 + height := height_39 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_39 +def height_41 : ℕ := 4 +def childrenH_41 : Fin 2 → ℕ := ![height_6, height_24] +theorem height_exact_41 : height_41 = 1 + Finset.univ.sup childrenH_41 := by decide +kernel +theorem required_origin_41 : ∀ x ∈ required_41, + (∃ j, x ∈ childrenC_41 j) ∨ ∀ j, x ∈ childrenD_41 j := by decide +kernel +theorem required_exact_41 : required_41 = + ((Finset.univ.biUnion childrenC_41) ∪ commonEnvelope childrenD_41).erase (1, 4) := by + exact required_eq_combination childrenC_41 childrenD_41 (1, 4) required_41 + (by decide +kernel) child_required_sub_41 common_sub_41 required_origin_41 +theorem envelope_origin_41 : ∀ x ∈ envelope_41, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_41 j := by decide +kernel +theorem envelope_exact_41 : envelope_41 = + insert (1, 4) (Finset.univ.biUnion childrenD_41) := by + exact envelope_eq_combination childrenD_41 (1, 4) envelope_41 + pivot_mem_41 child_envelope_sub_41 envelope_origin_41 +def checked_41 : CheckedCard where + required := required_41 + envelope := envelope_41 + height := height_41 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_41 +def height_42 : ℕ := 4 +def childrenH_42 : Fin 2 → ℕ := ![height_5, height_24] +theorem height_exact_42 : height_42 = 1 + Finset.univ.sup childrenH_42 := by decide +kernel +theorem required_origin_42 : ∀ x ∈ required_42, + (∃ j, x ∈ childrenC_42 j) ∨ ∀ j, x ∈ childrenD_42 j := by decide +kernel +theorem required_exact_42 : required_42 = + ((Finset.univ.biUnion childrenC_42) ∪ commonEnvelope childrenD_42).erase (1, 3) := by + exact required_eq_combination childrenC_42 childrenD_42 (1, 3) required_42 + (by decide +kernel) child_required_sub_42 common_sub_42 required_origin_42 +theorem envelope_origin_42 : ∀ x ∈ envelope_42, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_42 j := by decide +kernel +theorem envelope_exact_42 : envelope_42 = + insert (1, 3) (Finset.univ.biUnion childrenD_42) := by + exact envelope_eq_combination childrenD_42 (1, 3) envelope_42 + pivot_mem_42 child_envelope_sub_42 envelope_origin_42 +def checked_42 : CheckedCard where + required := required_42 + envelope := envelope_42 + height := height_42 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_42 +def height_46 : ℕ := 4 +def childrenH_46 : Fin 2 → ℕ := ![height_5, height_45] +theorem height_exact_46 : height_46 = 1 + Finset.univ.sup childrenH_46 := by decide +kernel +theorem required_origin_46 : ∀ x ∈ required_46, + (∃ j, x ∈ childrenC_46 j) ∨ ∀ j, x ∈ childrenD_46 j := by decide +kernel +theorem required_exact_46 : required_46 = + ((Finset.univ.biUnion childrenC_46) ∪ commonEnvelope childrenD_46).erase (3, 1) := by + exact required_eq_combination childrenC_46 childrenD_46 (3, 1) required_46 + (by decide +kernel) child_required_sub_46 common_sub_46 required_origin_46 +theorem envelope_origin_46 : ∀ x ∈ envelope_46, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_46 j := by decide +kernel +theorem envelope_exact_46 : envelope_46 = + insert (3, 1) (Finset.univ.biUnion childrenD_46) := by + exact envelope_eq_combination childrenD_46 (3, 1) envelope_46 + pivot_mem_46 child_envelope_sub_46 envelope_origin_46 +def checked_46 : CheckedCard where + required := required_46 + envelope := envelope_46 + height := height_46 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_46 +def height_48 : ℕ := 4 +def childrenH_48 : Fin 2 → ℕ := ![height_5, height_24] +theorem height_exact_48 : height_48 = 1 + Finset.univ.sup childrenH_48 := by decide +kernel +theorem required_origin_48 : ∀ x ∈ required_48, + (∃ j, x ∈ childrenC_48 j) ∨ ∀ j, x ∈ childrenD_48 j := by decide +kernel +theorem required_exact_48 : required_48 = + ((Finset.univ.biUnion childrenC_48) ∪ commonEnvelope childrenD_48).erase (1, 4) := by + exact required_eq_combination childrenC_48 childrenD_48 (1, 4) required_48 + (by decide +kernel) child_required_sub_48 common_sub_48 required_origin_48 +theorem envelope_origin_48 : ∀ x ∈ envelope_48, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_48 j := by decide +kernel +theorem envelope_exact_48 : envelope_48 = + insert (1, 4) (Finset.univ.biUnion childrenD_48) := by + exact envelope_eq_combination childrenD_48 (1, 4) envelope_48 + pivot_mem_48 child_envelope_sub_48 envelope_origin_48 +def checked_48 : CheckedCard where + required := required_48 + envelope := envelope_48 + height := height_48 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_48 +def height_49 : ℕ := 4 +def childrenH_49 : Fin 2 → ℕ := ![height_6, height_9] +theorem height_exact_49 : height_49 = 1 + Finset.univ.sup childrenH_49 := by decide +kernel +theorem required_origin_49 : ∀ x ∈ required_49, + (∃ j, x ∈ childrenC_49 j) ∨ ∀ j, x ∈ childrenD_49 j := by decide +kernel +theorem required_exact_49 : required_49 = + ((Finset.univ.biUnion childrenC_49) ∪ commonEnvelope childrenD_49).erase (4, 1) := by + exact required_eq_combination childrenC_49 childrenD_49 (4, 1) required_49 + (by decide +kernel) child_required_sub_49 common_sub_49 required_origin_49 +theorem envelope_origin_49 : ∀ x ∈ envelope_49, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_49 j := by decide +kernel +theorem envelope_exact_49 : envelope_49 = + insert (4, 1) (Finset.univ.biUnion childrenD_49) := by + exact envelope_eq_combination childrenD_49 (4, 1) envelope_49 + pivot_mem_49 child_envelope_sub_49 envelope_origin_49 +def checked_49 : CheckedCard where + required := required_49 + envelope := envelope_49 + height := height_49 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_49 +def height_50 : ℕ := 4 +def childrenH_50 : Fin 2 → ℕ := ![height_5, height_8] +theorem height_exact_50 : height_50 = 1 + Finset.univ.sup childrenH_50 := by decide +kernel +theorem required_origin_50 : ∀ x ∈ required_50, + (∃ j, x ∈ childrenC_50 j) ∨ ∀ j, x ∈ childrenD_50 j := by decide +kernel +theorem required_exact_50 : required_50 = + ((Finset.univ.biUnion childrenC_50) ∪ commonEnvelope childrenD_50).erase (1, 2) := by + exact required_eq_combination childrenC_50 childrenD_50 (1, 2) required_50 + (by decide +kernel) child_required_sub_50 common_sub_50 required_origin_50 +theorem envelope_origin_50 : ∀ x ∈ envelope_50, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_50 j := by decide +kernel +theorem envelope_exact_50 : envelope_50 = + insert (1, 2) (Finset.univ.biUnion childrenD_50) := by + exact envelope_eq_combination childrenD_50 (1, 2) envelope_50 + pivot_mem_50 child_envelope_sub_50 envelope_origin_50 +def checked_50 : CheckedCard where + required := required_50 + envelope := envelope_50 + height := height_50 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_50 +def height_55 : ℕ := 4 +def childrenH_55 : Fin 2 → ℕ := ![height_5, height_53] +theorem height_exact_55 : height_55 = 1 + Finset.univ.sup childrenH_55 := by decide +kernel +theorem required_origin_55 : ∀ x ∈ required_55, + (∃ j, x ∈ childrenC_55 j) ∨ ∀ j, x ∈ childrenD_55 j := by decide +kernel +theorem required_exact_55 : required_55 = + ((Finset.univ.biUnion childrenC_55) ∪ commonEnvelope childrenD_55).erase (3, 4) := by + exact required_eq_combination childrenC_55 childrenD_55 (3, 4) required_55 + (by decide +kernel) child_required_sub_55 common_sub_55 required_origin_55 +theorem envelope_origin_55 : ∀ x ∈ envelope_55, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_55 j := by decide +kernel +theorem envelope_exact_55 : envelope_55 = + insert (3, 4) (Finset.univ.biUnion childrenD_55) := by + exact envelope_eq_combination childrenD_55 (3, 4) envelope_55 + pivot_mem_55 child_envelope_sub_55 envelope_origin_55 +def checked_55 : CheckedCard where + required := required_55 + envelope := envelope_55 + height := height_55 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_55 +def height_56 : ℕ := 4 +def childrenH_56 : Fin 2 → ℕ := ![height_5, height_53] +theorem height_exact_56 : height_56 = 1 + Finset.univ.sup childrenH_56 := by decide +kernel +theorem required_origin_56 : ∀ x ∈ required_56, + (∃ j, x ∈ childrenC_56 j) ∨ ∀ j, x ∈ childrenD_56 j := by decide +kernel +theorem required_exact_56 : required_56 = + ((Finset.univ.biUnion childrenC_56) ∪ commonEnvelope childrenD_56).erase (3, 4) := by + exact required_eq_combination childrenC_56 childrenD_56 (3, 4) required_56 + (by decide +kernel) child_required_sub_56 common_sub_56 required_origin_56 +theorem envelope_origin_56 : ∀ x ∈ envelope_56, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_56 j := by decide +kernel +theorem envelope_exact_56 : envelope_56 = + insert (3, 4) (Finset.univ.biUnion childrenD_56) := by + exact envelope_eq_combination childrenD_56 (3, 4) envelope_56 + pivot_mem_56 child_envelope_sub_56 envelope_origin_56 +def checked_56 : CheckedCard where + required := required_56 + envelope := envelope_56 + height := height_56 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_56 +def height_57 : ℕ := 4 +def childrenH_57 : Fin 2 → ℕ := ![height_52, height_53] +theorem height_exact_57 : height_57 = 1 + Finset.univ.sup childrenH_57 := by decide +kernel +theorem required_origin_57 : ∀ x ∈ required_57, + (∃ j, x ∈ childrenC_57 j) ∨ ∀ j, x ∈ childrenD_57 j := by decide +kernel +theorem required_exact_57 : required_57 = + ((Finset.univ.biUnion childrenC_57) ∪ commonEnvelope childrenD_57).erase (3, 4) := by + exact required_eq_combination childrenC_57 childrenD_57 (3, 4) required_57 + (by decide +kernel) child_required_sub_57 common_sub_57 required_origin_57 +theorem envelope_origin_57 : ∀ x ∈ envelope_57, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_57 j := by decide +kernel +theorem envelope_exact_57 : envelope_57 = + insert (3, 4) (Finset.univ.biUnion childrenD_57) := by + exact envelope_eq_combination childrenD_57 (3, 4) envelope_57 + pivot_mem_57 child_envelope_sub_57 envelope_origin_57 +def checked_57 : CheckedCard where + required := required_57 + envelope := envelope_57 + height := height_57 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_57 +def height_58 : ℕ := 4 +def childrenH_58 : Fin 2 → ℕ := ![height_2, height_52] +theorem height_exact_58 : height_58 = 1 + Finset.univ.sup childrenH_58 := by decide +kernel +theorem required_origin_58 : ∀ x ∈ required_58, + (∃ j, x ∈ childrenC_58 j) ∨ ∀ j, x ∈ childrenD_58 j := by decide +kernel +theorem required_exact_58 : required_58 = + ((Finset.univ.biUnion childrenC_58) ∪ commonEnvelope childrenD_58).erase (4, 3) := by + exact required_eq_combination childrenC_58 childrenD_58 (4, 3) required_58 + (by decide +kernel) child_required_sub_58 common_sub_58 required_origin_58 +theorem envelope_origin_58 : ∀ x ∈ envelope_58, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_58 j := by decide +kernel +theorem envelope_exact_58 : envelope_58 = + insert (4, 3) (Finset.univ.biUnion childrenD_58) := by + exact envelope_eq_combination childrenD_58 (4, 3) envelope_58 + pivot_mem_58 child_envelope_sub_58 envelope_origin_58 +def checked_58 : CheckedCard where + required := required_58 + envelope := envelope_58 + height := height_58 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_58 +def height_60 : ℕ := 4 +def childrenH_60 : Fin 2 → ℕ := ![height_0, height_52] +theorem height_exact_60 : height_60 = 1 + Finset.univ.sup childrenH_60 := by decide +kernel +theorem required_origin_60 : ∀ x ∈ required_60, + (∃ j, x ∈ childrenC_60 j) ∨ ∀ j, x ∈ childrenD_60 j := by decide +kernel +theorem required_exact_60 : required_60 = + ((Finset.univ.biUnion childrenC_60) ∪ commonEnvelope childrenD_60).erase (0, 3) := by + exact required_eq_combination childrenC_60 childrenD_60 (0, 3) required_60 + (by decide +kernel) child_required_sub_60 common_sub_60 required_origin_60 +theorem envelope_origin_60 : ∀ x ∈ envelope_60, + x = (0, 3) ∨ ∃ j, x ∈ childrenD_60 j := by decide +kernel +theorem envelope_exact_60 : envelope_60 = + insert (0, 3) (Finset.univ.biUnion childrenD_60) := by + exact envelope_eq_combination childrenD_60 (0, 3) envelope_60 + pivot_mem_60 child_envelope_sub_60 envelope_origin_60 +def checked_60 : CheckedCard where + required := required_60 + envelope := envelope_60 + height := height_60 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_60 +def height_63 : ℕ := 4 +def childrenH_63 : Fin 3 → ℕ := ![height_16, height_24, height_62] +theorem height_exact_63 : height_63 = 1 + Finset.univ.sup childrenH_63 := by decide +kernel +theorem required_origin_63 : ∀ x ∈ required_63, + (∃ j, x ∈ childrenC_63 j) ∨ ∀ j, x ∈ childrenD_63 j := by decide +kernel +theorem required_exact_63 : required_63 = + ((Finset.univ.biUnion childrenC_63) ∪ commonEnvelope childrenD_63).erase (1, 4) := by + exact required_eq_combination childrenC_63 childrenD_63 (1, 4) required_63 + (by decide +kernel) child_required_sub_63 common_sub_63 required_origin_63 +theorem envelope_origin_63 : ∀ x ∈ envelope_63, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_63 j := by decide +kernel +theorem envelope_exact_63 : envelope_63 = + insert (1, 4) (Finset.univ.biUnion childrenD_63) := by + exact envelope_eq_combination childrenD_63 (1, 4) envelope_63 + pivot_mem_63 child_envelope_sub_63 envelope_origin_63 +def checked_63 : CheckedCard where + required := required_63 + envelope := envelope_63 + height := height_63 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_63 +def height_65 : ℕ := 4 +def childrenH_65 : Fin 2 → ℕ := ![height_20, height_20] +theorem height_exact_65 : height_65 = 1 + Finset.univ.sup childrenH_65 := by decide +kernel +theorem required_origin_65 : ∀ x ∈ required_65, + (∃ j, x ∈ childrenC_65 j) ∨ ∀ j, x ∈ childrenD_65 j := by decide +kernel +theorem required_exact_65 : required_65 = + ((Finset.univ.biUnion childrenC_65) ∪ commonEnvelope childrenD_65).erase (1, 5) := by + exact required_eq_combination childrenC_65 childrenD_65 (1, 5) required_65 + (by decide +kernel) child_required_sub_65 common_sub_65 required_origin_65 +theorem envelope_origin_65 : ∀ x ∈ envelope_65, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_65 j := by decide +kernel +theorem envelope_exact_65 : envelope_65 = + insert (1, 5) (Finset.univ.biUnion childrenD_65) := by + exact envelope_eq_combination childrenD_65 (1, 5) envelope_65 + pivot_mem_65 child_envelope_sub_65 envelope_origin_65 +def checked_65 : CheckedCard where + required := required_65 + envelope := envelope_65 + height := height_65 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_65 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part02.lean new file mode 100644 index 0000000..22fbb28 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part02.lean @@ -0,0 +1,1001 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_67 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_67 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 4), (2, 5), (2, 6), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_67 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_8), (placed21 3 (0, 4) required_32)] +def childrenD_67 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_8), (placed21 3 (0, 4) envelope_32)] +theorem common_sub_67 : commonEnvelope childrenD_67 ⊆ insert (1, 1) required_67 := by decide +kernel +theorem child_required_sub_67 : ∀ j, childrenC_67 j ⊆ insert (1, 1) required_67 := by decide +kernel +theorem child_envelope_sub_67 : ∀ j, childrenD_67 j ⊆ envelope_67 := by decide +kernel +theorem pivot_mem_67 : (1, 1) ∈ envelope_67 := by decide +kernel +theorem children_work_67 : ∀ j, Template HasSnaky 3 (childrenC_67 j) (childrenD_67 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_32 3 (0, 4)).mono (by decide +kernel) +theorem row_works_67 : Template HasSnaky 4 required_67 envelope_67 := by + refine compose HasSnaky 3 childrenC_67 childrenD_67 children_work_67 (1, 1) + required_67 envelope_67 pivot_mem_67 child_required_sub_67 child_envelope_sub_67 ?_ + intro b hb + exact common_sub_67 (mem_commonEnvelope childrenD_67 b hb) +def required_73 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_73 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_73 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_0), (placed21 0 (1, 0) required_52)] +def childrenD_73 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_0), (placed21 0 (1, 0) envelope_52)] +theorem common_sub_73 : commonEnvelope childrenD_73 ⊆ insert (2, 3) required_73 := by decide +kernel +theorem child_required_sub_73 : ∀ j, childrenC_73 j ⊆ insert (2, 3) required_73 := by decide +kernel +theorem child_envelope_sub_73 : ∀ j, childrenD_73 j ⊆ envelope_73 := by decide +kernel +theorem pivot_mem_73 : (2, 3) ∈ envelope_73 := by decide +kernel +theorem children_work_73 : ∀ j, Template HasSnaky 3 (childrenC_73 j) (childrenD_73 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (1, 0)).mono (by decide +kernel) +theorem row_works_73 : Template HasSnaky 4 required_73 envelope_73 := by + refine compose HasSnaky 3 childrenC_73 childrenD_73 children_work_73 (2, 3) + required_73 envelope_73 pivot_mem_73 child_required_sub_73 child_envelope_sub_73 ?_ + intro b hb + exact common_sub_73 (mem_commonEnvelope childrenD_73 b hb) +def required_75 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_75 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_75 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_20), (placed21 6 (1, 5) required_23)] +def childrenD_75 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_20), (placed21 6 (1, 5) envelope_23)] +theorem common_sub_75 : commonEnvelope childrenD_75 ⊆ insert (0, 4) required_75 := by decide +kernel +theorem child_required_sub_75 : ∀ j, childrenC_75 j ⊆ insert (0, 4) required_75 := by decide +kernel +theorem child_envelope_sub_75 : ∀ j, childrenD_75 j ⊆ envelope_75 := by decide +kernel +theorem pivot_mem_75 : (0, 4) ∈ envelope_75 := by decide +kernel +theorem children_work_75 : ∀ j, Template HasSnaky 3 (childrenC_75 j) (childrenD_75 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_20 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_23 6 (1, 5)).mono (by decide +kernel) +theorem row_works_75 : Template HasSnaky 4 required_75 envelope_75 := by + refine compose HasSnaky 3 childrenC_75 childrenD_75 children_work_75 (0, 4) + required_75 envelope_75 pivot_mem_75 child_required_sub_75 child_envelope_sub_75 ?_ + intro b hb + exact common_sub_75 (mem_commonEnvelope childrenD_75 b hb) +def required_79 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_79 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_79 : Fin 2 → Finset Cell := ![(placed21 1 (2, 1) required_8), (placed21 7 (4, 4) required_78)] +def childrenD_79 : Fin 2 → Finset Cell := ![(placed21 1 (2, 1) envelope_8), (placed21 7 (4, 4) envelope_78)] +theorem common_sub_79 : commonEnvelope childrenD_79 ⊆ insert (3, 4) required_79 := by decide +kernel +theorem child_required_sub_79 : ∀ j, childrenC_79 j ⊆ insert (3, 4) required_79 := by decide +kernel +theorem child_envelope_sub_79 : ∀ j, childrenD_79 j ⊆ envelope_79 := by decide +kernel +theorem pivot_mem_79 : (3, 4) ∈ envelope_79 := by decide +kernel +theorem children_work_79 : ∀ j, Template HasSnaky 3 (childrenC_79 j) (childrenD_79 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_78 7 (4, 4)).mono (by decide +kernel) +theorem row_works_79 : Template HasSnaky 4 required_79 envelope_79 := by + refine compose HasSnaky 3 childrenC_79 childrenD_79 children_work_79 (3, 4) + required_79 envelope_79 pivot_mem_79 child_required_sub_79 child_envelope_sub_79 ?_ + intro b hb + exact common_sub_79 (mem_commonEnvelope childrenD_79 b hb) +def required_82 : Finset Cell := ⟨(([(1, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_82 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_82 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) required_52), (placed21 1 (0, 2) required_64)] +def childrenD_82 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) envelope_52), (placed21 1 (0, 2) envelope_64)] +theorem common_sub_82 : commonEnvelope childrenD_82 ⊆ insert (4, 3) required_82 := by decide +kernel +theorem child_required_sub_82 : ∀ j, childrenC_82 j ⊆ insert (4, 3) required_82 := by decide +kernel +theorem child_envelope_sub_82 : ∀ j, childrenD_82 j ⊆ envelope_82 := by decide +kernel +theorem pivot_mem_82 : (4, 3) ∈ envelope_82 := by decide +kernel +theorem children_work_82 : ∀ j, Template HasSnaky 3 (childrenC_82 j) (childrenD_82 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_64 1 (0, 2)).mono (by decide +kernel) +theorem row_works_82 : Template HasSnaky 4 required_82 envelope_82 := by + refine compose HasSnaky 3 childrenC_82 childrenD_82 children_work_82 (4, 3) + required_82 envelope_82 pivot_mem_82 child_required_sub_82 child_envelope_sub_82 ?_ + intro b hb + exact common_sub_82 (mem_commonEnvelope childrenD_82 b hb) +def required_86 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (1, 5), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_86 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_86 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_2), (placed21 7 (4, 4) required_78)] +def childrenD_86 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_2), (placed21 7 (4, 4) envelope_78)] +theorem common_sub_86 : commonEnvelope childrenD_86 ⊆ insert (1, 2) required_86 := by decide +kernel +theorem child_required_sub_86 : ∀ j, childrenC_86 j ⊆ insert (1, 2) required_86 := by decide +kernel +theorem child_envelope_sub_86 : ∀ j, childrenD_86 j ⊆ envelope_86 := by decide +kernel +theorem pivot_mem_86 : (1, 2) ∈ envelope_86 := by decide +kernel +theorem children_work_86 : ∀ j, Template HasSnaky 3 (childrenC_86 j) (childrenD_86 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_78 7 (4, 4)).mono (by decide +kernel) +theorem row_works_86 : Template HasSnaky 4 required_86 envelope_86 := by + refine compose HasSnaky 3 childrenC_86 childrenD_86 children_work_86 (1, 2) + required_86 envelope_86 pivot_mem_86 child_required_sub_86 child_envelope_sub_86 ?_ + intro b hb + exact common_sub_86 (mem_commonEnvelope childrenD_86 b hb) +def required_88 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_88 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_88 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) required_52), (placed21 0 (2, 0) required_53)] +def childrenD_88 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) envelope_52), (placed21 0 (2, 0) envelope_53)] +theorem common_sub_88 : commonEnvelope childrenD_88 ⊆ insert (3, 4) required_88 := by decide +kernel +theorem child_required_sub_88 : ∀ j, childrenC_88 j ⊆ insert (3, 4) required_88 := by decide +kernel +theorem child_envelope_sub_88 : ∀ j, childrenD_88 j ⊆ envelope_88 := by decide +kernel +theorem pivot_mem_88 : (3, 4) ∈ envelope_88 := by decide +kernel +theorem children_work_88 : ∀ j, Template HasSnaky 3 (childrenC_88 j) (childrenD_88 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_53 0 (2, 0)).mono (by decide +kernel) +theorem row_works_88 : Template HasSnaky 4 required_88 envelope_88 := by + refine compose HasSnaky 3 childrenC_88 childrenD_88 children_work_88 (3, 4) + required_88 envelope_88 pivot_mem_88 child_required_sub_88 child_envelope_sub_88 ?_ + intro b hb + exact common_sub_88 (mem_commonEnvelope childrenD_88 b hb) +def required_89 : Finset Cell := ⟨(([(0, 0), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_89 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_89 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_4), (placed21 0 (1, 0) required_7)] +def childrenD_89 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_4), (placed21 0 (1, 0) envelope_7)] +theorem common_sub_89 : commonEnvelope childrenD_89 ⊆ insert (1, 4) required_89 := by decide +kernel +theorem child_required_sub_89 : ∀ j, childrenC_89 j ⊆ insert (1, 4) required_89 := by decide +kernel +theorem child_envelope_sub_89 : ∀ j, childrenD_89 j ⊆ envelope_89 := by decide +kernel +theorem pivot_mem_89 : (1, 4) ∈ envelope_89 := by decide +kernel +theorem children_work_89 : ∀ j, Template HasSnaky 3 (childrenC_89 j) (childrenD_89 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_7 0 (1, 0)).mono (by decide +kernel) +theorem row_works_89 : Template HasSnaky 4 required_89 envelope_89 := by + refine compose HasSnaky 3 childrenC_89 childrenD_89 children_work_89 (1, 4) + required_89 envelope_89 pivot_mem_89 child_required_sub_89 child_envelope_sub_89 ?_ + intro b hb + exact common_sub_89 (mem_commonEnvelope childrenD_89 b hb) +def required_90 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_90 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_90 : Fin 2 → Finset Cell := ![(placed21 3 (0, 1) required_6), (placed21 1 (1, 0) required_37)] +def childrenD_90 : Fin 2 → Finset Cell := ![(placed21 3 (0, 1) envelope_6), (placed21 1 (1, 0) envelope_37)] +theorem common_sub_90 : commonEnvelope childrenD_90 ⊆ insert (4, 1) required_90 := by decide +kernel +theorem child_required_sub_90 : ∀ j, childrenC_90 j ⊆ insert (4, 1) required_90 := by decide +kernel +theorem child_envelope_sub_90 : ∀ j, childrenD_90 j ⊆ envelope_90 := by decide +kernel +theorem pivot_mem_90 : (4, 1) ∈ envelope_90 := by decide +kernel +theorem children_work_90 : ∀ j, Template HasSnaky 3 (childrenC_90 j) (childrenD_90 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_37 1 (1, 0)).mono (by decide +kernel) +theorem row_works_90 : Template HasSnaky 4 required_90 envelope_90 := by + refine compose HasSnaky 3 childrenC_90 childrenD_90 children_work_90 (4, 1) + required_90 envelope_90 pivot_mem_90 child_required_sub_90 child_envelope_sub_90 ?_ + intro b hb + exact common_sub_90 (mem_commonEnvelope childrenD_90 b hb) +def required_91 : Finset Cell := ⟨(([(0, 0), (1, 1), (1, 2), (1, 3), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_91 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_91 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_4), (placed21 0 (1, 1) required_16)] +def childrenD_91 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_4), (placed21 0 (1, 1) envelope_16)] +theorem common_sub_91 : commonEnvelope childrenD_91 ⊆ insert (1, 4) required_91 := by decide +kernel +theorem child_required_sub_91 : ∀ j, childrenC_91 j ⊆ insert (1, 4) required_91 := by decide +kernel +theorem child_envelope_sub_91 : ∀ j, childrenD_91 j ⊆ envelope_91 := by decide +kernel +theorem pivot_mem_91 : (1, 4) ∈ envelope_91 := by decide +kernel +theorem children_work_91 : ∀ j, Template HasSnaky 3 (childrenC_91 j) (childrenD_91 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_16 0 (1, 1)).mono (by decide +kernel) +theorem row_works_91 : Template HasSnaky 4 required_91 envelope_91 := by + refine compose HasSnaky 3 childrenC_91 childrenD_91 children_work_91 (1, 4) + required_91 envelope_91 pivot_mem_91 child_required_sub_91 child_envelope_sub_91 ?_ + intro b hb + exact common_sub_91 (mem_commonEnvelope childrenD_91 b hb) +def required_92 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 3), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_92 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_92 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), required_69] +def childrenD_92 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), envelope_69] +theorem common_sub_92 : commonEnvelope childrenD_92 ⊆ insert (3, 3) required_92 := by decide +kernel +theorem child_required_sub_92 : ∀ j, childrenC_92 j ⊆ insert (3, 3) required_92 := by decide +kernel +theorem child_envelope_sub_92 : ∀ j, childrenD_92 j ⊆ envelope_92 := by decide +kernel +theorem pivot_mem_92 : (3, 3) ∈ envelope_92 := by decide +kernel +theorem children_work_92 : ∀ j, Template HasSnaky 3 (childrenC_92 j) (childrenD_92 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact row_works_69.mono (by decide +kernel) +theorem row_works_92 : Template HasSnaky 4 required_92 envelope_92 := by + refine compose HasSnaky 3 childrenC_92 childrenD_92 children_work_92 (3, 3) + required_92 envelope_92 pivot_mem_92 child_required_sub_92 child_envelope_sub_92 ?_ + intro b hb + exact common_sub_92 (mem_commonEnvelope childrenD_92 b hb) +def required_93 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_93 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_93 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_6), (placed21 3 (1, 1) required_21)] +def childrenD_93 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_6), (placed21 3 (1, 1) envelope_21)] +theorem common_sub_93 : commonEnvelope childrenD_93 ⊆ insert (4, 1) required_93 := by decide +kernel +theorem child_required_sub_93 : ∀ j, childrenC_93 j ⊆ insert (4, 1) required_93 := by decide +kernel +theorem child_envelope_sub_93 : ∀ j, childrenD_93 j ⊆ envelope_93 := by decide +kernel +theorem pivot_mem_93 : (4, 1) ∈ envelope_93 := by decide +kernel +theorem children_work_93 : ∀ j, Template HasSnaky 3 (childrenC_93 j) (childrenD_93 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_21 3 (1, 1)).mono (by decide +kernel) +theorem row_works_93 : Template HasSnaky 4 required_93 envelope_93 := by + refine compose HasSnaky 3 childrenC_93 childrenD_93 children_work_93 (4, 1) + required_93 envelope_93 pivot_mem_93 child_required_sub_93 child_envelope_sub_93 ?_ + intro b hb + exact common_sub_93 (mem_commonEnvelope childrenD_93 b hb) +def required_97 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_97 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_97 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 1 (0, 1) required_24)] +def childrenD_97 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_24)] +theorem common_sub_97 : commonEnvelope childrenD_97 ⊆ insert (1, 2) required_97 := by decide +kernel +theorem child_required_sub_97 : ∀ j, childrenC_97 j ⊆ insert (1, 2) required_97 := by decide +kernel +theorem child_envelope_sub_97 : ∀ j, childrenD_97 j ⊆ envelope_97 := by decide +kernel +theorem pivot_mem_97 : (1, 2) ∈ envelope_97 := by decide +kernel +theorem children_work_97 : ∀ j, Template HasSnaky 3 (childrenC_97 j) (childrenD_97 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_24 1 (0, 1)).mono (by decide +kernel) +theorem row_works_97 : Template HasSnaky 4 required_97 envelope_97 := by + refine compose HasSnaky 3 childrenC_97 childrenD_97 children_work_97 (1, 2) + required_97 envelope_97 pivot_mem_97 child_required_sub_97 child_envelope_sub_97 ?_ + intro b hb + exact common_sub_97 (mem_commonEnvelope childrenD_97 b hb) +def required_98 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 4), (1, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_98 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_98 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_5), (placed21 0 (0, 1) required_16)] +def childrenD_98 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_5), (placed21 0 (0, 1) envelope_16)] +theorem common_sub_98 : commonEnvelope childrenD_98 ⊆ insert (0, 2) required_98 := by decide +kernel +theorem child_required_sub_98 : ∀ j, childrenC_98 j ⊆ insert (0, 2) required_98 := by decide +kernel +theorem child_envelope_sub_98 : ∀ j, childrenD_98 j ⊆ envelope_98 := by decide +kernel +theorem pivot_mem_98 : (0, 2) ∈ envelope_98 := by decide +kernel +theorem children_work_98 : ∀ j, Template HasSnaky 3 (childrenC_98 j) (childrenD_98 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_16 0 (0, 1)).mono (by decide +kernel) +theorem row_works_98 : Template HasSnaky 4 required_98 envelope_98 := by + refine compose HasSnaky 3 childrenC_98 childrenD_98 children_work_98 (0, 2) + required_98 envelope_98 pivot_mem_98 child_required_sub_98 child_envelope_sub_98 ?_ + intro b hb + exact common_sub_98 (mem_commonEnvelope childrenD_98 b hb) +def required_99 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 1), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_99 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_99 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_5), (placed21 2 (3, 0) required_44)] +def childrenD_99 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_5), (placed21 2 (3, 0) envelope_44)] +theorem common_sub_99 : commonEnvelope childrenD_99 ⊆ insert (3, 2) required_99 := by decide +kernel +theorem child_required_sub_99 : ∀ j, childrenC_99 j ⊆ insert (3, 2) required_99 := by decide +kernel +theorem child_envelope_sub_99 : ∀ j, childrenD_99 j ⊆ envelope_99 := by decide +kernel +theorem pivot_mem_99 : (3, 2) ∈ envelope_99 := by decide +kernel +theorem children_work_99 : ∀ j, Template HasSnaky 3 (childrenC_99 j) (childrenD_99 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_44 2 (3, 0)).mono (by decide +kernel) +theorem row_works_99 : Template HasSnaky 4 required_99 envelope_99 := by + refine compose HasSnaky 3 childrenC_99 childrenD_99 children_work_99 (3, 2) + required_99 envelope_99 pivot_mem_99 child_required_sub_99 child_envelope_sub_99 ?_ + intro b hb + exact common_sub_99 (mem_commonEnvelope childrenD_99 b hb) +def required_106 : Finset Cell := ⟨(([(0, 0), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_106 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_106 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_4), (placed21 0 (1, 0) required_7)] +def childrenD_106 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_4), (placed21 0 (1, 0) envelope_7)] +theorem common_sub_106 : commonEnvelope childrenD_106 ⊆ insert (1, 1) required_106 := by decide +kernel +theorem child_required_sub_106 : ∀ j, childrenC_106 j ⊆ insert (1, 1) required_106 := by decide +kernel +theorem child_envelope_sub_106 : ∀ j, childrenD_106 j ⊆ envelope_106 := by decide +kernel +theorem pivot_mem_106 : (1, 1) ∈ envelope_106 := by decide +kernel +theorem children_work_106 : ∀ j, Template HasSnaky 3 (childrenC_106 j) (childrenD_106 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_7 0 (1, 0)).mono (by decide +kernel) +theorem row_works_106 : Template HasSnaky 4 required_106 envelope_106 := by + refine compose HasSnaky 3 childrenC_106 childrenD_106 children_work_106 (1, 1) + required_106 envelope_106 pivot_mem_106 child_required_sub_106 child_envelope_sub_106 ?_ + intro b hb + exact common_sub_106 (mem_commonEnvelope childrenD_106 b hb) +def required_109 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_109 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_109 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_5), (placed21 2 (3, 0) required_44)] +def childrenD_109 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_5), (placed21 2 (3, 0) envelope_44)] +theorem common_sub_109 : commonEnvelope childrenD_109 ⊆ insert (2, 3) required_109 := by decide +kernel +theorem child_required_sub_109 : ∀ j, childrenC_109 j ⊆ insert (2, 3) required_109 := by decide +kernel +theorem child_envelope_sub_109 : ∀ j, childrenD_109 j ⊆ envelope_109 := by decide +kernel +theorem pivot_mem_109 : (2, 3) ∈ envelope_109 := by decide +kernel +theorem children_work_109 : ∀ j, Template HasSnaky 3 (childrenC_109 j) (childrenD_109 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_44 2 (3, 0)).mono (by decide +kernel) +theorem row_works_109 : Template HasSnaky 4 required_109 envelope_109 := by + refine compose HasSnaky 3 childrenC_109 childrenD_109 children_work_109 (2, 3) + required_109 envelope_109 pivot_mem_109 child_required_sub_109 child_envelope_sub_109 ?_ + intro b hb + exact common_sub_109 (mem_commonEnvelope childrenD_109 b hb) +def required_112 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_112 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (4, 2), (4, 3), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_112 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) required_34), (placed21 0 (1, 0) required_44)] +def childrenD_112 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) envelope_34), (placed21 0 (1, 0) envelope_44)] +theorem common_sub_112 : commonEnvelope childrenD_112 ⊆ insert (2, 3) required_112 := by decide +kernel +theorem child_required_sub_112 : ∀ j, childrenC_112 j ⊆ insert (2, 3) required_112 := by decide +kernel +theorem child_envelope_sub_112 : ∀ j, childrenD_112 j ⊆ envelope_112 := by decide +kernel +theorem pivot_mem_112 : (2, 3) ∈ envelope_112 := by decide +kernel +theorem children_work_112 : ∀ j, Template HasSnaky 3 (childrenC_112 j) (childrenD_112 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_34 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_44 0 (1, 0)).mono (by decide +kernel) +theorem row_works_112 : Template HasSnaky 4 required_112 envelope_112 := by + refine compose HasSnaky 3 childrenC_112 childrenD_112 children_work_112 (2, 3) + required_112 envelope_112 pivot_mem_112 child_required_sub_112 child_envelope_sub_112 ?_ + intro b hb + exact common_sub_112 (mem_commonEnvelope childrenD_112 b hb) +def required_125 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_125 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_125 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), required_124] +def childrenD_125 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), envelope_124] +theorem common_sub_125 : commonEnvelope childrenD_125 ⊆ insert (1, 2) required_125 := by decide +kernel +theorem child_required_sub_125 : ∀ j, childrenC_125 j ⊆ insert (1, 2) required_125 := by decide +kernel +theorem child_envelope_sub_125 : ∀ j, childrenD_125 j ⊆ envelope_125 := by decide +kernel +theorem pivot_mem_125 : (1, 2) ∈ envelope_125 := by decide +kernel +theorem children_work_125 : ∀ j, Template HasSnaky 3 (childrenC_125 j) (childrenD_125 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact row_works_124.mono (by decide +kernel) +theorem row_works_125 : Template HasSnaky 4 required_125 envelope_125 := by + refine compose HasSnaky 3 childrenC_125 childrenD_125 children_work_125 (1, 2) + required_125 envelope_125 pivot_mem_125 child_required_sub_125 child_envelope_sub_125 ?_ + intro b hb + exact common_sub_125 (mem_commonEnvelope childrenD_125 b hb) +def required_127 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_127 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_127 : Fin 3 → Finset Cell := ![(placed21 4 (1, 6) required_7), (placed21 1 (0, 2) required_24), (placed21 0 (0, 1) required_124)] +def childrenD_127 : Fin 3 → Finset Cell := ![(placed21 4 (1, 6) envelope_7), (placed21 1 (0, 2) envelope_24), (placed21 0 (0, 1) envelope_124)] +theorem common_sub_127 : commonEnvelope childrenD_127 ⊆ insert (1, 5) required_127 := by decide +kernel +theorem child_required_sub_127 : ∀ j, childrenC_127 j ⊆ insert (1, 5) required_127 := by decide +kernel +theorem child_envelope_sub_127 : ∀ j, childrenD_127 j ⊆ envelope_127 := by decide +kernel +theorem pivot_mem_127 : (1, 5) ∈ envelope_127 := by decide +kernel +theorem children_work_127 : ∀ j, Template HasSnaky 3 (childrenC_127 j) (childrenD_127 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_24 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_124 0 (0, 1)).mono (by decide +kernel) +theorem row_works_127 : Template HasSnaky 4 required_127 envelope_127 := by + refine compose HasSnaky 3 childrenC_127 childrenD_127 children_work_127 (1, 5) + required_127 envelope_127 pivot_mem_127 child_required_sub_127 child_envelope_sub_127 ?_ + intro b hb + exact common_sub_127 (mem_commonEnvelope childrenD_127 b hb) +def required_128 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_128 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_128 : Fin 3 → Finset Cell := ![(placed21 4 (0, 6) required_9), (placed21 2 (1, 2) required_16), (placed21 0 (0, 1) required_124)] +def childrenD_128 : Fin 3 → Finset Cell := ![(placed21 4 (0, 6) envelope_9), (placed21 2 (1, 2) envelope_16), (placed21 0 (0, 1) envelope_124)] +theorem common_sub_128 : commonEnvelope childrenD_128 ⊆ insert (1, 5) required_128 := by decide +kernel +theorem child_required_sub_128 : ∀ j, childrenC_128 j ⊆ insert (1, 5) required_128 := by decide +kernel +theorem child_envelope_sub_128 : ∀ j, childrenD_128 j ⊆ envelope_128 := by decide +kernel +theorem pivot_mem_128 : (1, 5) ∈ envelope_128 := by decide +kernel +theorem children_work_128 : ∀ j, Template HasSnaky 3 (childrenC_128 j) (childrenD_128 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_16 2 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_124 0 (0, 1)).mono (by decide +kernel) +theorem row_works_128 : Template HasSnaky 4 required_128 envelope_128 := by + refine compose HasSnaky 3 childrenC_128 childrenD_128 children_work_128 (1, 5) + required_128 envelope_128 pivot_mem_128 child_required_sub_128 child_envelope_sub_128 ?_ + intro b hb + exact common_sub_128 (mem_commonEnvelope childrenD_128 b hb) +def required_132 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_132 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_132 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_5), (placed21 0 (1, 0) required_131)] +def childrenD_132 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_5), (placed21 0 (1, 0) envelope_131)] +theorem common_sub_132 : commonEnvelope childrenD_132 ⊆ insert (1, 3) required_132 := by decide +kernel +theorem child_required_sub_132 : ∀ j, childrenC_132 j ⊆ insert (1, 3) required_132 := by decide +kernel +theorem child_envelope_sub_132 : ∀ j, childrenD_132 j ⊆ envelope_132 := by decide +kernel +theorem pivot_mem_132 : (1, 3) ∈ envelope_132 := by decide +kernel +theorem children_work_132 : ∀ j, Template HasSnaky 3 (childrenC_132 j) (childrenD_132 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_131 0 (1, 0)).mono (by decide +kernel) +theorem row_works_132 : Template HasSnaky 4 required_132 envelope_132 := by + refine compose HasSnaky 3 childrenC_132 childrenD_132 children_work_132 (1, 3) + required_132 envelope_132 pivot_mem_132 child_required_sub_132 child_envelope_sub_132 ?_ + intro b hb + exact common_sub_132 (mem_commonEnvelope childrenD_132 b hb) +def required_141 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_141 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_141 : Fin 3 → Finset Cell := ![required_53, (placed21 6 (1, 6) required_53), (placed21 1 (0, 2) required_76)] +def childrenD_141 : Fin 3 → Finset Cell := ![envelope_53, (placed21 6 (1, 6) envelope_53), (placed21 1 (0, 2) envelope_76)] +theorem common_sub_141 : commonEnvelope childrenD_141 ⊆ insert (1, 4) required_141 := by decide +kernel +theorem child_required_sub_141 : ∀ j, childrenC_141 j ⊆ insert (1, 4) required_141 := by decide +kernel +theorem child_envelope_sub_141 : ∀ j, childrenD_141 j ⊆ envelope_141 := by decide +kernel +theorem pivot_mem_141 : (1, 4) ∈ envelope_141 := by decide +kernel +theorem children_work_141 : ∀ j, Template HasSnaky 3 (childrenC_141 j) (childrenD_141 j) := by + intro j + fin_cases j + · exact row_works_53.mono (by decide +kernel) + · exact (placed21_template row_works_53 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_76 1 (0, 2)).mono (by decide +kernel) +theorem row_works_141 : Template HasSnaky 4 required_141 envelope_141 := by + refine compose HasSnaky 3 childrenC_141 childrenD_141 children_work_141 (1, 4) + required_141 envelope_141 pivot_mem_141 child_required_sub_141 child_envelope_sub_141 ?_ + intro b hb + exact common_sub_141 (mem_commonEnvelope childrenD_141 b hb) +def required_148 : Finset Cell := ⟨(([(0, 0), (1, 1), (1, 2), (1, 3), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_148 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_148 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_4), (placed21 0 (1, 1) required_21)] +def childrenD_148 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_4), (placed21 0 (1, 1) envelope_21)] +theorem common_sub_148 : commonEnvelope childrenD_148 ⊆ insert (1, 4) required_148 := by decide +kernel +theorem child_required_sub_148 : ∀ j, childrenC_148 j ⊆ insert (1, 4) required_148 := by decide +kernel +theorem child_envelope_sub_148 : ∀ j, childrenD_148 j ⊆ envelope_148 := by decide +kernel +theorem pivot_mem_148 : (1, 4) ∈ envelope_148 := by decide +kernel +theorem children_work_148 : ∀ j, Template HasSnaky 3 (childrenC_148 j) (childrenD_148 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_21 0 (1, 1)).mono (by decide +kernel) +theorem row_works_148 : Template HasSnaky 4 required_148 envelope_148 := by + refine compose HasSnaky 3 childrenC_148 childrenD_148 children_work_148 (1, 4) + required_148 envelope_148 pivot_mem_148 child_required_sub_148 child_envelope_sub_148 ?_ + intro b hb + exact common_sub_148 (mem_commonEnvelope childrenD_148 b hb) +def height_67 : ℕ := 4 +def childrenH_67 : Fin 2 → ℕ := ![height_8, height_32] +theorem height_exact_67 : height_67 = 1 + Finset.univ.sup childrenH_67 := by decide +kernel +theorem required_origin_67 : ∀ x ∈ required_67, + (∃ j, x ∈ childrenC_67 j) ∨ ∀ j, x ∈ childrenD_67 j := by decide +kernel +theorem required_exact_67 : required_67 = + ((Finset.univ.biUnion childrenC_67) ∪ commonEnvelope childrenD_67).erase (1, 1) := by + exact required_eq_combination childrenC_67 childrenD_67 (1, 1) required_67 + (by decide +kernel) child_required_sub_67 common_sub_67 required_origin_67 +theorem envelope_origin_67 : ∀ x ∈ envelope_67, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_67 j := by decide +kernel +theorem envelope_exact_67 : envelope_67 = + insert (1, 1) (Finset.univ.biUnion childrenD_67) := by + exact envelope_eq_combination childrenD_67 (1, 1) envelope_67 + pivot_mem_67 child_envelope_sub_67 envelope_origin_67 +def checked_67 : CheckedCard where + required := required_67 + envelope := envelope_67 + height := height_67 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_67 +def height_73 : ℕ := 4 +def childrenH_73 : Fin 2 → ℕ := ![height_0, height_52] +theorem height_exact_73 : height_73 = 1 + Finset.univ.sup childrenH_73 := by decide +kernel +theorem required_origin_73 : ∀ x ∈ required_73, + (∃ j, x ∈ childrenC_73 j) ∨ ∀ j, x ∈ childrenD_73 j := by decide +kernel +theorem required_exact_73 : required_73 = + ((Finset.univ.biUnion childrenC_73) ∪ commonEnvelope childrenD_73).erase (2, 3) := by + exact required_eq_combination childrenC_73 childrenD_73 (2, 3) required_73 + (by decide +kernel) child_required_sub_73 common_sub_73 required_origin_73 +theorem envelope_origin_73 : ∀ x ∈ envelope_73, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_73 j := by decide +kernel +theorem envelope_exact_73 : envelope_73 = + insert (2, 3) (Finset.univ.biUnion childrenD_73) := by + exact envelope_eq_combination childrenD_73 (2, 3) envelope_73 + pivot_mem_73 child_envelope_sub_73 envelope_origin_73 +def checked_73 : CheckedCard where + required := required_73 + envelope := envelope_73 + height := height_73 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_73 +def height_75 : ℕ := 4 +def childrenH_75 : Fin 2 → ℕ := ![height_20, height_23] +theorem height_exact_75 : height_75 = 1 + Finset.univ.sup childrenH_75 := by decide +kernel +theorem required_origin_75 : ∀ x ∈ required_75, + (∃ j, x ∈ childrenC_75 j) ∨ ∀ j, x ∈ childrenD_75 j := by decide +kernel +theorem required_exact_75 : required_75 = + ((Finset.univ.biUnion childrenC_75) ∪ commonEnvelope childrenD_75).erase (0, 4) := by + exact required_eq_combination childrenC_75 childrenD_75 (0, 4) required_75 + (by decide +kernel) child_required_sub_75 common_sub_75 required_origin_75 +theorem envelope_origin_75 : ∀ x ∈ envelope_75, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_75 j := by decide +kernel +theorem envelope_exact_75 : envelope_75 = + insert (0, 4) (Finset.univ.biUnion childrenD_75) := by + exact envelope_eq_combination childrenD_75 (0, 4) envelope_75 + pivot_mem_75 child_envelope_sub_75 envelope_origin_75 +def checked_75 : CheckedCard where + required := required_75 + envelope := envelope_75 + height := height_75 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_75 +def height_79 : ℕ := 4 +def childrenH_79 : Fin 2 → ℕ := ![height_8, height_78] +theorem height_exact_79 : height_79 = 1 + Finset.univ.sup childrenH_79 := by decide +kernel +theorem required_origin_79 : ∀ x ∈ required_79, + (∃ j, x ∈ childrenC_79 j) ∨ ∀ j, x ∈ childrenD_79 j := by decide +kernel +theorem required_exact_79 : required_79 = + ((Finset.univ.biUnion childrenC_79) ∪ commonEnvelope childrenD_79).erase (3, 4) := by + exact required_eq_combination childrenC_79 childrenD_79 (3, 4) required_79 + (by decide +kernel) child_required_sub_79 common_sub_79 required_origin_79 +theorem envelope_origin_79 : ∀ x ∈ envelope_79, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_79 j := by decide +kernel +theorem envelope_exact_79 : envelope_79 = + insert (3, 4) (Finset.univ.biUnion childrenD_79) := by + exact envelope_eq_combination childrenD_79 (3, 4) envelope_79 + pivot_mem_79 child_envelope_sub_79 envelope_origin_79 +def checked_79 : CheckedCard where + required := required_79 + envelope := envelope_79 + height := height_79 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_79 +def height_82 : ℕ := 4 +def childrenH_82 : Fin 2 → ℕ := ![height_52, height_64] +theorem height_exact_82 : height_82 = 1 + Finset.univ.sup childrenH_82 := by decide +kernel +theorem required_origin_82 : ∀ x ∈ required_82, + (∃ j, x ∈ childrenC_82 j) ∨ ∀ j, x ∈ childrenD_82 j := by decide +kernel +theorem required_exact_82 : required_82 = + ((Finset.univ.biUnion childrenC_82) ∪ commonEnvelope childrenD_82).erase (4, 3) := by + exact required_eq_combination childrenC_82 childrenD_82 (4, 3) required_82 + (by decide +kernel) child_required_sub_82 common_sub_82 required_origin_82 +theorem envelope_origin_82 : ∀ x ∈ envelope_82, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_82 j := by decide +kernel +theorem envelope_exact_82 : envelope_82 = + insert (4, 3) (Finset.univ.biUnion childrenD_82) := by + exact envelope_eq_combination childrenD_82 (4, 3) envelope_82 + pivot_mem_82 child_envelope_sub_82 envelope_origin_82 +def checked_82 : CheckedCard where + required := required_82 + envelope := envelope_82 + height := height_82 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_82 +def height_86 : ℕ := 4 +def childrenH_86 : Fin 2 → ℕ := ![height_2, height_78] +theorem height_exact_86 : height_86 = 1 + Finset.univ.sup childrenH_86 := by decide +kernel +theorem required_origin_86 : ∀ x ∈ required_86, + (∃ j, x ∈ childrenC_86 j) ∨ ∀ j, x ∈ childrenD_86 j := by decide +kernel +theorem required_exact_86 : required_86 = + ((Finset.univ.biUnion childrenC_86) ∪ commonEnvelope childrenD_86).erase (1, 2) := by + exact required_eq_combination childrenC_86 childrenD_86 (1, 2) required_86 + (by decide +kernel) child_required_sub_86 common_sub_86 required_origin_86 +theorem envelope_origin_86 : ∀ x ∈ envelope_86, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_86 j := by decide +kernel +theorem envelope_exact_86 : envelope_86 = + insert (1, 2) (Finset.univ.biUnion childrenD_86) := by + exact envelope_eq_combination childrenD_86 (1, 2) envelope_86 + pivot_mem_86 child_envelope_sub_86 envelope_origin_86 +def checked_86 : CheckedCard where + required := required_86 + envelope := envelope_86 + height := height_86 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_86 +def height_88 : ℕ := 4 +def childrenH_88 : Fin 2 → ℕ := ![height_52, height_53] +theorem height_exact_88 : height_88 = 1 + Finset.univ.sup childrenH_88 := by decide +kernel +theorem required_origin_88 : ∀ x ∈ required_88, + (∃ j, x ∈ childrenC_88 j) ∨ ∀ j, x ∈ childrenD_88 j := by decide +kernel +theorem required_exact_88 : required_88 = + ((Finset.univ.biUnion childrenC_88) ∪ commonEnvelope childrenD_88).erase (3, 4) := by + exact required_eq_combination childrenC_88 childrenD_88 (3, 4) required_88 + (by decide +kernel) child_required_sub_88 common_sub_88 required_origin_88 +theorem envelope_origin_88 : ∀ x ∈ envelope_88, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_88 j := by decide +kernel +theorem envelope_exact_88 : envelope_88 = + insert (3, 4) (Finset.univ.biUnion childrenD_88) := by + exact envelope_eq_combination childrenD_88 (3, 4) envelope_88 + pivot_mem_88 child_envelope_sub_88 envelope_origin_88 +def checked_88 : CheckedCard where + required := required_88 + envelope := envelope_88 + height := height_88 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_88 +def height_89 : ℕ := 4 +def childrenH_89 : Fin 2 → ℕ := ![height_4, height_7] +theorem height_exact_89 : height_89 = 1 + Finset.univ.sup childrenH_89 := by decide +kernel +theorem required_origin_89 : ∀ x ∈ required_89, + (∃ j, x ∈ childrenC_89 j) ∨ ∀ j, x ∈ childrenD_89 j := by decide +kernel +theorem required_exact_89 : required_89 = + ((Finset.univ.biUnion childrenC_89) ∪ commonEnvelope childrenD_89).erase (1, 4) := by + exact required_eq_combination childrenC_89 childrenD_89 (1, 4) required_89 + (by decide +kernel) child_required_sub_89 common_sub_89 required_origin_89 +theorem envelope_origin_89 : ∀ x ∈ envelope_89, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_89 j := by decide +kernel +theorem envelope_exact_89 : envelope_89 = + insert (1, 4) (Finset.univ.biUnion childrenD_89) := by + exact envelope_eq_combination childrenD_89 (1, 4) envelope_89 + pivot_mem_89 child_envelope_sub_89 envelope_origin_89 +def checked_89 : CheckedCard where + required := required_89 + envelope := envelope_89 + height := height_89 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_89 +def height_90 : ℕ := 4 +def childrenH_90 : Fin 2 → ℕ := ![height_6, height_37] +theorem height_exact_90 : height_90 = 1 + Finset.univ.sup childrenH_90 := by decide +kernel +theorem required_origin_90 : ∀ x ∈ required_90, + (∃ j, x ∈ childrenC_90 j) ∨ ∀ j, x ∈ childrenD_90 j := by decide +kernel +theorem required_exact_90 : required_90 = + ((Finset.univ.biUnion childrenC_90) ∪ commonEnvelope childrenD_90).erase (4, 1) := by + exact required_eq_combination childrenC_90 childrenD_90 (4, 1) required_90 + (by decide +kernel) child_required_sub_90 common_sub_90 required_origin_90 +theorem envelope_origin_90 : ∀ x ∈ envelope_90, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_90 j := by decide +kernel +theorem envelope_exact_90 : envelope_90 = + insert (4, 1) (Finset.univ.biUnion childrenD_90) := by + exact envelope_eq_combination childrenD_90 (4, 1) envelope_90 + pivot_mem_90 child_envelope_sub_90 envelope_origin_90 +def checked_90 : CheckedCard where + required := required_90 + envelope := envelope_90 + height := height_90 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_90 +def height_91 : ℕ := 4 +def childrenH_91 : Fin 2 → ℕ := ![height_4, height_16] +theorem height_exact_91 : height_91 = 1 + Finset.univ.sup childrenH_91 := by decide +kernel +theorem required_origin_91 : ∀ x ∈ required_91, + (∃ j, x ∈ childrenC_91 j) ∨ ∀ j, x ∈ childrenD_91 j := by decide +kernel +theorem required_exact_91 : required_91 = + ((Finset.univ.biUnion childrenC_91) ∪ commonEnvelope childrenD_91).erase (1, 4) := by + exact required_eq_combination childrenC_91 childrenD_91 (1, 4) required_91 + (by decide +kernel) child_required_sub_91 common_sub_91 required_origin_91 +theorem envelope_origin_91 : ∀ x ∈ envelope_91, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_91 j := by decide +kernel +theorem envelope_exact_91 : envelope_91 = + insert (1, 4) (Finset.univ.biUnion childrenD_91) := by + exact envelope_eq_combination childrenD_91 (1, 4) envelope_91 + pivot_mem_91 child_envelope_sub_91 envelope_origin_91 +def checked_91 : CheckedCard where + required := required_91 + envelope := envelope_91 + height := height_91 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_91 +def height_92 : ℕ := 4 +def childrenH_92 : Fin 2 → ℕ := ![height_5, height_69] +theorem height_exact_92 : height_92 = 1 + Finset.univ.sup childrenH_92 := by decide +kernel +theorem required_origin_92 : ∀ x ∈ required_92, + (∃ j, x ∈ childrenC_92 j) ∨ ∀ j, x ∈ childrenD_92 j := by decide +kernel +theorem required_exact_92 : required_92 = + ((Finset.univ.biUnion childrenC_92) ∪ commonEnvelope childrenD_92).erase (3, 3) := by + exact required_eq_combination childrenC_92 childrenD_92 (3, 3) required_92 + (by decide +kernel) child_required_sub_92 common_sub_92 required_origin_92 +theorem envelope_origin_92 : ∀ x ∈ envelope_92, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_92 j := by decide +kernel +theorem envelope_exact_92 : envelope_92 = + insert (3, 3) (Finset.univ.biUnion childrenD_92) := by + exact envelope_eq_combination childrenD_92 (3, 3) envelope_92 + pivot_mem_92 child_envelope_sub_92 envelope_origin_92 +def checked_92 : CheckedCard where + required := required_92 + envelope := envelope_92 + height := height_92 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_92 +def height_93 : ℕ := 4 +def childrenH_93 : Fin 2 → ℕ := ![height_6, height_21] +theorem height_exact_93 : height_93 = 1 + Finset.univ.sup childrenH_93 := by decide +kernel +theorem required_origin_93 : ∀ x ∈ required_93, + (∃ j, x ∈ childrenC_93 j) ∨ ∀ j, x ∈ childrenD_93 j := by decide +kernel +theorem required_exact_93 : required_93 = + ((Finset.univ.biUnion childrenC_93) ∪ commonEnvelope childrenD_93).erase (4, 1) := by + exact required_eq_combination childrenC_93 childrenD_93 (4, 1) required_93 + (by decide +kernel) child_required_sub_93 common_sub_93 required_origin_93 +theorem envelope_origin_93 : ∀ x ∈ envelope_93, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_93 j := by decide +kernel +theorem envelope_exact_93 : envelope_93 = + insert (4, 1) (Finset.univ.biUnion childrenD_93) := by + exact envelope_eq_combination childrenD_93 (4, 1) envelope_93 + pivot_mem_93 child_envelope_sub_93 envelope_origin_93 +def checked_93 : CheckedCard where + required := required_93 + envelope := envelope_93 + height := height_93 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_93 +def height_97 : ℕ := 4 +def childrenH_97 : Fin 2 → ℕ := ![height_5, height_24] +theorem height_exact_97 : height_97 = 1 + Finset.univ.sup childrenH_97 := by decide +kernel +theorem required_origin_97 : ∀ x ∈ required_97, + (∃ j, x ∈ childrenC_97 j) ∨ ∀ j, x ∈ childrenD_97 j := by decide +kernel +theorem required_exact_97 : required_97 = + ((Finset.univ.biUnion childrenC_97) ∪ commonEnvelope childrenD_97).erase (1, 2) := by + exact required_eq_combination childrenC_97 childrenD_97 (1, 2) required_97 + (by decide +kernel) child_required_sub_97 common_sub_97 required_origin_97 +theorem envelope_origin_97 : ∀ x ∈ envelope_97, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_97 j := by decide +kernel +theorem envelope_exact_97 : envelope_97 = + insert (1, 2) (Finset.univ.biUnion childrenD_97) := by + exact envelope_eq_combination childrenD_97 (1, 2) envelope_97 + pivot_mem_97 child_envelope_sub_97 envelope_origin_97 +def checked_97 : CheckedCard where + required := required_97 + envelope := envelope_97 + height := height_97 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_97 +def height_98 : ℕ := 4 +def childrenH_98 : Fin 2 → ℕ := ![height_5, height_16] +theorem height_exact_98 : height_98 = 1 + Finset.univ.sup childrenH_98 := by decide +kernel +theorem required_origin_98 : ∀ x ∈ required_98, + (∃ j, x ∈ childrenC_98 j) ∨ ∀ j, x ∈ childrenD_98 j := by decide +kernel +theorem required_exact_98 : required_98 = + ((Finset.univ.biUnion childrenC_98) ∪ commonEnvelope childrenD_98).erase (0, 2) := by + exact required_eq_combination childrenC_98 childrenD_98 (0, 2) required_98 + (by decide +kernel) child_required_sub_98 common_sub_98 required_origin_98 +theorem envelope_origin_98 : ∀ x ∈ envelope_98, + x = (0, 2) ∨ ∃ j, x ∈ childrenD_98 j := by decide +kernel +theorem envelope_exact_98 : envelope_98 = + insert (0, 2) (Finset.univ.biUnion childrenD_98) := by + exact envelope_eq_combination childrenD_98 (0, 2) envelope_98 + pivot_mem_98 child_envelope_sub_98 envelope_origin_98 +def checked_98 : CheckedCard where + required := required_98 + envelope := envelope_98 + height := height_98 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_98 +def height_99 : ℕ := 4 +def childrenH_99 : Fin 2 → ℕ := ![height_5, height_44] +theorem height_exact_99 : height_99 = 1 + Finset.univ.sup childrenH_99 := by decide +kernel +theorem required_origin_99 : ∀ x ∈ required_99, + (∃ j, x ∈ childrenC_99 j) ∨ ∀ j, x ∈ childrenD_99 j := by decide +kernel +theorem required_exact_99 : required_99 = + ((Finset.univ.biUnion childrenC_99) ∪ commonEnvelope childrenD_99).erase (3, 2) := by + exact required_eq_combination childrenC_99 childrenD_99 (3, 2) required_99 + (by decide +kernel) child_required_sub_99 common_sub_99 required_origin_99 +theorem envelope_origin_99 : ∀ x ∈ envelope_99, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_99 j := by decide +kernel +theorem envelope_exact_99 : envelope_99 = + insert (3, 2) (Finset.univ.biUnion childrenD_99) := by + exact envelope_eq_combination childrenD_99 (3, 2) envelope_99 + pivot_mem_99 child_envelope_sub_99 envelope_origin_99 +def checked_99 : CheckedCard where + required := required_99 + envelope := envelope_99 + height := height_99 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_99 +def height_106 : ℕ := 4 +def childrenH_106 : Fin 2 → ℕ := ![height_4, height_7] +theorem height_exact_106 : height_106 = 1 + Finset.univ.sup childrenH_106 := by decide +kernel +theorem required_origin_106 : ∀ x ∈ required_106, + (∃ j, x ∈ childrenC_106 j) ∨ ∀ j, x ∈ childrenD_106 j := by decide +kernel +theorem required_exact_106 : required_106 = + ((Finset.univ.biUnion childrenC_106) ∪ commonEnvelope childrenD_106).erase (1, 1) := by + exact required_eq_combination childrenC_106 childrenD_106 (1, 1) required_106 + (by decide +kernel) child_required_sub_106 common_sub_106 required_origin_106 +theorem envelope_origin_106 : ∀ x ∈ envelope_106, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_106 j := by decide +kernel +theorem envelope_exact_106 : envelope_106 = + insert (1, 1) (Finset.univ.biUnion childrenD_106) := by + exact envelope_eq_combination childrenD_106 (1, 1) envelope_106 + pivot_mem_106 child_envelope_sub_106 envelope_origin_106 +def checked_106 : CheckedCard where + required := required_106 + envelope := envelope_106 + height := height_106 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_106 +def height_109 : ℕ := 4 +def childrenH_109 : Fin 2 → ℕ := ![height_5, height_44] +theorem height_exact_109 : height_109 = 1 + Finset.univ.sup childrenH_109 := by decide +kernel +theorem required_origin_109 : ∀ x ∈ required_109, + (∃ j, x ∈ childrenC_109 j) ∨ ∀ j, x ∈ childrenD_109 j := by decide +kernel +theorem required_exact_109 : required_109 = + ((Finset.univ.biUnion childrenC_109) ∪ commonEnvelope childrenD_109).erase (2, 3) := by + exact required_eq_combination childrenC_109 childrenD_109 (2, 3) required_109 + (by decide +kernel) child_required_sub_109 common_sub_109 required_origin_109 +theorem envelope_origin_109 : ∀ x ∈ envelope_109, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_109 j := by decide +kernel +theorem envelope_exact_109 : envelope_109 = + insert (2, 3) (Finset.univ.biUnion childrenD_109) := by + exact envelope_eq_combination childrenD_109 (2, 3) envelope_109 + pivot_mem_109 child_envelope_sub_109 envelope_origin_109 +def checked_109 : CheckedCard where + required := required_109 + envelope := envelope_109 + height := height_109 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_109 +def height_112 : ℕ := 4 +def childrenH_112 : Fin 2 → ℕ := ![height_34, height_44] +theorem height_exact_112 : height_112 = 1 + Finset.univ.sup childrenH_112 := by decide +kernel +theorem required_origin_112 : ∀ x ∈ required_112, + (∃ j, x ∈ childrenC_112 j) ∨ ∀ j, x ∈ childrenD_112 j := by decide +kernel +theorem required_exact_112 : required_112 = + ((Finset.univ.biUnion childrenC_112) ∪ commonEnvelope childrenD_112).erase (2, 3) := by + exact required_eq_combination childrenC_112 childrenD_112 (2, 3) required_112 + (by decide +kernel) child_required_sub_112 common_sub_112 required_origin_112 +theorem envelope_origin_112 : ∀ x ∈ envelope_112, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_112 j := by decide +kernel +theorem envelope_exact_112 : envelope_112 = + insert (2, 3) (Finset.univ.biUnion childrenD_112) := by + exact envelope_eq_combination childrenD_112 (2, 3) envelope_112 + pivot_mem_112 child_envelope_sub_112 envelope_origin_112 +def checked_112 : CheckedCard where + required := required_112 + envelope := envelope_112 + height := height_112 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_112 +def height_125 : ℕ := 4 +def childrenH_125 : Fin 2 → ℕ := ![height_5, height_124] +theorem height_exact_125 : height_125 = 1 + Finset.univ.sup childrenH_125 := by decide +kernel +theorem required_origin_125 : ∀ x ∈ required_125, + (∃ j, x ∈ childrenC_125 j) ∨ ∀ j, x ∈ childrenD_125 j := by decide +kernel +theorem required_exact_125 : required_125 = + ((Finset.univ.biUnion childrenC_125) ∪ commonEnvelope childrenD_125).erase (1, 2) := by + exact required_eq_combination childrenC_125 childrenD_125 (1, 2) required_125 + (by decide +kernel) child_required_sub_125 common_sub_125 required_origin_125 +theorem envelope_origin_125 : ∀ x ∈ envelope_125, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_125 j := by decide +kernel +theorem envelope_exact_125 : envelope_125 = + insert (1, 2) (Finset.univ.biUnion childrenD_125) := by + exact envelope_eq_combination childrenD_125 (1, 2) envelope_125 + pivot_mem_125 child_envelope_sub_125 envelope_origin_125 +def checked_125 : CheckedCard where + required := required_125 + envelope := envelope_125 + height := height_125 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_125 +def height_127 : ℕ := 4 +def childrenH_127 : Fin 3 → ℕ := ![height_7, height_24, height_124] +theorem height_exact_127 : height_127 = 1 + Finset.univ.sup childrenH_127 := by decide +kernel +theorem required_origin_127 : ∀ x ∈ required_127, + (∃ j, x ∈ childrenC_127 j) ∨ ∀ j, x ∈ childrenD_127 j := by decide +kernel +theorem required_exact_127 : required_127 = + ((Finset.univ.biUnion childrenC_127) ∪ commonEnvelope childrenD_127).erase (1, 5) := by + exact required_eq_combination childrenC_127 childrenD_127 (1, 5) required_127 + (by decide +kernel) child_required_sub_127 common_sub_127 required_origin_127 +theorem envelope_origin_127 : ∀ x ∈ envelope_127, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_127 j := by decide +kernel +theorem envelope_exact_127 : envelope_127 = + insert (1, 5) (Finset.univ.biUnion childrenD_127) := by + exact envelope_eq_combination childrenD_127 (1, 5) envelope_127 + pivot_mem_127 child_envelope_sub_127 envelope_origin_127 +def checked_127 : CheckedCard where + required := required_127 + envelope := envelope_127 + height := height_127 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_127 +def height_128 : ℕ := 4 +def childrenH_128 : Fin 3 → ℕ := ![height_9, height_16, height_124] +theorem height_exact_128 : height_128 = 1 + Finset.univ.sup childrenH_128 := by decide +kernel +theorem required_origin_128 : ∀ x ∈ required_128, + (∃ j, x ∈ childrenC_128 j) ∨ ∀ j, x ∈ childrenD_128 j := by decide +kernel +theorem required_exact_128 : required_128 = + ((Finset.univ.biUnion childrenC_128) ∪ commonEnvelope childrenD_128).erase (1, 5) := by + exact required_eq_combination childrenC_128 childrenD_128 (1, 5) required_128 + (by decide +kernel) child_required_sub_128 common_sub_128 required_origin_128 +theorem envelope_origin_128 : ∀ x ∈ envelope_128, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_128 j := by decide +kernel +theorem envelope_exact_128 : envelope_128 = + insert (1, 5) (Finset.univ.biUnion childrenD_128) := by + exact envelope_eq_combination childrenD_128 (1, 5) envelope_128 + pivot_mem_128 child_envelope_sub_128 envelope_origin_128 +def checked_128 : CheckedCard where + required := required_128 + envelope := envelope_128 + height := height_128 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_128 +def height_132 : ℕ := 4 +def childrenH_132 : Fin 2 → ℕ := ![height_5, height_131] +theorem height_exact_132 : height_132 = 1 + Finset.univ.sup childrenH_132 := by decide +kernel +theorem required_origin_132 : ∀ x ∈ required_132, + (∃ j, x ∈ childrenC_132 j) ∨ ∀ j, x ∈ childrenD_132 j := by decide +kernel +theorem required_exact_132 : required_132 = + ((Finset.univ.biUnion childrenC_132) ∪ commonEnvelope childrenD_132).erase (1, 3) := by + exact required_eq_combination childrenC_132 childrenD_132 (1, 3) required_132 + (by decide +kernel) child_required_sub_132 common_sub_132 required_origin_132 +theorem envelope_origin_132 : ∀ x ∈ envelope_132, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_132 j := by decide +kernel +theorem envelope_exact_132 : envelope_132 = + insert (1, 3) (Finset.univ.biUnion childrenD_132) := by + exact envelope_eq_combination childrenD_132 (1, 3) envelope_132 + pivot_mem_132 child_envelope_sub_132 envelope_origin_132 +def checked_132 : CheckedCard where + required := required_132 + envelope := envelope_132 + height := height_132 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_132 +def height_141 : ℕ := 4 +def childrenH_141 : Fin 3 → ℕ := ![height_53, height_53, height_76] +theorem height_exact_141 : height_141 = 1 + Finset.univ.sup childrenH_141 := by decide +kernel +theorem required_origin_141 : ∀ x ∈ required_141, + (∃ j, x ∈ childrenC_141 j) ∨ ∀ j, x ∈ childrenD_141 j := by decide +kernel +theorem required_exact_141 : required_141 = + ((Finset.univ.biUnion childrenC_141) ∪ commonEnvelope childrenD_141).erase (1, 4) := by + exact required_eq_combination childrenC_141 childrenD_141 (1, 4) required_141 + (by decide +kernel) child_required_sub_141 common_sub_141 required_origin_141 +theorem envelope_origin_141 : ∀ x ∈ envelope_141, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_141 j := by decide +kernel +theorem envelope_exact_141 : envelope_141 = + insert (1, 4) (Finset.univ.biUnion childrenD_141) := by + exact envelope_eq_combination childrenD_141 (1, 4) envelope_141 + pivot_mem_141 child_envelope_sub_141 envelope_origin_141 +def checked_141 : CheckedCard where + required := required_141 + envelope := envelope_141 + height := height_141 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_141 +def height_148 : ℕ := 4 +def childrenH_148 : Fin 2 → ℕ := ![height_4, height_21] +theorem height_exact_148 : height_148 = 1 + Finset.univ.sup childrenH_148 := by decide +kernel +theorem required_origin_148 : ∀ x ∈ required_148, + (∃ j, x ∈ childrenC_148 j) ∨ ∀ j, x ∈ childrenD_148 j := by decide +kernel +theorem required_exact_148 : required_148 = + ((Finset.univ.biUnion childrenC_148) ∪ commonEnvelope childrenD_148).erase (1, 4) := by + exact required_eq_combination childrenC_148 childrenD_148 (1, 4) required_148 + (by decide +kernel) child_required_sub_148 common_sub_148 required_origin_148 +theorem envelope_origin_148 : ∀ x ∈ envelope_148, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_148 j := by decide +kernel +theorem envelope_exact_148 : envelope_148 = + insert (1, 4) (Finset.univ.biUnion childrenD_148) := by + exact envelope_eq_combination childrenD_148 (1, 4) envelope_148 + pivot_mem_148 child_envelope_sub_148 envelope_origin_148 +def checked_148 : CheckedCard where + required := required_148 + envelope := envelope_148 + height := height_148 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_148 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part03.lean new file mode 100644 index 0000000..c104fd4 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part03.lean @@ -0,0 +1,1002 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_149 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_149 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_149 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), required_124] +def childrenD_149 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), envelope_124] +theorem common_sub_149 : commonEnvelope childrenD_149 ⊆ insert (1, 3) required_149 := by decide +kernel +theorem child_required_sub_149 : ∀ j, childrenC_149 j ⊆ insert (1, 3) required_149 := by decide +kernel +theorem child_envelope_sub_149 : ∀ j, childrenD_149 j ⊆ envelope_149 := by decide +kernel +theorem pivot_mem_149 : (1, 3) ∈ envelope_149 := by decide +kernel +theorem children_work_149 : ∀ j, Template HasSnaky 3 (childrenC_149 j) (childrenD_149 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact row_works_124.mono (by decide +kernel) +theorem row_works_149 : Template HasSnaky 4 required_149 envelope_149 := by + refine compose HasSnaky 3 childrenC_149 childrenD_149 children_work_149 (1, 3) + required_149 envelope_149 pivot_mem_149 child_required_sub_149 child_envelope_sub_149 ?_ + intro b hb + exact common_sub_149 (mem_commonEnvelope childrenD_149 b hb) +def required_150 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_150 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_150 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 0 (1, 0) required_7)] +def childrenD_150 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 0 (1, 0) envelope_7)] +theorem common_sub_150 : commonEnvelope childrenD_150 ⊆ insert (1, 2) required_150 := by decide +kernel +theorem child_required_sub_150 : ∀ j, childrenC_150 j ⊆ insert (1, 2) required_150 := by decide +kernel +theorem child_envelope_sub_150 : ∀ j, childrenD_150 j ⊆ envelope_150 := by decide +kernel +theorem pivot_mem_150 : (1, 2) ∈ envelope_150 := by decide +kernel +theorem children_work_150 : ∀ j, Template HasSnaky 3 (childrenC_150 j) (childrenD_150 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_7 0 (1, 0)).mono (by decide +kernel) +theorem row_works_150 : Template HasSnaky 4 required_150 envelope_150 := by + refine compose HasSnaky 3 childrenC_150 childrenD_150 children_work_150 (1, 2) + required_150 envelope_150 pivot_mem_150 child_required_sub_150 child_envelope_sub_150 ?_ + intro b hb + exact common_sub_150 (mem_commonEnvelope childrenD_150 b hb) +def required_151 : Finset Cell := ⟨(([(0, 1), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_151 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_151 : Fin 2 → Finset Cell := ![(placed21 0 (3, 1) required_21), (placed21 7 (4, 4) required_35)] +def childrenD_151 : Fin 2 → Finset Cell := ![(placed21 0 (3, 1) envelope_21), (placed21 7 (4, 4) envelope_35)] +theorem common_sub_151 : commonEnvelope childrenD_151 ⊆ insert (4, 2) required_151 := by decide +kernel +theorem child_required_sub_151 : ∀ j, childrenC_151 j ⊆ insert (4, 2) required_151 := by decide +kernel +theorem child_envelope_sub_151 : ∀ j, childrenD_151 j ⊆ envelope_151 := by decide +kernel +theorem pivot_mem_151 : (4, 2) ∈ envelope_151 := by decide +kernel +theorem children_work_151 : ∀ j, Template HasSnaky 3 (childrenC_151 j) (childrenD_151 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_35 7 (4, 4)).mono (by decide +kernel) +theorem row_works_151 : Template HasSnaky 4 required_151 envelope_151 := by + refine compose HasSnaky 3 childrenC_151 childrenD_151 children_work_151 (4, 2) + required_151 envelope_151 pivot_mem_151 child_required_sub_151 child_envelope_sub_151 ?_ + intro b hb + exact common_sub_151 (mem_commonEnvelope childrenD_151 b hb) +def required_165 : Finset Cell := ⟨(([(1, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_165 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_165 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) required_44), (placed21 1 (0, 2) required_64)] +def childrenD_165 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) envelope_44), (placed21 1 (0, 2) envelope_64)] +theorem common_sub_165 : commonEnvelope childrenD_165 ⊆ insert (4, 3) required_165 := by decide +kernel +theorem child_required_sub_165 : ∀ j, childrenC_165 j ⊆ insert (4, 3) required_165 := by decide +kernel +theorem child_envelope_sub_165 : ∀ j, childrenD_165 j ⊆ envelope_165 := by decide +kernel +theorem pivot_mem_165 : (4, 3) ∈ envelope_165 := by decide +kernel +theorem children_work_165 : ∀ j, Template HasSnaky 3 (childrenC_165 j) (childrenD_165 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_64 1 (0, 2)).mono (by decide +kernel) +theorem row_works_165 : Template HasSnaky 4 required_165 envelope_165 := by + refine compose HasSnaky 3 childrenC_165 childrenD_165 children_work_165 (4, 3) + required_165 envelope_165 pivot_mem_165 child_required_sub_165 child_envelope_sub_165 ?_ + intro b hb + exact common_sub_165 (mem_commonEnvelope childrenD_165 b hb) +def required_168 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_168 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_168 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_5), (placed21 0 (1, 0) required_131)] +def childrenD_168 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_5), (placed21 0 (1, 0) envelope_131)] +theorem common_sub_168 : commonEnvelope childrenD_168 ⊆ insert (2, 2) required_168 := by decide +kernel +theorem child_required_sub_168 : ∀ j, childrenC_168 j ⊆ insert (2, 2) required_168 := by decide +kernel +theorem child_envelope_sub_168 : ∀ j, childrenD_168 j ⊆ envelope_168 := by decide +kernel +theorem pivot_mem_168 : (2, 2) ∈ envelope_168 := by decide +kernel +theorem children_work_168 : ∀ j, Template HasSnaky 3 (childrenC_168 j) (childrenD_168 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_131 0 (1, 0)).mono (by decide +kernel) +theorem row_works_168 : Template HasSnaky 4 required_168 envelope_168 := by + refine compose HasSnaky 3 childrenC_168 childrenD_168 children_work_168 (2, 2) + required_168 envelope_168 pivot_mem_168 child_required_sub_168 child_envelope_sub_168 ?_ + intro b hb + exact common_sub_168 (mem_commonEnvelope childrenD_168 b hb) +def required_178 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_178 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (3, 2), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_178 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_5), (placed21 0 (1, 0) required_177)] +def childrenD_178 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_5), (placed21 0 (1, 0) envelope_177)] +theorem common_sub_178 : commonEnvelope childrenD_178 ⊆ insert (1, 1) required_178 := by decide +kernel +theorem child_required_sub_178 : ∀ j, childrenC_178 j ⊆ insert (1, 1) required_178 := by decide +kernel +theorem child_envelope_sub_178 : ∀ j, childrenD_178 j ⊆ envelope_178 := by decide +kernel +theorem pivot_mem_178 : (1, 1) ∈ envelope_178 := by decide +kernel +theorem children_work_178 : ∀ j, Template HasSnaky 3 (childrenC_178 j) (childrenD_178 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_177 0 (1, 0)).mono (by decide +kernel) +theorem row_works_178 : Template HasSnaky 4 required_178 envelope_178 := by + refine compose HasSnaky 3 childrenC_178 childrenD_178 children_work_178 (1, 1) + required_178 envelope_178 pivot_mem_178 child_required_sub_178 child_envelope_sub_178 ?_ + intro b hb + exact common_sub_178 (mem_commonEnvelope childrenD_178 b hb) +def required_185 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_185 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_185 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_5), required_113] +def childrenD_185 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_5), envelope_113] +theorem common_sub_185 : commonEnvelope childrenD_185 ⊆ insert (1, 4) required_185 := by decide +kernel +theorem child_required_sub_185 : ∀ j, childrenC_185 j ⊆ insert (1, 4) required_185 := by decide +kernel +theorem child_envelope_sub_185 : ∀ j, childrenD_185 j ⊆ envelope_185 := by decide +kernel +theorem pivot_mem_185 : (1, 4) ∈ envelope_185 := by decide +kernel +theorem children_work_185 : ∀ j, Template HasSnaky 3 (childrenC_185 j) (childrenD_185 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (0, 1)).mono (by decide +kernel) + · exact row_works_113.mono (by decide +kernel) +theorem row_works_185 : Template HasSnaky 4 required_185 envelope_185 := by + refine compose HasSnaky 3 childrenC_185 childrenD_185 children_work_185 (1, 4) + required_185 envelope_185 pivot_mem_185 child_required_sub_185 child_envelope_sub_185 ?_ + intro b hb + exact common_sub_185 (mem_commonEnvelope childrenD_185 b hb) +def required_194 : Finset Cell := ⟨(([(0, 0), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_194 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_194 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_4), (placed21 2 (2, 0) required_9)] +def childrenD_194 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_4), (placed21 2 (2, 0) envelope_9)] +theorem common_sub_194 : commonEnvelope childrenD_194 ⊆ insert (1, 4) required_194 := by decide +kernel +theorem child_required_sub_194 : ∀ j, childrenC_194 j ⊆ insert (1, 4) required_194 := by decide +kernel +theorem child_envelope_sub_194 : ∀ j, childrenD_194 j ⊆ envelope_194 := by decide +kernel +theorem pivot_mem_194 : (1, 4) ∈ envelope_194 := by decide +kernel +theorem children_work_194 : ∀ j, Template HasSnaky 3 (childrenC_194 j) (childrenD_194 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (2, 0)).mono (by decide +kernel) +theorem row_works_194 : Template HasSnaky 4 required_194 envelope_194 := by + refine compose HasSnaky 3 childrenC_194 childrenD_194 children_work_194 (1, 4) + required_194 envelope_194 pivot_mem_194 child_required_sub_194 child_envelope_sub_194 ?_ + intro b hb + exact common_sub_194 (mem_commonEnvelope childrenD_194 b hb) +def required_195 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_195 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_195 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 0 (1, 0) required_7)] +def childrenD_195 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 0 (1, 0) envelope_7)] +theorem common_sub_195 : commonEnvelope childrenD_195 ⊆ insert (1, 4) required_195 := by decide +kernel +theorem child_required_sub_195 : ∀ j, childrenC_195 j ⊆ insert (1, 4) required_195 := by decide +kernel +theorem child_envelope_sub_195 : ∀ j, childrenD_195 j ⊆ envelope_195 := by decide +kernel +theorem pivot_mem_195 : (1, 4) ∈ envelope_195 := by decide +kernel +theorem children_work_195 : ∀ j, Template HasSnaky 3 (childrenC_195 j) (childrenD_195 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_7 0 (1, 0)).mono (by decide +kernel) +theorem row_works_195 : Template HasSnaky 4 required_195 envelope_195 := by + refine compose HasSnaky 3 childrenC_195 childrenD_195 children_work_195 (1, 4) + required_195 envelope_195 pivot_mem_195 child_required_sub_195 child_envelope_sub_195 ?_ + intro b hb + exact common_sub_195 (mem_commonEnvelope childrenD_195 b hb) +def required_196 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_196 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1), (4, 0), (4, 1), (4, 2), (5, 1), (5, 2), (6, 1), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_196 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), (placed21 0 (1, 0) required_143)] +def childrenD_196 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), (placed21 0 (1, 0) envelope_143)] +theorem common_sub_196 : commonEnvelope childrenD_196 ⊆ insert (3, 0) required_196 := by decide +kernel +theorem child_required_sub_196 : ∀ j, childrenC_196 j ⊆ insert (3, 0) required_196 := by decide +kernel +theorem child_envelope_sub_196 : ∀ j, childrenD_196 j ⊆ envelope_196 := by decide +kernel +theorem pivot_mem_196 : (3, 0) ∈ envelope_196 := by decide +kernel +theorem children_work_196 : ∀ j, Template HasSnaky 3 (childrenC_196 j) (childrenD_196 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_143 0 (1, 0)).mono (by decide +kernel) +theorem row_works_196 : Template HasSnaky 4 required_196 envelope_196 := by + refine compose HasSnaky 3 childrenC_196 childrenD_196 children_work_196 (3, 0) + required_196 envelope_196 pivot_mem_196 child_required_sub_196 child_envelope_sub_196 ?_ + intro b hb + exact common_sub_196 (mem_commonEnvelope childrenD_196 b hb) +def required_199 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_199 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_199 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) required_0), required_198] +def childrenD_199 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) envelope_0), envelope_198] +theorem common_sub_199 : commonEnvelope childrenD_199 ⊆ insert (1, 1) required_199 := by decide +kernel +theorem child_required_sub_199 : ∀ j, childrenC_199 j ⊆ insert (1, 1) required_199 := by decide +kernel +theorem child_envelope_sub_199 : ∀ j, childrenD_199 j ⊆ envelope_199 := by decide +kernel +theorem pivot_mem_199 : (1, 1) ∈ envelope_199 := by decide +kernel +theorem children_work_199 : ∀ j, Template HasSnaky 3 (childrenC_199 j) (childrenD_199 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 5 (1, 0)).mono (by decide +kernel) + · exact row_works_198.mono (by decide +kernel) +theorem row_works_199 : Template HasSnaky 4 required_199 envelope_199 := by + refine compose HasSnaky 3 childrenC_199 childrenD_199 children_work_199 (1, 1) + required_199 envelope_199 pivot_mem_199 child_required_sub_199 child_envelope_sub_199 ?_ + intro b hb + exact common_sub_199 (mem_commonEnvelope childrenD_199 b hb) +def required_206 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_206 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_206 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) required_0), required_205] +def childrenD_206 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) envelope_0), envelope_205] +theorem common_sub_206 : commonEnvelope childrenD_206 ⊆ insert (1, 1) required_206 := by decide +kernel +theorem child_required_sub_206 : ∀ j, childrenC_206 j ⊆ insert (1, 1) required_206 := by decide +kernel +theorem child_envelope_sub_206 : ∀ j, childrenD_206 j ⊆ envelope_206 := by decide +kernel +theorem pivot_mem_206 : (1, 1) ∈ envelope_206 := by decide +kernel +theorem children_work_206 : ∀ j, Template HasSnaky 3 (childrenC_206 j) (childrenD_206 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 5 (1, 0)).mono (by decide +kernel) + · exact row_works_205.mono (by decide +kernel) +theorem row_works_206 : Template HasSnaky 4 required_206 envelope_206 := by + refine compose HasSnaky 3 childrenC_206 childrenD_206 children_work_206 (1, 1) + required_206 envelope_206 pivot_mem_206 child_required_sub_206 child_envelope_sub_206 ?_ + intro b hb + exact common_sub_206 (mem_commonEnvelope childrenD_206 b hb) +def required_208 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_208 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_208 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_4), (placed21 0 (1, 0) required_207)] +def childrenD_208 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_4), (placed21 0 (1, 0) envelope_207)] +theorem common_sub_208 : commonEnvelope childrenD_208 ⊆ insert (4, 0) required_208 := by decide +kernel +theorem child_required_sub_208 : ∀ j, childrenC_208 j ⊆ insert (4, 0) required_208 := by decide +kernel +theorem child_envelope_sub_208 : ∀ j, childrenD_208 j ⊆ envelope_208 := by decide +kernel +theorem pivot_mem_208 : (4, 0) ∈ envelope_208 := by decide +kernel +theorem children_work_208 : ∀ j, Template HasSnaky 3 (childrenC_208 j) (childrenD_208 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_207 0 (1, 0)).mono (by decide +kernel) +theorem row_works_208 : Template HasSnaky 4 required_208 envelope_208 := by + refine compose HasSnaky 3 childrenC_208 childrenD_208 children_work_208 (4, 0) + required_208 envelope_208 pivot_mem_208 child_required_sub_208 child_envelope_sub_208 ?_ + intro b hb + exact common_sub_208 (mem_commonEnvelope childrenD_208 b hb) +def required_213 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_213 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_213 : Fin 3 → Finset Cell := ![(placed21 2 (2, 0) required_53), (placed21 4 (1, 6) required_53), (placed21 3 (0, 4) required_212)] +def childrenD_213 : Fin 3 → Finset Cell := ![(placed21 2 (2, 0) envelope_53), (placed21 4 (1, 6) envelope_53), (placed21 3 (0, 4) envelope_212)] +theorem common_sub_213 : commonEnvelope childrenD_213 ⊆ insert (1, 4) required_213 := by decide +kernel +theorem child_required_sub_213 : ∀ j, childrenC_213 j ⊆ insert (1, 4) required_213 := by decide +kernel +theorem child_envelope_sub_213 : ∀ j, childrenD_213 j ⊆ envelope_213 := by decide +kernel +theorem pivot_mem_213 : (1, 4) ∈ envelope_213 := by decide +kernel +theorem children_work_213 : ∀ j, Template HasSnaky 3 (childrenC_213 j) (childrenD_213 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 2 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_53 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_212 3 (0, 4)).mono (by decide +kernel) +theorem row_works_213 : Template HasSnaky 4 required_213 envelope_213 := by + refine compose HasSnaky 3 childrenC_213 childrenD_213 children_work_213 (1, 4) + required_213 envelope_213 pivot_mem_213 child_required_sub_213 child_envelope_sub_213 ?_ + intro b hb + exact common_sub_213 (mem_commonEnvelope childrenD_213 b hb) +def required_216 : Finset Cell := ⟨(([(1, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_216 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_216 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) required_52), (placed21 1 (0, 2) required_54)] +def childrenD_216 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) envelope_52), (placed21 1 (0, 2) envelope_54)] +theorem common_sub_216 : commonEnvelope childrenD_216 ⊆ insert (4, 3) required_216 := by decide +kernel +theorem child_required_sub_216 : ∀ j, childrenC_216 j ⊆ insert (4, 3) required_216 := by decide +kernel +theorem child_envelope_sub_216 : ∀ j, childrenD_216 j ⊆ envelope_216 := by decide +kernel +theorem pivot_mem_216 : (4, 3) ∈ envelope_216 := by decide +kernel +theorem children_work_216 : ∀ j, Template HasSnaky 3 (childrenC_216 j) (childrenD_216 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_54 1 (0, 2)).mono (by decide +kernel) +theorem row_works_216 : Template HasSnaky 4 required_216 envelope_216 := by + refine compose HasSnaky 3 childrenC_216 childrenD_216 children_work_216 (4, 3) + required_216 envelope_216 pivot_mem_216 child_required_sub_216 child_envelope_sub_216 ?_ + intro b hb + exact common_sub_216 (mem_commonEnvelope childrenD_216 b hb) +def required_227 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 3), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_227 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_227 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 2 (2, 0) required_53)] +def childrenD_227 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 2 (2, 0) envelope_53)] +theorem common_sub_227 : commonEnvelope childrenD_227 ⊆ insert (1, 4) required_227 := by decide +kernel +theorem child_required_sub_227 : ∀ j, childrenC_227 j ⊆ insert (1, 4) required_227 := by decide +kernel +theorem child_envelope_sub_227 : ∀ j, childrenD_227 j ⊆ envelope_227 := by decide +kernel +theorem pivot_mem_227 : (1, 4) ∈ envelope_227 := by decide +kernel +theorem children_work_227 : ∀ j, Template HasSnaky 3 (childrenC_227 j) (childrenD_227 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_53 2 (2, 0)).mono (by decide +kernel) +theorem row_works_227 : Template HasSnaky 4 required_227 envelope_227 := by + refine compose HasSnaky 3 childrenC_227 childrenD_227 children_work_227 (1, 4) + required_227 envelope_227 pivot_mem_227 child_required_sub_227 child_envelope_sub_227 ?_ + intro b hb + exact common_sub_227 (mem_commonEnvelope childrenD_227 b hb) +def required_229 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_229 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_229 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), required_215] +def childrenD_229 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), envelope_215] +theorem common_sub_229 : commonEnvelope childrenD_229 ⊆ insert (3, 3) required_229 := by decide +kernel +theorem child_required_sub_229 : ∀ j, childrenC_229 j ⊆ insert (3, 3) required_229 := by decide +kernel +theorem child_envelope_sub_229 : ∀ j, childrenD_229 j ⊆ envelope_229 := by decide +kernel +theorem pivot_mem_229 : (3, 3) ∈ envelope_229 := by decide +kernel +theorem children_work_229 : ∀ j, Template HasSnaky 3 (childrenC_229 j) (childrenD_229 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact row_works_215.mono (by decide +kernel) +theorem row_works_229 : Template HasSnaky 4 required_229 envelope_229 := by + refine compose HasSnaky 3 childrenC_229 childrenD_229 children_work_229 (3, 3) + required_229 envelope_229 pivot_mem_229 child_required_sub_229 child_envelope_sub_229 ?_ + intro b hb + exact common_sub_229 (mem_commonEnvelope childrenD_229 b hb) +def required_235 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 4), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_235 : Finset Cell := ⟨(([(0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_235 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 1 (0, 1) required_226)] +def childrenD_235 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_226)] +theorem common_sub_235 : commonEnvelope childrenD_235 ⊆ insert (2, 1) required_235 := by decide +kernel +theorem child_required_sub_235 : ∀ j, childrenC_235 j ⊆ insert (2, 1) required_235 := by decide +kernel +theorem child_envelope_sub_235 : ∀ j, childrenD_235 j ⊆ envelope_235 := by decide +kernel +theorem pivot_mem_235 : (2, 1) ∈ envelope_235 := by decide +kernel +theorem children_work_235 : ∀ j, Template HasSnaky 3 (childrenC_235 j) (childrenD_235 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_226 1 (0, 1)).mono (by decide +kernel) +theorem row_works_235 : Template HasSnaky 4 required_235 envelope_235 := by + refine compose HasSnaky 3 childrenC_235 childrenD_235 children_work_235 (2, 1) + required_235 envelope_235 pivot_mem_235 child_required_sub_235 child_envelope_sub_235 ?_ + intro b hb + exact common_sub_235 (mem_commonEnvelope childrenD_235 b hb) +def required_240 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_240 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_240 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_0), (placed21 2 (3, 0) required_52)] +def childrenD_240 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_0), (placed21 2 (3, 0) envelope_52)] +theorem common_sub_240 : commonEnvelope childrenD_240 ⊆ insert (2, 3) required_240 := by decide +kernel +theorem child_required_sub_240 : ∀ j, childrenC_240 j ⊆ insert (2, 3) required_240 := by decide +kernel +theorem child_envelope_sub_240 : ∀ j, childrenD_240 j ⊆ envelope_240 := by decide +kernel +theorem pivot_mem_240 : (2, 3) ∈ envelope_240 := by decide +kernel +theorem children_work_240 : ∀ j, Template HasSnaky 3 (childrenC_240 j) (childrenD_240 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (3, 0)).mono (by decide +kernel) +theorem row_works_240 : Template HasSnaky 4 required_240 envelope_240 := by + refine compose HasSnaky 3 childrenC_240 childrenD_240 children_work_240 (2, 3) + required_240 envelope_240 pivot_mem_240 child_required_sub_240 child_envelope_sub_240 ?_ + intro b hb + exact common_sub_240 (mem_commonEnvelope childrenD_240 b hb) +def required_242 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 2), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_242 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 2), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_242 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_5), (placed21 0 (1, 0) required_69)] +def childrenD_242 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_5), (placed21 0 (1, 0) envelope_69)] +theorem common_sub_242 : commonEnvelope childrenD_242 ⊆ insert (4, 2) required_242 := by decide +kernel +theorem child_required_sub_242 : ∀ j, childrenC_242 j ⊆ insert (4, 2) required_242 := by decide +kernel +theorem child_envelope_sub_242 : ∀ j, childrenD_242 j ⊆ envelope_242 := by decide +kernel +theorem pivot_mem_242 : (4, 2) ∈ envelope_242 := by decide +kernel +theorem children_work_242 : ∀ j, Template HasSnaky 3 (childrenC_242 j) (childrenD_242 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_69 0 (1, 0)).mono (by decide +kernel) +theorem row_works_242 : Template HasSnaky 4 required_242 envelope_242 := by + refine compose HasSnaky 3 childrenC_242 childrenD_242 children_work_242 (4, 2) + required_242 envelope_242 pivot_mem_242 child_required_sub_242 child_envelope_sub_242 ?_ + intro b hb + exact common_sub_242 (mem_commonEnvelope childrenD_242 b hb) +def required_259 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_259 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_259 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) required_15), (placed21 4 (0, 5) required_159)] +def childrenD_259 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) envelope_15), (placed21 4 (0, 5) envelope_159)] +theorem common_sub_259 : commonEnvelope childrenD_259 ⊆ insert (2, 4) required_259 := by decide +kernel +theorem child_required_sub_259 : ∀ j, childrenC_259 j ⊆ insert (2, 4) required_259 := by decide +kernel +theorem child_envelope_sub_259 : ∀ j, childrenD_259 j ⊆ envelope_259 := by decide +kernel +theorem pivot_mem_259 : (2, 4) ∈ envelope_259 := by decide +kernel +theorem children_work_259 : ∀ j, Template HasSnaky 3 (childrenC_259 j) (childrenD_259 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_159 4 (0, 5)).mono (by decide +kernel) +theorem row_works_259 : Template HasSnaky 4 required_259 envelope_259 := by + refine compose HasSnaky 3 childrenC_259 childrenD_259 children_work_259 (2, 4) + required_259 envelope_259 pivot_mem_259 child_required_sub_259 child_envelope_sub_259 ?_ + intro b hb + exact common_sub_259 (mem_commonEnvelope childrenD_259 b hb) +def required_263 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_263 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_263 : Fin 3 → Finset Cell := ![(placed21 0 (3, 0) required_7), (placed21 2 (4, 0) required_9), (placed21 5 (4, 1) required_78)] +def childrenD_263 : Fin 3 → Finset Cell := ![(placed21 0 (3, 0) envelope_7), (placed21 2 (4, 0) envelope_9), (placed21 5 (4, 1) envelope_78)] +theorem common_sub_263 : commonEnvelope childrenD_263 ⊆ insert (3, 4) required_263 := by decide +kernel +theorem child_required_sub_263 : ∀ j, childrenC_263 j ⊆ insert (3, 4) required_263 := by decide +kernel +theorem child_envelope_sub_263 : ∀ j, childrenD_263 j ⊆ envelope_263 := by decide +kernel +theorem pivot_mem_263 : (3, 4) ∈ envelope_263 := by decide +kernel +theorem children_work_263 : ∀ j, Template HasSnaky 3 (childrenC_263 j) (childrenD_263 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_78 5 (4, 1)).mono (by decide +kernel) +theorem row_works_263 : Template HasSnaky 4 required_263 envelope_263 := by + refine compose HasSnaky 3 childrenC_263 childrenD_263 children_work_263 (3, 4) + required_263 envelope_263 pivot_mem_263 child_required_sub_263 child_envelope_sub_263 ?_ + intro b hb + exact common_sub_263 (mem_commonEnvelope childrenD_263 b hb) +def required_264 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_264 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_264 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_8), (placed21 3 (0, 4) required_201)] +def childrenD_264 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_8), (placed21 3 (0, 4) envelope_201)] +theorem common_sub_264 : commonEnvelope childrenD_264 ⊆ insert (1, 4) required_264 := by decide +kernel +theorem child_required_sub_264 : ∀ j, childrenC_264 j ⊆ insert (1, 4) required_264 := by decide +kernel +theorem child_envelope_sub_264 : ∀ j, childrenD_264 j ⊆ envelope_264 := by decide +kernel +theorem pivot_mem_264 : (1, 4) ∈ envelope_264 := by decide +kernel +theorem children_work_264 : ∀ j, Template HasSnaky 3 (childrenC_264 j) (childrenD_264 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_201 3 (0, 4)).mono (by decide +kernel) +theorem row_works_264 : Template HasSnaky 4 required_264 envelope_264 := by + refine compose HasSnaky 3 childrenC_264 childrenD_264 children_work_264 (1, 4) + required_264 envelope_264 pivot_mem_264 child_required_sub_264 child_envelope_sub_264 ?_ + intro b hb + exact common_sub_264 (mem_commonEnvelope childrenD_264 b hb) +def required_266 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 5), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_266 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_266 : Fin 3 → Finset Cell := ![(placed21 0 (0, 2) required_6), (placed21 0 (0, 3) required_16), (placed21 4 (0, 7) required_113)] +def childrenD_266 : Fin 3 → Finset Cell := ![(placed21 0 (0, 2) envelope_6), (placed21 0 (0, 3) envelope_16), (placed21 4 (0, 7) envelope_113)] +theorem common_sub_266 : commonEnvelope childrenD_266 ⊆ insert (0, 6) required_266 := by decide +kernel +theorem child_required_sub_266 : ∀ j, childrenC_266 j ⊆ insert (0, 6) required_266 := by decide +kernel +theorem child_envelope_sub_266 : ∀ j, childrenD_266 j ⊆ envelope_266 := by decide +kernel +theorem pivot_mem_266 : (0, 6) ∈ envelope_266 := by decide +kernel +theorem children_work_266 : ∀ j, Template HasSnaky 3 (childrenC_266 j) (childrenD_266 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_16 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_113 4 (0, 7)).mono (by decide +kernel) +theorem row_works_266 : Template HasSnaky 4 required_266 envelope_266 := by + refine compose HasSnaky 3 childrenC_266 childrenD_266 children_work_266 (0, 6) + required_266 envelope_266 pivot_mem_266 child_required_sub_266 child_envelope_sub_266 ?_ + intro b hb + exact common_sub_266 (mem_commonEnvelope childrenD_266 b hb) +def height_149 : ℕ := 4 +def childrenH_149 : Fin 2 → ℕ := ![height_5, height_124] +theorem height_exact_149 : height_149 = 1 + Finset.univ.sup childrenH_149 := by decide +kernel +theorem required_origin_149 : ∀ x ∈ required_149, + (∃ j, x ∈ childrenC_149 j) ∨ ∀ j, x ∈ childrenD_149 j := by decide +kernel +theorem required_exact_149 : required_149 = + ((Finset.univ.biUnion childrenC_149) ∪ commonEnvelope childrenD_149).erase (1, 3) := by + exact required_eq_combination childrenC_149 childrenD_149 (1, 3) required_149 + (by decide +kernel) child_required_sub_149 common_sub_149 required_origin_149 +theorem envelope_origin_149 : ∀ x ∈ envelope_149, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_149 j := by decide +kernel +theorem envelope_exact_149 : envelope_149 = + insert (1, 3) (Finset.univ.biUnion childrenD_149) := by + exact envelope_eq_combination childrenD_149 (1, 3) envelope_149 + pivot_mem_149 child_envelope_sub_149 envelope_origin_149 +def checked_149 : CheckedCard where + required := required_149 + envelope := envelope_149 + height := height_149 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_149 +def height_150 : ℕ := 4 +def childrenH_150 : Fin 2 → ℕ := ![height_5, height_7] +theorem height_exact_150 : height_150 = 1 + Finset.univ.sup childrenH_150 := by decide +kernel +theorem required_origin_150 : ∀ x ∈ required_150, + (∃ j, x ∈ childrenC_150 j) ∨ ∀ j, x ∈ childrenD_150 j := by decide +kernel +theorem required_exact_150 : required_150 = + ((Finset.univ.biUnion childrenC_150) ∪ commonEnvelope childrenD_150).erase (1, 2) := by + exact required_eq_combination childrenC_150 childrenD_150 (1, 2) required_150 + (by decide +kernel) child_required_sub_150 common_sub_150 required_origin_150 +theorem envelope_origin_150 : ∀ x ∈ envelope_150, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_150 j := by decide +kernel +theorem envelope_exact_150 : envelope_150 = + insert (1, 2) (Finset.univ.biUnion childrenD_150) := by + exact envelope_eq_combination childrenD_150 (1, 2) envelope_150 + pivot_mem_150 child_envelope_sub_150 envelope_origin_150 +def checked_150 : CheckedCard where + required := required_150 + envelope := envelope_150 + height := height_150 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_150 +def height_151 : ℕ := 4 +def childrenH_151 : Fin 2 → ℕ := ![height_21, height_35] +theorem height_exact_151 : height_151 = 1 + Finset.univ.sup childrenH_151 := by decide +kernel +theorem required_origin_151 : ∀ x ∈ required_151, + (∃ j, x ∈ childrenC_151 j) ∨ ∀ j, x ∈ childrenD_151 j := by decide +kernel +theorem required_exact_151 : required_151 = + ((Finset.univ.biUnion childrenC_151) ∪ commonEnvelope childrenD_151).erase (4, 2) := by + exact required_eq_combination childrenC_151 childrenD_151 (4, 2) required_151 + (by decide +kernel) child_required_sub_151 common_sub_151 required_origin_151 +theorem envelope_origin_151 : ∀ x ∈ envelope_151, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_151 j := by decide +kernel +theorem envelope_exact_151 : envelope_151 = + insert (4, 2) (Finset.univ.biUnion childrenD_151) := by + exact envelope_eq_combination childrenD_151 (4, 2) envelope_151 + pivot_mem_151 child_envelope_sub_151 envelope_origin_151 +def checked_151 : CheckedCard where + required := required_151 + envelope := envelope_151 + height := height_151 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_151 +def height_165 : ℕ := 4 +def childrenH_165 : Fin 2 → ℕ := ![height_44, height_64] +theorem height_exact_165 : height_165 = 1 + Finset.univ.sup childrenH_165 := by decide +kernel +theorem required_origin_165 : ∀ x ∈ required_165, + (∃ j, x ∈ childrenC_165 j) ∨ ∀ j, x ∈ childrenD_165 j := by decide +kernel +theorem required_exact_165 : required_165 = + ((Finset.univ.biUnion childrenC_165) ∪ commonEnvelope childrenD_165).erase (4, 3) := by + exact required_eq_combination childrenC_165 childrenD_165 (4, 3) required_165 + (by decide +kernel) child_required_sub_165 common_sub_165 required_origin_165 +theorem envelope_origin_165 : ∀ x ∈ envelope_165, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_165 j := by decide +kernel +theorem envelope_exact_165 : envelope_165 = + insert (4, 3) (Finset.univ.biUnion childrenD_165) := by + exact envelope_eq_combination childrenD_165 (4, 3) envelope_165 + pivot_mem_165 child_envelope_sub_165 envelope_origin_165 +def checked_165 : CheckedCard where + required := required_165 + envelope := envelope_165 + height := height_165 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_165 +def height_168 : ℕ := 4 +def childrenH_168 : Fin 2 → ℕ := ![height_5, height_131] +theorem height_exact_168 : height_168 = 1 + Finset.univ.sup childrenH_168 := by decide +kernel +theorem required_origin_168 : ∀ x ∈ required_168, + (∃ j, x ∈ childrenC_168 j) ∨ ∀ j, x ∈ childrenD_168 j := by decide +kernel +theorem required_exact_168 : required_168 = + ((Finset.univ.biUnion childrenC_168) ∪ commonEnvelope childrenD_168).erase (2, 2) := by + exact required_eq_combination childrenC_168 childrenD_168 (2, 2) required_168 + (by decide +kernel) child_required_sub_168 common_sub_168 required_origin_168 +theorem envelope_origin_168 : ∀ x ∈ envelope_168, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_168 j := by decide +kernel +theorem envelope_exact_168 : envelope_168 = + insert (2, 2) (Finset.univ.biUnion childrenD_168) := by + exact envelope_eq_combination childrenD_168 (2, 2) envelope_168 + pivot_mem_168 child_envelope_sub_168 envelope_origin_168 +def checked_168 : CheckedCard where + required := required_168 + envelope := envelope_168 + height := height_168 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_168 +def height_178 : ℕ := 4 +def childrenH_178 : Fin 2 → ℕ := ![height_5, height_177] +theorem height_exact_178 : height_178 = 1 + Finset.univ.sup childrenH_178 := by decide +kernel +theorem required_origin_178 : ∀ x ∈ required_178, + (∃ j, x ∈ childrenC_178 j) ∨ ∀ j, x ∈ childrenD_178 j := by decide +kernel +theorem required_exact_178 : required_178 = + ((Finset.univ.biUnion childrenC_178) ∪ commonEnvelope childrenD_178).erase (1, 1) := by + exact required_eq_combination childrenC_178 childrenD_178 (1, 1) required_178 + (by decide +kernel) child_required_sub_178 common_sub_178 required_origin_178 +theorem envelope_origin_178 : ∀ x ∈ envelope_178, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_178 j := by decide +kernel +theorem envelope_exact_178 : envelope_178 = + insert (1, 1) (Finset.univ.biUnion childrenD_178) := by + exact envelope_eq_combination childrenD_178 (1, 1) envelope_178 + pivot_mem_178 child_envelope_sub_178 envelope_origin_178 +def checked_178 : CheckedCard where + required := required_178 + envelope := envelope_178 + height := height_178 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_178 +def height_185 : ℕ := 4 +def childrenH_185 : Fin 2 → ℕ := ![height_5, height_113] +theorem height_exact_185 : height_185 = 1 + Finset.univ.sup childrenH_185 := by decide +kernel +theorem required_origin_185 : ∀ x ∈ required_185, + (∃ j, x ∈ childrenC_185 j) ∨ ∀ j, x ∈ childrenD_185 j := by decide +kernel +theorem required_exact_185 : required_185 = + ((Finset.univ.biUnion childrenC_185) ∪ commonEnvelope childrenD_185).erase (1, 4) := by + exact required_eq_combination childrenC_185 childrenD_185 (1, 4) required_185 + (by decide +kernel) child_required_sub_185 common_sub_185 required_origin_185 +theorem envelope_origin_185 : ∀ x ∈ envelope_185, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_185 j := by decide +kernel +theorem envelope_exact_185 : envelope_185 = + insert (1, 4) (Finset.univ.biUnion childrenD_185) := by + exact envelope_eq_combination childrenD_185 (1, 4) envelope_185 + pivot_mem_185 child_envelope_sub_185 envelope_origin_185 +def checked_185 : CheckedCard where + required := required_185 + envelope := envelope_185 + height := height_185 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_185 +def height_194 : ℕ := 4 +def childrenH_194 : Fin 2 → ℕ := ![height_4, height_9] +theorem height_exact_194 : height_194 = 1 + Finset.univ.sup childrenH_194 := by decide +kernel +theorem required_origin_194 : ∀ x ∈ required_194, + (∃ j, x ∈ childrenC_194 j) ∨ ∀ j, x ∈ childrenD_194 j := by decide +kernel +theorem required_exact_194 : required_194 = + ((Finset.univ.biUnion childrenC_194) ∪ commonEnvelope childrenD_194).erase (1, 4) := by + exact required_eq_combination childrenC_194 childrenD_194 (1, 4) required_194 + (by decide +kernel) child_required_sub_194 common_sub_194 required_origin_194 +theorem envelope_origin_194 : ∀ x ∈ envelope_194, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_194 j := by decide +kernel +theorem envelope_exact_194 : envelope_194 = + insert (1, 4) (Finset.univ.biUnion childrenD_194) := by + exact envelope_eq_combination childrenD_194 (1, 4) envelope_194 + pivot_mem_194 child_envelope_sub_194 envelope_origin_194 +def checked_194 : CheckedCard where + required := required_194 + envelope := envelope_194 + height := height_194 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_194 +def height_195 : ℕ := 4 +def childrenH_195 : Fin 2 → ℕ := ![height_5, height_7] +theorem height_exact_195 : height_195 = 1 + Finset.univ.sup childrenH_195 := by decide +kernel +theorem required_origin_195 : ∀ x ∈ required_195, + (∃ j, x ∈ childrenC_195 j) ∨ ∀ j, x ∈ childrenD_195 j := by decide +kernel +theorem required_exact_195 : required_195 = + ((Finset.univ.biUnion childrenC_195) ∪ commonEnvelope childrenD_195).erase (1, 4) := by + exact required_eq_combination childrenC_195 childrenD_195 (1, 4) required_195 + (by decide +kernel) child_required_sub_195 common_sub_195 required_origin_195 +theorem envelope_origin_195 : ∀ x ∈ envelope_195, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_195 j := by decide +kernel +theorem envelope_exact_195 : envelope_195 = + insert (1, 4) (Finset.univ.biUnion childrenD_195) := by + exact envelope_eq_combination childrenD_195 (1, 4) envelope_195 + pivot_mem_195 child_envelope_sub_195 envelope_origin_195 +def checked_195 : CheckedCard where + required := required_195 + envelope := envelope_195 + height := height_195 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_195 +def height_196 : ℕ := 4 +def childrenH_196 : Fin 2 → ℕ := ![height_5, height_143] +theorem height_exact_196 : height_196 = 1 + Finset.univ.sup childrenH_196 := by decide +kernel +theorem required_origin_196 : ∀ x ∈ required_196, + (∃ j, x ∈ childrenC_196 j) ∨ ∀ j, x ∈ childrenD_196 j := by decide +kernel +theorem required_exact_196 : required_196 = + ((Finset.univ.biUnion childrenC_196) ∪ commonEnvelope childrenD_196).erase (3, 0) := by + exact required_eq_combination childrenC_196 childrenD_196 (3, 0) required_196 + (by decide +kernel) child_required_sub_196 common_sub_196 required_origin_196 +theorem envelope_origin_196 : ∀ x ∈ envelope_196, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_196 j := by decide +kernel +theorem envelope_exact_196 : envelope_196 = + insert (3, 0) (Finset.univ.biUnion childrenD_196) := by + exact envelope_eq_combination childrenD_196 (3, 0) envelope_196 + pivot_mem_196 child_envelope_sub_196 envelope_origin_196 +def checked_196 : CheckedCard where + required := required_196 + envelope := envelope_196 + height := height_196 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_196 +def height_199 : ℕ := 4 +def childrenH_199 : Fin 2 → ℕ := ![height_0, height_198] +theorem height_exact_199 : height_199 = 1 + Finset.univ.sup childrenH_199 := by decide +kernel +theorem required_origin_199 : ∀ x ∈ required_199, + (∃ j, x ∈ childrenC_199 j) ∨ ∀ j, x ∈ childrenD_199 j := by decide +kernel +theorem required_exact_199 : required_199 = + ((Finset.univ.biUnion childrenC_199) ∪ commonEnvelope childrenD_199).erase (1, 1) := by + exact required_eq_combination childrenC_199 childrenD_199 (1, 1) required_199 + (by decide +kernel) child_required_sub_199 common_sub_199 required_origin_199 +theorem envelope_origin_199 : ∀ x ∈ envelope_199, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_199 j := by decide +kernel +theorem envelope_exact_199 : envelope_199 = + insert (1, 1) (Finset.univ.biUnion childrenD_199) := by + exact envelope_eq_combination childrenD_199 (1, 1) envelope_199 + pivot_mem_199 child_envelope_sub_199 envelope_origin_199 +def checked_199 : CheckedCard where + required := required_199 + envelope := envelope_199 + height := height_199 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_199 +def height_206 : ℕ := 4 +def childrenH_206 : Fin 2 → ℕ := ![height_0, height_205] +theorem height_exact_206 : height_206 = 1 + Finset.univ.sup childrenH_206 := by decide +kernel +theorem required_origin_206 : ∀ x ∈ required_206, + (∃ j, x ∈ childrenC_206 j) ∨ ∀ j, x ∈ childrenD_206 j := by decide +kernel +theorem required_exact_206 : required_206 = + ((Finset.univ.biUnion childrenC_206) ∪ commonEnvelope childrenD_206).erase (1, 1) := by + exact required_eq_combination childrenC_206 childrenD_206 (1, 1) required_206 + (by decide +kernel) child_required_sub_206 common_sub_206 required_origin_206 +theorem envelope_origin_206 : ∀ x ∈ envelope_206, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_206 j := by decide +kernel +theorem envelope_exact_206 : envelope_206 = + insert (1, 1) (Finset.univ.biUnion childrenD_206) := by + exact envelope_eq_combination childrenD_206 (1, 1) envelope_206 + pivot_mem_206 child_envelope_sub_206 envelope_origin_206 +def checked_206 : CheckedCard where + required := required_206 + envelope := envelope_206 + height := height_206 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_206 +def height_208 : ℕ := 4 +def childrenH_208 : Fin 2 → ℕ := ![height_4, height_207] +theorem height_exact_208 : height_208 = 1 + Finset.univ.sup childrenH_208 := by decide +kernel +theorem required_origin_208 : ∀ x ∈ required_208, + (∃ j, x ∈ childrenC_208 j) ∨ ∀ j, x ∈ childrenD_208 j := by decide +kernel +theorem required_exact_208 : required_208 = + ((Finset.univ.biUnion childrenC_208) ∪ commonEnvelope childrenD_208).erase (4, 0) := by + exact required_eq_combination childrenC_208 childrenD_208 (4, 0) required_208 + (by decide +kernel) child_required_sub_208 common_sub_208 required_origin_208 +theorem envelope_origin_208 : ∀ x ∈ envelope_208, + x = (4, 0) ∨ ∃ j, x ∈ childrenD_208 j := by decide +kernel +theorem envelope_exact_208 : envelope_208 = + insert (4, 0) (Finset.univ.biUnion childrenD_208) := by + exact envelope_eq_combination childrenD_208 (4, 0) envelope_208 + pivot_mem_208 child_envelope_sub_208 envelope_origin_208 +def checked_208 : CheckedCard where + required := required_208 + envelope := envelope_208 + height := height_208 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_208 +def height_213 : ℕ := 4 +def childrenH_213 : Fin 3 → ℕ := ![height_53, height_53, height_212] +theorem height_exact_213 : height_213 = 1 + Finset.univ.sup childrenH_213 := by decide +kernel +theorem required_origin_213 : ∀ x ∈ required_213, + (∃ j, x ∈ childrenC_213 j) ∨ ∀ j, x ∈ childrenD_213 j := by decide +kernel +theorem required_exact_213 : required_213 = + ((Finset.univ.biUnion childrenC_213) ∪ commonEnvelope childrenD_213).erase (1, 4) := by + exact required_eq_combination childrenC_213 childrenD_213 (1, 4) required_213 + (by decide +kernel) child_required_sub_213 common_sub_213 required_origin_213 +theorem envelope_origin_213 : ∀ x ∈ envelope_213, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_213 j := by decide +kernel +theorem envelope_exact_213 : envelope_213 = + insert (1, 4) (Finset.univ.biUnion childrenD_213) := by + exact envelope_eq_combination childrenD_213 (1, 4) envelope_213 + pivot_mem_213 child_envelope_sub_213 envelope_origin_213 +def checked_213 : CheckedCard where + required := required_213 + envelope := envelope_213 + height := height_213 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_213 +def height_216 : ℕ := 4 +def childrenH_216 : Fin 2 → ℕ := ![height_52, height_54] +theorem height_exact_216 : height_216 = 1 + Finset.univ.sup childrenH_216 := by decide +kernel +theorem required_origin_216 : ∀ x ∈ required_216, + (∃ j, x ∈ childrenC_216 j) ∨ ∀ j, x ∈ childrenD_216 j := by decide +kernel +theorem required_exact_216 : required_216 = + ((Finset.univ.biUnion childrenC_216) ∪ commonEnvelope childrenD_216).erase (4, 3) := by + exact required_eq_combination childrenC_216 childrenD_216 (4, 3) required_216 + (by decide +kernel) child_required_sub_216 common_sub_216 required_origin_216 +theorem envelope_origin_216 : ∀ x ∈ envelope_216, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_216 j := by decide +kernel +theorem envelope_exact_216 : envelope_216 = + insert (4, 3) (Finset.univ.biUnion childrenD_216) := by + exact envelope_eq_combination childrenD_216 (4, 3) envelope_216 + pivot_mem_216 child_envelope_sub_216 envelope_origin_216 +def checked_216 : CheckedCard where + required := required_216 + envelope := envelope_216 + height := height_216 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_216 +def height_227 : ℕ := 4 +def childrenH_227 : Fin 2 → ℕ := ![height_0, height_53] +theorem height_exact_227 : height_227 = 1 + Finset.univ.sup childrenH_227 := by decide +kernel +theorem required_origin_227 : ∀ x ∈ required_227, + (∃ j, x ∈ childrenC_227 j) ∨ ∀ j, x ∈ childrenD_227 j := by decide +kernel +theorem required_exact_227 : required_227 = + ((Finset.univ.biUnion childrenC_227) ∪ commonEnvelope childrenD_227).erase (1, 4) := by + exact required_eq_combination childrenC_227 childrenD_227 (1, 4) required_227 + (by decide +kernel) child_required_sub_227 common_sub_227 required_origin_227 +theorem envelope_origin_227 : ∀ x ∈ envelope_227, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_227 j := by decide +kernel +theorem envelope_exact_227 : envelope_227 = + insert (1, 4) (Finset.univ.biUnion childrenD_227) := by + exact envelope_eq_combination childrenD_227 (1, 4) envelope_227 + pivot_mem_227 child_envelope_sub_227 envelope_origin_227 +def checked_227 : CheckedCard where + required := required_227 + envelope := envelope_227 + height := height_227 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_227 +def height_229 : ℕ := 4 +def childrenH_229 : Fin 2 → ℕ := ![height_5, height_215] +theorem height_exact_229 : height_229 = 1 + Finset.univ.sup childrenH_229 := by decide +kernel +theorem required_origin_229 : ∀ x ∈ required_229, + (∃ j, x ∈ childrenC_229 j) ∨ ∀ j, x ∈ childrenD_229 j := by decide +kernel +theorem required_exact_229 : required_229 = + ((Finset.univ.biUnion childrenC_229) ∪ commonEnvelope childrenD_229).erase (3, 3) := by + exact required_eq_combination childrenC_229 childrenD_229 (3, 3) required_229 + (by decide +kernel) child_required_sub_229 common_sub_229 required_origin_229 +theorem envelope_origin_229 : ∀ x ∈ envelope_229, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_229 j := by decide +kernel +theorem envelope_exact_229 : envelope_229 = + insert (3, 3) (Finset.univ.biUnion childrenD_229) := by + exact envelope_eq_combination childrenD_229 (3, 3) envelope_229 + pivot_mem_229 child_envelope_sub_229 envelope_origin_229 +def checked_229 : CheckedCard where + required := required_229 + envelope := envelope_229 + height := height_229 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_229 +def height_235 : ℕ := 4 +def childrenH_235 : Fin 2 → ℕ := ![height_5, height_226] +theorem height_exact_235 : height_235 = 1 + Finset.univ.sup childrenH_235 := by decide +kernel +theorem required_origin_235 : ∀ x ∈ required_235, + (∃ j, x ∈ childrenC_235 j) ∨ ∀ j, x ∈ childrenD_235 j := by decide +kernel +theorem required_exact_235 : required_235 = + ((Finset.univ.biUnion childrenC_235) ∪ commonEnvelope childrenD_235).erase (2, 1) := by + exact required_eq_combination childrenC_235 childrenD_235 (2, 1) required_235 + (by decide +kernel) child_required_sub_235 common_sub_235 required_origin_235 +theorem envelope_origin_235 : ∀ x ∈ envelope_235, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_235 j := by decide +kernel +theorem envelope_exact_235 : envelope_235 = + insert (2, 1) (Finset.univ.biUnion childrenD_235) := by + exact envelope_eq_combination childrenD_235 (2, 1) envelope_235 + pivot_mem_235 child_envelope_sub_235 envelope_origin_235 +def checked_235 : CheckedCard where + required := required_235 + envelope := envelope_235 + height := height_235 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_235 +def height_240 : ℕ := 4 +def childrenH_240 : Fin 2 → ℕ := ![height_0, height_52] +theorem height_exact_240 : height_240 = 1 + Finset.univ.sup childrenH_240 := by decide +kernel +theorem required_origin_240 : ∀ x ∈ required_240, + (∃ j, x ∈ childrenC_240 j) ∨ ∀ j, x ∈ childrenD_240 j := by decide +kernel +theorem required_exact_240 : required_240 = + ((Finset.univ.biUnion childrenC_240) ∪ commonEnvelope childrenD_240).erase (2, 3) := by + exact required_eq_combination childrenC_240 childrenD_240 (2, 3) required_240 + (by decide +kernel) child_required_sub_240 common_sub_240 required_origin_240 +theorem envelope_origin_240 : ∀ x ∈ envelope_240, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_240 j := by decide +kernel +theorem envelope_exact_240 : envelope_240 = + insert (2, 3) (Finset.univ.biUnion childrenD_240) := by + exact envelope_eq_combination childrenD_240 (2, 3) envelope_240 + pivot_mem_240 child_envelope_sub_240 envelope_origin_240 +def checked_240 : CheckedCard where + required := required_240 + envelope := envelope_240 + height := height_240 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_240 +def height_242 : ℕ := 4 +def childrenH_242 : Fin 2 → ℕ := ![height_5, height_69] +theorem height_exact_242 : height_242 = 1 + Finset.univ.sup childrenH_242 := by decide +kernel +theorem required_origin_242 : ∀ x ∈ required_242, + (∃ j, x ∈ childrenC_242 j) ∨ ∀ j, x ∈ childrenD_242 j := by decide +kernel +theorem required_exact_242 : required_242 = + ((Finset.univ.biUnion childrenC_242) ∪ commonEnvelope childrenD_242).erase (4, 2) := by + exact required_eq_combination childrenC_242 childrenD_242 (4, 2) required_242 + (by decide +kernel) child_required_sub_242 common_sub_242 required_origin_242 +theorem envelope_origin_242 : ∀ x ∈ envelope_242, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_242 j := by decide +kernel +theorem envelope_exact_242 : envelope_242 = + insert (4, 2) (Finset.univ.biUnion childrenD_242) := by + exact envelope_eq_combination childrenD_242 (4, 2) envelope_242 + pivot_mem_242 child_envelope_sub_242 envelope_origin_242 +def checked_242 : CheckedCard where + required := required_242 + envelope := envelope_242 + height := height_242 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_242 +def height_259 : ℕ := 4 +def childrenH_259 : Fin 2 → ℕ := ![height_15, height_159] +theorem height_exact_259 : height_259 = 1 + Finset.univ.sup childrenH_259 := by decide +kernel +theorem required_origin_259 : ∀ x ∈ required_259, + (∃ j, x ∈ childrenC_259 j) ∨ ∀ j, x ∈ childrenD_259 j := by decide +kernel +theorem required_exact_259 : required_259 = + ((Finset.univ.biUnion childrenC_259) ∪ commonEnvelope childrenD_259).erase (2, 4) := by + exact required_eq_combination childrenC_259 childrenD_259 (2, 4) required_259 + (by decide +kernel) child_required_sub_259 common_sub_259 required_origin_259 +theorem envelope_origin_259 : ∀ x ∈ envelope_259, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_259 j := by decide +kernel +theorem envelope_exact_259 : envelope_259 = + insert (2, 4) (Finset.univ.biUnion childrenD_259) := by + exact envelope_eq_combination childrenD_259 (2, 4) envelope_259 + pivot_mem_259 child_envelope_sub_259 envelope_origin_259 +def checked_259 : CheckedCard where + required := required_259 + envelope := envelope_259 + height := height_259 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_259 +def height_263 : ℕ := 4 +def childrenH_263 : Fin 3 → ℕ := ![height_7, height_9, height_78] +theorem height_exact_263 : height_263 = 1 + Finset.univ.sup childrenH_263 := by decide +kernel +theorem required_origin_263 : ∀ x ∈ required_263, + (∃ j, x ∈ childrenC_263 j) ∨ ∀ j, x ∈ childrenD_263 j := by decide +kernel +theorem required_exact_263 : required_263 = + ((Finset.univ.biUnion childrenC_263) ∪ commonEnvelope childrenD_263).erase (3, 4) := by + exact required_eq_combination childrenC_263 childrenD_263 (3, 4) required_263 + (by decide +kernel) child_required_sub_263 common_sub_263 required_origin_263 +theorem envelope_origin_263 : ∀ x ∈ envelope_263, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_263 j := by decide +kernel +theorem envelope_exact_263 : envelope_263 = + insert (3, 4) (Finset.univ.biUnion childrenD_263) := by + exact envelope_eq_combination childrenD_263 (3, 4) envelope_263 + pivot_mem_263 child_envelope_sub_263 envelope_origin_263 +def checked_263 : CheckedCard where + required := required_263 + envelope := envelope_263 + height := height_263 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_263 +def height_264 : ℕ := 4 +def childrenH_264 : Fin 2 → ℕ := ![height_8, height_201] +theorem height_exact_264 : height_264 = 1 + Finset.univ.sup childrenH_264 := by decide +kernel +theorem required_origin_264 : ∀ x ∈ required_264, + (∃ j, x ∈ childrenC_264 j) ∨ ∀ j, x ∈ childrenD_264 j := by decide +kernel +theorem required_exact_264 : required_264 = + ((Finset.univ.biUnion childrenC_264) ∪ commonEnvelope childrenD_264).erase (1, 4) := by + exact required_eq_combination childrenC_264 childrenD_264 (1, 4) required_264 + (by decide +kernel) child_required_sub_264 common_sub_264 required_origin_264 +theorem envelope_origin_264 : ∀ x ∈ envelope_264, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_264 j := by decide +kernel +theorem envelope_exact_264 : envelope_264 = + insert (1, 4) (Finset.univ.biUnion childrenD_264) := by + exact envelope_eq_combination childrenD_264 (1, 4) envelope_264 + pivot_mem_264 child_envelope_sub_264 envelope_origin_264 +def checked_264 : CheckedCard where + required := required_264 + envelope := envelope_264 + height := height_264 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_264 +def height_266 : ℕ := 4 +def childrenH_266 : Fin 3 → ℕ := ![height_6, height_16, height_113] +theorem height_exact_266 : height_266 = 1 + Finset.univ.sup childrenH_266 := by decide +kernel +theorem required_origin_266 : ∀ x ∈ required_266, + (∃ j, x ∈ childrenC_266 j) ∨ ∀ j, x ∈ childrenD_266 j := by decide +kernel +theorem required_exact_266 : required_266 = + ((Finset.univ.biUnion childrenC_266) ∪ commonEnvelope childrenD_266).erase (0, 6) := by + exact required_eq_combination childrenC_266 childrenD_266 (0, 6) required_266 + (by decide +kernel) child_required_sub_266 common_sub_266 required_origin_266 +theorem envelope_origin_266 : ∀ x ∈ envelope_266, + x = (0, 6) ∨ ∃ j, x ∈ childrenD_266 j := by decide +kernel +theorem envelope_exact_266 : envelope_266 = + insert (0, 6) (Finset.univ.biUnion childrenD_266) := by + exact envelope_eq_combination childrenD_266 (0, 6) envelope_266 + pivot_mem_266 child_envelope_sub_266 envelope_origin_266 +def checked_266 : CheckedCard where + required := required_266 + envelope := envelope_266 + height := height_266 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_266 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part04.lean new file mode 100644 index 0000000..4f03c9c --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part04.lean @@ -0,0 +1,922 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_268 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_268 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_268 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) required_7), (placed21 1 (0, 2) required_8), (placed21 6 (2, 6) required_9)] +def childrenD_268 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) envelope_7), (placed21 1 (0, 2) envelope_8), (placed21 6 (2, 6) envelope_9)] +theorem common_sub_268 : commonEnvelope childrenD_268 ⊆ insert (1, 4) required_268 := by decide +kernel +theorem child_required_sub_268 : ∀ j, childrenC_268 j ⊆ insert (1, 4) required_268 := by decide +kernel +theorem child_envelope_sub_268 : ∀ j, childrenD_268 j ⊆ envelope_268 := by decide +kernel +theorem pivot_mem_268 : (1, 4) ∈ envelope_268 := by decide +kernel +theorem children_work_268 : ∀ j, Template HasSnaky 3 (childrenC_268 j) (childrenD_268 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 6 (2, 6)).mono (by decide +kernel) +theorem row_works_268 : Template HasSnaky 4 required_268 envelope_268 := by + refine compose HasSnaky 3 childrenC_268 childrenD_268 children_work_268 (1, 4) + required_268 envelope_268 pivot_mem_268 child_required_sub_268 child_envelope_sub_268 ?_ + intro b hb + exact common_sub_268 (mem_commonEnvelope childrenD_268 b hb) +def required_269 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_269 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_269 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) required_7), (placed21 2 (1, 2) required_21)] +def childrenD_269 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) envelope_7), (placed21 2 (1, 2) envelope_21)] +theorem common_sub_269 : commonEnvelope childrenD_269 ⊆ insert (1, 5) required_269 := by decide +kernel +theorem child_required_sub_269 : ∀ j, childrenC_269 j ⊆ insert (1, 5) required_269 := by decide +kernel +theorem child_envelope_sub_269 : ∀ j, childrenD_269 j ⊆ envelope_269 := by decide +kernel +theorem pivot_mem_269 : (1, 5) ∈ envelope_269 := by decide +kernel +theorem children_work_269 : ∀ j, Template HasSnaky 3 (childrenC_269 j) (childrenD_269 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_21 2 (1, 2)).mono (by decide +kernel) +theorem row_works_269 : Template HasSnaky 4 required_269 envelope_269 := by + refine compose HasSnaky 3 childrenC_269 childrenD_269 children_work_269 (1, 5) + required_269 envelope_269 pivot_mem_269 child_required_sub_269 child_envelope_sub_269 ?_ + intro b hb + exact common_sub_269 (mem_commonEnvelope childrenD_269 b hb) +def required_271 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_271 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_271 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_5), (placed21 2 (3, 0) required_52)] +def childrenD_271 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_5), (placed21 2 (3, 0) envelope_52)] +theorem common_sub_271 : commonEnvelope childrenD_271 ⊆ insert (2, 3) required_271 := by decide +kernel +theorem child_required_sub_271 : ∀ j, childrenC_271 j ⊆ insert (2, 3) required_271 := by decide +kernel +theorem child_envelope_sub_271 : ∀ j, childrenD_271 j ⊆ envelope_271 := by decide +kernel +theorem pivot_mem_271 : (2, 3) ∈ envelope_271 := by decide +kernel +theorem children_work_271 : ∀ j, Template HasSnaky 3 (childrenC_271 j) (childrenD_271 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (3, 0)).mono (by decide +kernel) +theorem row_works_271 : Template HasSnaky 4 required_271 envelope_271 := by + refine compose HasSnaky 3 childrenC_271 childrenD_271 children_work_271 (2, 3) + required_271 envelope_271 pivot_mem_271 child_required_sub_271 child_envelope_sub_271 ?_ + intro b hb + exact common_sub_271 (mem_commonEnvelope childrenD_271 b hb) +def required_277 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_277 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_277 : Fin 2 → Finset Cell := ![(placed21 2 (5, 2) required_0), (placed21 2 (4, 0) required_69)] +def childrenD_277 : Fin 2 → Finset Cell := ![(placed21 2 (5, 2) envelope_0), (placed21 2 (4, 0) envelope_69)] +theorem common_sub_277 : commonEnvelope childrenD_277 ⊆ insert (1, 3) required_277 := by decide +kernel +theorem child_required_sub_277 : ∀ j, childrenC_277 j ⊆ insert (1, 3) required_277 := by decide +kernel +theorem child_envelope_sub_277 : ∀ j, childrenD_277 j ⊆ envelope_277 := by decide +kernel +theorem pivot_mem_277 : (1, 3) ∈ envelope_277 := by decide +kernel +theorem children_work_277 : ∀ j, Template HasSnaky 3 (childrenC_277 j) (childrenD_277 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_69 2 (4, 0)).mono (by decide +kernel) +theorem row_works_277 : Template HasSnaky 4 required_277 envelope_277 := by + refine compose HasSnaky 3 childrenC_277 childrenD_277 children_work_277 (1, 3) + required_277 envelope_277 pivot_mem_277 child_required_sub_277 child_envelope_sub_277 ?_ + intro b hb + exact common_sub_277 (mem_commonEnvelope childrenD_277 b hb) +def required_288 : Finset Cell := ⟨(([(0, 0), (0, 3), (1, 3), (1, 4), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_288 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (3, 4), (3, 5), (4, 4), (4, 5), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_288 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) required_54), required_68] +def childrenD_288 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) envelope_54), envelope_68] +theorem common_sub_288 : commonEnvelope childrenD_288 ⊆ insert (1, 5) required_288 := by decide +kernel +theorem child_required_sub_288 : ∀ j, childrenC_288 j ⊆ insert (1, 5) required_288 := by decide +kernel +theorem child_envelope_sub_288 : ∀ j, childrenD_288 j ⊆ envelope_288 := by decide +kernel +theorem pivot_mem_288 : (1, 5) ∈ envelope_288 := by decide +kernel +theorem children_work_288 : ∀ j, Template HasSnaky 3 (childrenC_288 j) (childrenD_288 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 3 (0, 5)).mono (by decide +kernel) + · exact row_works_68.mono (by decide +kernel) +theorem row_works_288 : Template HasSnaky 4 required_288 envelope_288 := by + refine compose HasSnaky 3 childrenC_288 childrenD_288 children_work_288 (1, 5) + required_288 envelope_288 pivot_mem_288 child_required_sub_288 child_envelope_sub_288 ?_ + intro b hb + exact common_sub_288 (mem_commonEnvelope childrenD_288 b hb) +def required_289 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 4), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_289 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_289 : Fin 3 → Finset Cell := ![required_22, (placed21 4 (0, 5) required_28), (placed21 6 (2, 5) required_126)] +def childrenD_289 : Fin 3 → Finset Cell := ![envelope_22, (placed21 4 (0, 5) envelope_28), (placed21 6 (2, 5) envelope_126)] +theorem common_sub_289 : commonEnvelope childrenD_289 ⊆ insert (1, 2) required_289 := by decide +kernel +theorem child_required_sub_289 : ∀ j, childrenC_289 j ⊆ insert (1, 2) required_289 := by decide +kernel +theorem child_envelope_sub_289 : ∀ j, childrenD_289 j ⊆ envelope_289 := by decide +kernel +theorem pivot_mem_289 : (1, 2) ∈ envelope_289 := by decide +kernel +theorem children_work_289 : ∀ j, Template HasSnaky 3 (childrenC_289 j) (childrenD_289 j) := by + intro j + fin_cases j + · exact row_works_22.mono (by decide +kernel) + · exact (placed21_template row_works_28 4 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_126 6 (2, 5)).mono (by decide +kernel) +theorem row_works_289 : Template HasSnaky 4 required_289 envelope_289 := by + refine compose HasSnaky 3 childrenC_289 childrenD_289 children_work_289 (1, 2) + required_289 envelope_289 pivot_mem_289 child_required_sub_289 child_envelope_sub_289 ?_ + intro b hb + exact common_sub_289 (mem_commonEnvelope childrenD_289 b hb) +def required_291 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_291 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_291 : Fin 2 → Finset Cell := ![(placed21 2 (3, 0) required_7), (placed21 5 (4, 1) required_25)] +def childrenD_291 : Fin 2 → Finset Cell := ![(placed21 2 (3, 0) envelope_7), (placed21 5 (4, 1) envelope_25)] +theorem common_sub_291 : commonEnvelope childrenD_291 ⊆ insert (3, 4) required_291 := by decide +kernel +theorem child_required_sub_291 : ∀ j, childrenC_291 j ⊆ insert (3, 4) required_291 := by decide +kernel +theorem child_envelope_sub_291 : ∀ j, childrenD_291 j ⊆ envelope_291 := by decide +kernel +theorem pivot_mem_291 : (3, 4) ∈ envelope_291 := by decide +kernel +theorem children_work_291 : ∀ j, Template HasSnaky 3 (childrenC_291 j) (childrenD_291 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_25 5 (4, 1)).mono (by decide +kernel) +theorem row_works_291 : Template HasSnaky 4 required_291 envelope_291 := by + refine compose HasSnaky 3 childrenC_291 childrenD_291 children_work_291 (3, 4) + required_291 envelope_291 pivot_mem_291 child_required_sub_291 child_envelope_sub_291 ?_ + intro b hb + exact common_sub_291 (mem_commonEnvelope childrenD_291 b hb) +def required_304 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_304 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_304 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) required_7), (placed21 1 (0, 2) required_8), (placed21 6 (2, 6) required_9)] +def childrenD_304 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) envelope_7), (placed21 1 (0, 2) envelope_8), (placed21 6 (2, 6) envelope_9)] +theorem common_sub_304 : commonEnvelope childrenD_304 ⊆ insert (1, 4) required_304 := by decide +kernel +theorem child_required_sub_304 : ∀ j, childrenC_304 j ⊆ insert (1, 4) required_304 := by decide +kernel +theorem child_envelope_sub_304 : ∀ j, childrenD_304 j ⊆ envelope_304 := by decide +kernel +theorem pivot_mem_304 : (1, 4) ∈ envelope_304 := by decide +kernel +theorem children_work_304 : ∀ j, Template HasSnaky 3 (childrenC_304 j) (childrenD_304 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 6 (2, 6)).mono (by decide +kernel) +theorem row_works_304 : Template HasSnaky 4 required_304 envelope_304 := by + refine compose HasSnaky 3 childrenC_304 childrenD_304 children_work_304 (1, 4) + required_304 envelope_304 pivot_mem_304 child_required_sub_304 child_envelope_sub_304 ?_ + intro b hb + exact common_sub_304 (mem_commonEnvelope childrenD_304 b hb) +def required_305 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 2), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_305 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_305 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 4 (0, 5) required_124)] +def childrenD_305 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 4 (0, 5) envelope_124)] +theorem common_sub_305 : commonEnvelope childrenD_305 ⊆ insert (1, 3) required_305 := by decide +kernel +theorem child_required_sub_305 : ∀ j, childrenC_305 j ⊆ insert (1, 3) required_305 := by decide +kernel +theorem child_envelope_sub_305 : ∀ j, childrenD_305 j ⊆ envelope_305 := by decide +kernel +theorem pivot_mem_305 : (1, 3) ∈ envelope_305 := by decide +kernel +theorem children_work_305 : ∀ j, Template HasSnaky 3 (childrenC_305 j) (childrenD_305 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_124 4 (0, 5)).mono (by decide +kernel) +theorem row_works_305 : Template HasSnaky 4 required_305 envelope_305 := by + refine compose HasSnaky 3 childrenC_305 childrenD_305 children_work_305 (1, 3) + required_305 envelope_305 pivot_mem_305 child_required_sub_305 child_envelope_sub_305 ?_ + intro b hb + exact common_sub_305 (mem_commonEnvelope childrenD_305 b hb) +def required_307 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_307 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_307 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_5), (placed21 0 (1, 0) required_131)] +def childrenD_307 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_5), (placed21 0 (1, 0) envelope_131)] +theorem common_sub_307 : commonEnvelope childrenD_307 ⊆ insert (4, 2) required_307 := by decide +kernel +theorem child_required_sub_307 : ∀ j, childrenC_307 j ⊆ insert (4, 2) required_307 := by decide +kernel +theorem child_envelope_sub_307 : ∀ j, childrenD_307 j ⊆ envelope_307 := by decide +kernel +theorem pivot_mem_307 : (4, 2) ∈ envelope_307 := by decide +kernel +theorem children_work_307 : ∀ j, Template HasSnaky 3 (childrenC_307 j) (childrenD_307 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_131 0 (1, 0)).mono (by decide +kernel) +theorem row_works_307 : Template HasSnaky 4 required_307 envelope_307 := by + refine compose HasSnaky 3 childrenC_307 childrenD_307 children_work_307 (4, 2) + required_307 envelope_307 pivot_mem_307 child_required_sub_307 child_envelope_sub_307 ?_ + intro b hb + exact common_sub_307 (mem_commonEnvelope childrenD_307 b hb) +def required_311_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (4, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_311_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_311_i0 : Fin 2 → Finset Cell := ![(placed21 4 (1, 1) required_5), (placed21 1 (0, 1) required_6)] +def childrenD_311_i0 : Fin 2 → Finset Cell := ![(placed21 4 (1, 1) envelope_5), (placed21 1 (0, 1) envelope_6)] +theorem common_sub_311_i0 : commonEnvelope childrenD_311_i0 ⊆ insert (4, 1) required_311_i0 := by decide +kernel +theorem child_required_sub_311_i0 : ∀ j, childrenC_311_i0 j ⊆ insert (4, 1) required_311_i0 := by decide +kernel +theorem child_envelope_sub_311_i0 : ∀ j, childrenD_311_i0 j ⊆ envelope_311_i0 := by decide +kernel +theorem pivot_mem_311_i0 : (4, 1) ∈ envelope_311_i0 := by decide +kernel +theorem children_work_311_i0 : ∀ j, Template HasSnaky 2 (childrenC_311_i0 j) (childrenD_311_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_6 1 (0, 1)).mono (by decide +kernel) +theorem row_works_311_i0 : Template HasSnaky 3 required_311_i0 envelope_311_i0 := by + refine compose HasSnaky 2 childrenC_311_i0 childrenD_311_i0 children_work_311_i0 (4, 1) + required_311_i0 envelope_311_i0 pivot_mem_311_i0 child_required_sub_311_i0 child_envelope_sub_311_i0 ?_ + intro b hb + exact common_sub_311_i0 (mem_commonEnvelope childrenD_311_i0 b hb) +def required_311 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (4, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_311 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_311 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_4), required_311_i0] +def childrenD_311 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_4), envelope_311_i0] +theorem common_sub_311 : commonEnvelope childrenD_311 ⊆ insert (3, 1) required_311 := by decide +kernel +theorem child_required_sub_311 : ∀ j, childrenC_311 j ⊆ insert (3, 1) required_311 := by decide +kernel +theorem child_envelope_sub_311 : ∀ j, childrenD_311 j ⊆ envelope_311 := by decide +kernel +theorem pivot_mem_311 : (3, 1) ∈ envelope_311 := by decide +kernel +theorem children_work_311 : ∀ j, Template HasSnaky 3 (childrenC_311 j) (childrenD_311 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact row_works_311_i0.mono (by decide +kernel) +theorem row_works_311 : Template HasSnaky 4 required_311 envelope_311 := by + refine compose HasSnaky 3 childrenC_311 childrenD_311 children_work_311 (3, 1) + required_311 envelope_311 pivot_mem_311 child_required_sub_311 child_envelope_sub_311 ?_ + intro b hb + exact common_sub_311 (mem_commonEnvelope childrenD_311 b hb) +def required_334 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_334 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_334 : Fin 4 → Finset Cell := ![(placed21 0 (0, 1) required_101), (placed21 6 (1, 6) required_101), (placed21 0 (0, 2) required_333), (placed21 6 (1, 5) required_333)] +def childrenD_334 : Fin 4 → Finset Cell := ![(placed21 0 (0, 1) envelope_101), (placed21 6 (1, 6) envelope_101), (placed21 0 (0, 2) envelope_333), (placed21 6 (1, 5) envelope_333)] +theorem common_sub_334 : commonEnvelope childrenD_334 ⊆ insert (1, 5) required_334 := by decide +kernel +theorem child_required_sub_334 : ∀ j, childrenC_334 j ⊆ insert (1, 5) required_334 := by decide +kernel +theorem child_envelope_sub_334 : ∀ j, childrenD_334 j ⊆ envelope_334 := by decide +kernel +theorem pivot_mem_334 : (1, 5) ∈ envelope_334 := by decide +kernel +theorem children_work_334 : ∀ j, Template HasSnaky 3 (childrenC_334 j) (childrenD_334 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_101 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_101 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_333 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_333 6 (1, 5)).mono (by decide +kernel) +theorem row_works_334 : Template HasSnaky 4 required_334 envelope_334 := by + refine compose HasSnaky 3 childrenC_334 childrenD_334 children_work_334 (1, 5) + required_334 envelope_334 pivot_mem_334 child_required_sub_334 child_envelope_sub_334 ?_ + intro b hb + exact common_sub_334 (mem_commonEnvelope childrenD_334 b hb) +def required_351 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_351 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (5, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_351 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), required_350] +def childrenD_351 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), envelope_350] +theorem common_sub_351 : commonEnvelope childrenD_351 ⊆ insert (3, 1) required_351 := by decide +kernel +theorem child_required_sub_351 : ∀ j, childrenC_351 j ⊆ insert (3, 1) required_351 := by decide +kernel +theorem child_envelope_sub_351 : ∀ j, childrenD_351 j ⊆ envelope_351 := by decide +kernel +theorem pivot_mem_351 : (3, 1) ∈ envelope_351 := by decide +kernel +theorem children_work_351 : ∀ j, Template HasSnaky 3 (childrenC_351 j) (childrenD_351 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact row_works_350.mono (by decide +kernel) +theorem row_works_351 : Template HasSnaky 4 required_351 envelope_351 := by + refine compose HasSnaky 3 childrenC_351 childrenD_351 children_work_351 (3, 1) + required_351 envelope_351 pivot_mem_351 child_required_sub_351 child_envelope_sub_351 ?_ + intro b hb + exact common_sub_351 (mem_commonEnvelope childrenD_351 b hb) +def required_354_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 0), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_354_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_354_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), (placed21 2 (3, 0) required_70)] +def childrenD_354_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), (placed21 2 (3, 0) envelope_70)] +theorem common_sub_354_i0 : commonEnvelope childrenD_354_i0 ⊆ insert (3, 2) required_354_i0 := by decide +kernel +theorem child_required_sub_354_i0 : ∀ j, childrenC_354_i0 j ⊆ insert (3, 2) required_354_i0 := by decide +kernel +theorem child_envelope_sub_354_i0 : ∀ j, childrenD_354_i0 j ⊆ envelope_354_i0 := by decide +kernel +theorem pivot_mem_354_i0 : (3, 2) ∈ envelope_354_i0 := by decide +kernel +theorem children_work_354_i0 : ∀ j, Template HasSnaky 2 (childrenC_354_i0 j) (childrenD_354_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_70 2 (3, 0)).mono (by decide +kernel) +theorem row_works_354_i0 : Template HasSnaky 3 required_354_i0 envelope_354_i0 := by + refine compose HasSnaky 2 childrenC_354_i0 childrenD_354_i0 children_work_354_i0 (3, 2) + required_354_i0 envelope_354_i0 pivot_mem_354_i0 child_required_sub_354_i0 child_envelope_sub_354_i0 ?_ + intro b hb + exact common_sub_354_i0 (mem_commonEnvelope childrenD_354_i0 b hb) +def required_354 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_354 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_354 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), required_354_i0] +def childrenD_354 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), envelope_354_i0] +theorem common_sub_354 : commonEnvelope childrenD_354 ⊆ insert (3, 0) required_354 := by decide +kernel +theorem child_required_sub_354 : ∀ j, childrenC_354 j ⊆ insert (3, 0) required_354 := by decide +kernel +theorem child_envelope_sub_354 : ∀ j, childrenD_354 j ⊆ envelope_354 := by decide +kernel +theorem pivot_mem_354 : (3, 0) ∈ envelope_354 := by decide +kernel +theorem children_work_354 : ∀ j, Template HasSnaky 3 (childrenC_354 j) (childrenD_354 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact row_works_354_i0.mono (by decide +kernel) +theorem row_works_354 : Template HasSnaky 4 required_354 envelope_354 := by + refine compose HasSnaky 3 childrenC_354 childrenD_354 children_work_354 (3, 0) + required_354 envelope_354 pivot_mem_354 child_required_sub_354 child_envelope_sub_354 ?_ + intro b hb + exact common_sub_354 (mem_commonEnvelope childrenD_354 b hb) +def required_365_i1 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_365_i1 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_365_i1 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) required_0), (placed21 7 (1, 7) required_0)] +def childrenD_365_i1 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) envelope_0), (placed21 7 (1, 7) envelope_0)] +theorem common_sub_365_i1 : commonEnvelope childrenD_365_i1 ⊆ insert (0, 4) required_365_i1 := by decide +kernel +theorem child_required_sub_365_i1 : ∀ j, childrenC_365_i1 j ⊆ insert (0, 4) required_365_i1 := by decide +kernel +theorem child_envelope_sub_365_i1 : ∀ j, childrenD_365_i1 j ⊆ envelope_365_i1 := by decide +kernel +theorem pivot_mem_365_i1 : (0, 4) ∈ envelope_365_i1 := by decide +kernel +theorem children_work_365_i1 : ∀ j, Template HasSnaky 1 (childrenC_365_i1 j) (childrenD_365_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 5 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_0 7 (1, 7)).mono (by decide +kernel) +theorem row_works_365_i1 : Template HasSnaky 2 required_365_i1 envelope_365_i1 := by + refine compose HasSnaky 1 childrenC_365_i1 childrenD_365_i1 children_work_365_i1 (0, 4) + required_365_i1 envelope_365_i1 pivot_mem_365_i1 child_required_sub_365_i1 child_envelope_sub_365_i1 ?_ + intro b hb + exact common_sub_365_i1 (mem_commonEnvelope childrenD_365_i1 b hb) +def required_365_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_365_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_365_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 6) required_5), required_365_i1] +def childrenD_365_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 6) envelope_5), envelope_365_i1] +theorem common_sub_365_i0 : commonEnvelope childrenD_365_i0 ⊆ insert (0, 3) required_365_i0 := by decide +kernel +theorem child_required_sub_365_i0 : ∀ j, childrenC_365_i0 j ⊆ insert (0, 3) required_365_i0 := by decide +kernel +theorem child_envelope_sub_365_i0 : ∀ j, childrenD_365_i0 j ⊆ envelope_365_i0 := by decide +kernel +theorem pivot_mem_365_i0 : (0, 3) ∈ envelope_365_i0 := by decide +kernel +theorem children_work_365_i0 : ∀ j, Template HasSnaky 2 (childrenC_365_i0 j) (childrenD_365_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 6)).mono (by decide +kernel) + · exact row_works_365_i1.mono (by decide +kernel) +theorem row_works_365_i0 : Template HasSnaky 3 required_365_i0 envelope_365_i0 := by + refine compose HasSnaky 2 childrenC_365_i0 childrenD_365_i0 children_work_365_i0 (0, 3) + required_365_i0 envelope_365_i0 pivot_mem_365_i0 child_required_sub_365_i0 child_envelope_sub_365_i0 ?_ + intro b hb + exact common_sub_365_i0 (mem_commonEnvelope childrenD_365_i0 b hb) +def required_365 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_365 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_365 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) required_6), required_365_i0] +def childrenD_365 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) envelope_6), envelope_365_i0] +theorem common_sub_365 : commonEnvelope childrenD_365 ⊆ insert (1, 6) required_365 := by decide +kernel +theorem child_required_sub_365 : ∀ j, childrenC_365 j ⊆ insert (1, 6) required_365 := by decide +kernel +theorem child_envelope_sub_365 : ∀ j, childrenD_365 j ⊆ envelope_365 := by decide +kernel +theorem pivot_mem_365 : (1, 6) ∈ envelope_365 := by decide +kernel +theorem children_work_365 : ∀ j, Template HasSnaky 3 (childrenC_365 j) (childrenD_365 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (1, 2)).mono (by decide +kernel) + · exact row_works_365_i0.mono (by decide +kernel) +theorem row_works_365 : Template HasSnaky 4 required_365 envelope_365 := by + refine compose HasSnaky 3 childrenC_365 childrenD_365 children_work_365 (1, 6) + required_365 envelope_365 pivot_mem_365 child_required_sub_365 child_envelope_sub_365 ?_ + intro b hb + exact common_sub_365 (mem_commonEnvelope childrenD_365 b hb) +def required_375 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_375 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_375 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), required_374] +def childrenD_375 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), envelope_374] +theorem common_sub_375 : commonEnvelope childrenD_375 ⊆ insert (3, 1) required_375 := by decide +kernel +theorem child_required_sub_375 : ∀ j, childrenC_375 j ⊆ insert (3, 1) required_375 := by decide +kernel +theorem child_envelope_sub_375 : ∀ j, childrenD_375 j ⊆ envelope_375 := by decide +kernel +theorem pivot_mem_375 : (3, 1) ∈ envelope_375 := by decide +kernel +theorem children_work_375 : ∀ j, Template HasSnaky 3 (childrenC_375 j) (childrenD_375 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact row_works_374.mono (by decide +kernel) +theorem row_works_375 : Template HasSnaky 4 required_375 envelope_375 := by + refine compose HasSnaky 3 childrenC_375 childrenD_375 children_work_375 (3, 1) + required_375 envelope_375 pivot_mem_375 child_required_sub_375 child_envelope_sub_375 ?_ + intro b hb + exact common_sub_375 (mem_commonEnvelope childrenD_375 b hb) +def required_376_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (3, 0), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_376_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_376_i0 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) required_2), (placed21 5 (4, 0) required_77)] +def childrenD_376_i0 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) envelope_2), (placed21 5 (4, 0) envelope_77)] +theorem common_sub_376_i0 : commonEnvelope childrenD_376_i0 ⊆ insert (2, 4) required_376_i0 := by decide +kernel +theorem child_required_sub_376_i0 : ∀ j, childrenC_376_i0 j ⊆ insert (2, 4) required_376_i0 := by decide +kernel +theorem child_envelope_sub_376_i0 : ∀ j, childrenD_376_i0 j ⊆ envelope_376_i0 := by decide +kernel +theorem pivot_mem_376_i0 : (2, 4) ∈ envelope_376_i0 := by decide +kernel +theorem children_work_376_i0 : ∀ j, Template HasSnaky 2 (childrenC_376_i0 j) (childrenD_376_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 3 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_77 5 (4, 0)).mono (by decide +kernel) +theorem row_works_376_i0 : Template HasSnaky 3 required_376_i0 envelope_376_i0 := by + refine compose HasSnaky 2 childrenC_376_i0 childrenD_376_i0 children_work_376_i0 (2, 4) + required_376_i0 envelope_376_i0 pivot_mem_376_i0 child_required_sub_376_i0 child_envelope_sub_376_i0 ?_ + intro b hb + exact common_sub_376_i0 (mem_commonEnvelope childrenD_376_i0 b hb) +def required_376 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_376 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_376 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), required_376_i0] +def childrenD_376 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), envelope_376_i0] +theorem common_sub_376 : commonEnvelope childrenD_376 ⊆ insert (3, 0) required_376 := by decide +kernel +theorem child_required_sub_376 : ∀ j, childrenC_376 j ⊆ insert (3, 0) required_376 := by decide +kernel +theorem child_envelope_sub_376 : ∀ j, childrenD_376 j ⊆ envelope_376 := by decide +kernel +theorem pivot_mem_376 : (3, 0) ∈ envelope_376 := by decide +kernel +theorem children_work_376 : ∀ j, Template HasSnaky 3 (childrenC_376 j) (childrenD_376 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact row_works_376_i0.mono (by decide +kernel) +theorem row_works_376 : Template HasSnaky 4 required_376 envelope_376 := by + refine compose HasSnaky 3 childrenC_376 childrenD_376 children_work_376 (3, 0) + required_376 envelope_376 pivot_mem_376 child_required_sub_376 child_envelope_sub_376 ?_ + intro b hb + exact common_sub_376 (mem_commonEnvelope childrenD_376 b hb) +def height_268 : ℕ := 4 +def childrenH_268 : Fin 3 → ℕ := ![height_7, height_8, height_9] +theorem height_exact_268 : height_268 = 1 + Finset.univ.sup childrenH_268 := by decide +kernel +theorem required_origin_268 : ∀ x ∈ required_268, + (∃ j, x ∈ childrenC_268 j) ∨ ∀ j, x ∈ childrenD_268 j := by decide +kernel +theorem required_exact_268 : required_268 = + ((Finset.univ.biUnion childrenC_268) ∪ commonEnvelope childrenD_268).erase (1, 4) := by + exact required_eq_combination childrenC_268 childrenD_268 (1, 4) required_268 + (by decide +kernel) child_required_sub_268 common_sub_268 required_origin_268 +theorem envelope_origin_268 : ∀ x ∈ envelope_268, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_268 j := by decide +kernel +theorem envelope_exact_268 : envelope_268 = + insert (1, 4) (Finset.univ.biUnion childrenD_268) := by + exact envelope_eq_combination childrenD_268 (1, 4) envelope_268 + pivot_mem_268 child_envelope_sub_268 envelope_origin_268 +def checked_268 : CheckedCard where + required := required_268 + envelope := envelope_268 + height := height_268 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_268 +def height_269 : ℕ := 4 +def childrenH_269 : Fin 2 → ℕ := ![height_7, height_21] +theorem height_exact_269 : height_269 = 1 + Finset.univ.sup childrenH_269 := by decide +kernel +theorem required_origin_269 : ∀ x ∈ required_269, + (∃ j, x ∈ childrenC_269 j) ∨ ∀ j, x ∈ childrenD_269 j := by decide +kernel +theorem required_exact_269 : required_269 = + ((Finset.univ.biUnion childrenC_269) ∪ commonEnvelope childrenD_269).erase (1, 5) := by + exact required_eq_combination childrenC_269 childrenD_269 (1, 5) required_269 + (by decide +kernel) child_required_sub_269 common_sub_269 required_origin_269 +theorem envelope_origin_269 : ∀ x ∈ envelope_269, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_269 j := by decide +kernel +theorem envelope_exact_269 : envelope_269 = + insert (1, 5) (Finset.univ.biUnion childrenD_269) := by + exact envelope_eq_combination childrenD_269 (1, 5) envelope_269 + pivot_mem_269 child_envelope_sub_269 envelope_origin_269 +def checked_269 : CheckedCard where + required := required_269 + envelope := envelope_269 + height := height_269 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_269 +def height_271 : ℕ := 4 +def childrenH_271 : Fin 2 → ℕ := ![height_5, height_52] +theorem height_exact_271 : height_271 = 1 + Finset.univ.sup childrenH_271 := by decide +kernel +theorem required_origin_271 : ∀ x ∈ required_271, + (∃ j, x ∈ childrenC_271 j) ∨ ∀ j, x ∈ childrenD_271 j := by decide +kernel +theorem required_exact_271 : required_271 = + ((Finset.univ.biUnion childrenC_271) ∪ commonEnvelope childrenD_271).erase (2, 3) := by + exact required_eq_combination childrenC_271 childrenD_271 (2, 3) required_271 + (by decide +kernel) child_required_sub_271 common_sub_271 required_origin_271 +theorem envelope_origin_271 : ∀ x ∈ envelope_271, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_271 j := by decide +kernel +theorem envelope_exact_271 : envelope_271 = + insert (2, 3) (Finset.univ.biUnion childrenD_271) := by + exact envelope_eq_combination childrenD_271 (2, 3) envelope_271 + pivot_mem_271 child_envelope_sub_271 envelope_origin_271 +def checked_271 : CheckedCard where + required := required_271 + envelope := envelope_271 + height := height_271 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_271 +def height_277 : ℕ := 4 +def childrenH_277 : Fin 2 → ℕ := ![height_0, height_69] +theorem height_exact_277 : height_277 = 1 + Finset.univ.sup childrenH_277 := by decide +kernel +theorem required_origin_277 : ∀ x ∈ required_277, + (∃ j, x ∈ childrenC_277 j) ∨ ∀ j, x ∈ childrenD_277 j := by decide +kernel +theorem required_exact_277 : required_277 = + ((Finset.univ.biUnion childrenC_277) ∪ commonEnvelope childrenD_277).erase (1, 3) := by + exact required_eq_combination childrenC_277 childrenD_277 (1, 3) required_277 + (by decide +kernel) child_required_sub_277 common_sub_277 required_origin_277 +theorem envelope_origin_277 : ∀ x ∈ envelope_277, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_277 j := by decide +kernel +theorem envelope_exact_277 : envelope_277 = + insert (1, 3) (Finset.univ.biUnion childrenD_277) := by + exact envelope_eq_combination childrenD_277 (1, 3) envelope_277 + pivot_mem_277 child_envelope_sub_277 envelope_origin_277 +def checked_277 : CheckedCard where + required := required_277 + envelope := envelope_277 + height := height_277 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_277 +def height_288 : ℕ := 4 +def childrenH_288 : Fin 2 → ℕ := ![height_54, height_68] +theorem height_exact_288 : height_288 = 1 + Finset.univ.sup childrenH_288 := by decide +kernel +theorem required_origin_288 : ∀ x ∈ required_288, + (∃ j, x ∈ childrenC_288 j) ∨ ∀ j, x ∈ childrenD_288 j := by decide +kernel +theorem required_exact_288 : required_288 = + ((Finset.univ.biUnion childrenC_288) ∪ commonEnvelope childrenD_288).erase (1, 5) := by + exact required_eq_combination childrenC_288 childrenD_288 (1, 5) required_288 + (by decide +kernel) child_required_sub_288 common_sub_288 required_origin_288 +theorem envelope_origin_288 : ∀ x ∈ envelope_288, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_288 j := by decide +kernel +theorem envelope_exact_288 : envelope_288 = + insert (1, 5) (Finset.univ.biUnion childrenD_288) := by + exact envelope_eq_combination childrenD_288 (1, 5) envelope_288 + pivot_mem_288 child_envelope_sub_288 envelope_origin_288 +def checked_288 : CheckedCard where + required := required_288 + envelope := envelope_288 + height := height_288 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_288 +def height_289 : ℕ := 4 +def childrenH_289 : Fin 3 → ℕ := ![height_22, height_28, height_126] +theorem height_exact_289 : height_289 = 1 + Finset.univ.sup childrenH_289 := by decide +kernel +theorem required_origin_289 : ∀ x ∈ required_289, + (∃ j, x ∈ childrenC_289 j) ∨ ∀ j, x ∈ childrenD_289 j := by decide +kernel +theorem required_exact_289 : required_289 = + ((Finset.univ.biUnion childrenC_289) ∪ commonEnvelope childrenD_289).erase (1, 2) := by + exact required_eq_combination childrenC_289 childrenD_289 (1, 2) required_289 + (by decide +kernel) child_required_sub_289 common_sub_289 required_origin_289 +theorem envelope_origin_289 : ∀ x ∈ envelope_289, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_289 j := by decide +kernel +theorem envelope_exact_289 : envelope_289 = + insert (1, 2) (Finset.univ.biUnion childrenD_289) := by + exact envelope_eq_combination childrenD_289 (1, 2) envelope_289 + pivot_mem_289 child_envelope_sub_289 envelope_origin_289 +def checked_289 : CheckedCard where + required := required_289 + envelope := envelope_289 + height := height_289 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_289 +def height_291 : ℕ := 4 +def childrenH_291 : Fin 2 → ℕ := ![height_7, height_25] +theorem height_exact_291 : height_291 = 1 + Finset.univ.sup childrenH_291 := by decide +kernel +theorem required_origin_291 : ∀ x ∈ required_291, + (∃ j, x ∈ childrenC_291 j) ∨ ∀ j, x ∈ childrenD_291 j := by decide +kernel +theorem required_exact_291 : required_291 = + ((Finset.univ.biUnion childrenC_291) ∪ commonEnvelope childrenD_291).erase (3, 4) := by + exact required_eq_combination childrenC_291 childrenD_291 (3, 4) required_291 + (by decide +kernel) child_required_sub_291 common_sub_291 required_origin_291 +theorem envelope_origin_291 : ∀ x ∈ envelope_291, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_291 j := by decide +kernel +theorem envelope_exact_291 : envelope_291 = + insert (3, 4) (Finset.univ.biUnion childrenD_291) := by + exact envelope_eq_combination childrenD_291 (3, 4) envelope_291 + pivot_mem_291 child_envelope_sub_291 envelope_origin_291 +def checked_291 : CheckedCard where + required := required_291 + envelope := envelope_291 + height := height_291 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_291 +def height_304 : ℕ := 4 +def childrenH_304 : Fin 3 → ℕ := ![height_7, height_8, height_9] +theorem height_exact_304 : height_304 = 1 + Finset.univ.sup childrenH_304 := by decide +kernel +theorem required_origin_304 : ∀ x ∈ required_304, + (∃ j, x ∈ childrenC_304 j) ∨ ∀ j, x ∈ childrenD_304 j := by decide +kernel +theorem required_exact_304 : required_304 = + ((Finset.univ.biUnion childrenC_304) ∪ commonEnvelope childrenD_304).erase (1, 4) := by + exact required_eq_combination childrenC_304 childrenD_304 (1, 4) required_304 + (by decide +kernel) child_required_sub_304 common_sub_304 required_origin_304 +theorem envelope_origin_304 : ∀ x ∈ envelope_304, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_304 j := by decide +kernel +theorem envelope_exact_304 : envelope_304 = + insert (1, 4) (Finset.univ.biUnion childrenD_304) := by + exact envelope_eq_combination childrenD_304 (1, 4) envelope_304 + pivot_mem_304 child_envelope_sub_304 envelope_origin_304 +def checked_304 : CheckedCard where + required := required_304 + envelope := envelope_304 + height := height_304 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_304 +def height_305 : ℕ := 4 +def childrenH_305 : Fin 2 → ℕ := ![height_5, height_124] +theorem height_exact_305 : height_305 = 1 + Finset.univ.sup childrenH_305 := by decide +kernel +theorem required_origin_305 : ∀ x ∈ required_305, + (∃ j, x ∈ childrenC_305 j) ∨ ∀ j, x ∈ childrenD_305 j := by decide +kernel +theorem required_exact_305 : required_305 = + ((Finset.univ.biUnion childrenC_305) ∪ commonEnvelope childrenD_305).erase (1, 3) := by + exact required_eq_combination childrenC_305 childrenD_305 (1, 3) required_305 + (by decide +kernel) child_required_sub_305 common_sub_305 required_origin_305 +theorem envelope_origin_305 : ∀ x ∈ envelope_305, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_305 j := by decide +kernel +theorem envelope_exact_305 : envelope_305 = + insert (1, 3) (Finset.univ.biUnion childrenD_305) := by + exact envelope_eq_combination childrenD_305 (1, 3) envelope_305 + pivot_mem_305 child_envelope_sub_305 envelope_origin_305 +def checked_305 : CheckedCard where + required := required_305 + envelope := envelope_305 + height := height_305 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_305 +def height_307 : ℕ := 4 +def childrenH_307 : Fin 2 → ℕ := ![height_5, height_131] +theorem height_exact_307 : height_307 = 1 + Finset.univ.sup childrenH_307 := by decide +kernel +theorem required_origin_307 : ∀ x ∈ required_307, + (∃ j, x ∈ childrenC_307 j) ∨ ∀ j, x ∈ childrenD_307 j := by decide +kernel +theorem required_exact_307 : required_307 = + ((Finset.univ.biUnion childrenC_307) ∪ commonEnvelope childrenD_307).erase (4, 2) := by + exact required_eq_combination childrenC_307 childrenD_307 (4, 2) required_307 + (by decide +kernel) child_required_sub_307 common_sub_307 required_origin_307 +theorem envelope_origin_307 : ∀ x ∈ envelope_307, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_307 j := by decide +kernel +theorem envelope_exact_307 : envelope_307 = + insert (4, 2) (Finset.univ.biUnion childrenD_307) := by + exact envelope_eq_combination childrenD_307 (4, 2) envelope_307 + pivot_mem_307 child_envelope_sub_307 envelope_origin_307 +def checked_307 : CheckedCard where + required := required_307 + envelope := envelope_307 + height := height_307 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_307 +def height_311_i0 : ℕ := 3 +def childrenH_311_i0 : Fin 2 → ℕ := ![height_5, height_6] +theorem height_exact_311_i0 : height_311_i0 = 1 + Finset.univ.sup childrenH_311_i0 := by decide +kernel +theorem required_origin_311_i0 : ∀ x ∈ required_311_i0, + (∃ j, x ∈ childrenC_311_i0 j) ∨ ∀ j, x ∈ childrenD_311_i0 j := by decide +kernel +theorem required_exact_311_i0 : required_311_i0 = + ((Finset.univ.biUnion childrenC_311_i0) ∪ commonEnvelope childrenD_311_i0).erase (4, 1) := by + exact required_eq_combination childrenC_311_i0 childrenD_311_i0 (4, 1) required_311_i0 + (by decide +kernel) child_required_sub_311_i0 common_sub_311_i0 required_origin_311_i0 +theorem envelope_origin_311_i0 : ∀ x ∈ envelope_311_i0, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_311_i0 j := by decide +kernel +theorem envelope_exact_311_i0 : envelope_311_i0 = + insert (4, 1) (Finset.univ.biUnion childrenD_311_i0) := by + exact envelope_eq_combination childrenD_311_i0 (4, 1) envelope_311_i0 + pivot_mem_311_i0 child_envelope_sub_311_i0 envelope_origin_311_i0 +def checked_311_i0 : CheckedCard where + required := required_311_i0 + envelope := envelope_311_i0 + height := height_311_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_311_i0 +def height_311 : ℕ := 4 +def childrenH_311 : Fin 2 → ℕ := ![height_4, height_311_i0] +theorem height_exact_311 : height_311 = 1 + Finset.univ.sup childrenH_311 := by decide +kernel +theorem required_origin_311 : ∀ x ∈ required_311, + (∃ j, x ∈ childrenC_311 j) ∨ ∀ j, x ∈ childrenD_311 j := by decide +kernel +theorem required_exact_311 : required_311 = + ((Finset.univ.biUnion childrenC_311) ∪ commonEnvelope childrenD_311).erase (3, 1) := by + exact required_eq_combination childrenC_311 childrenD_311 (3, 1) required_311 + (by decide +kernel) child_required_sub_311 common_sub_311 required_origin_311 +theorem envelope_origin_311 : ∀ x ∈ envelope_311, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_311 j := by decide +kernel +theorem envelope_exact_311 : envelope_311 = + insert (3, 1) (Finset.univ.biUnion childrenD_311) := by + exact envelope_eq_combination childrenD_311 (3, 1) envelope_311 + pivot_mem_311 child_envelope_sub_311 envelope_origin_311 +def checked_311 : CheckedCard where + required := required_311 + envelope := envelope_311 + height := height_311 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_311 +def height_334 : ℕ := 4 +def childrenH_334 : Fin 4 → ℕ := ![height_101, height_101, height_333, height_333] +theorem height_exact_334 : height_334 = 1 + Finset.univ.sup childrenH_334 := by decide +kernel +theorem required_origin_334 : ∀ x ∈ required_334, + (∃ j, x ∈ childrenC_334 j) ∨ ∀ j, x ∈ childrenD_334 j := by decide +kernel +theorem required_exact_334 : required_334 = + ((Finset.univ.biUnion childrenC_334) ∪ commonEnvelope childrenD_334).erase (1, 5) := by + exact required_eq_combination childrenC_334 childrenD_334 (1, 5) required_334 + (by decide +kernel) child_required_sub_334 common_sub_334 required_origin_334 +theorem envelope_origin_334 : ∀ x ∈ envelope_334, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_334 j := by decide +kernel +theorem envelope_exact_334 : envelope_334 = + insert (1, 5) (Finset.univ.biUnion childrenD_334) := by + exact envelope_eq_combination childrenD_334 (1, 5) envelope_334 + pivot_mem_334 child_envelope_sub_334 envelope_origin_334 +def checked_334 : CheckedCard where + required := required_334 + envelope := envelope_334 + height := height_334 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_334 +def height_351 : ℕ := 4 +def childrenH_351 : Fin 2 → ℕ := ![height_5, height_350] +theorem height_exact_351 : height_351 = 1 + Finset.univ.sup childrenH_351 := by decide +kernel +theorem required_origin_351 : ∀ x ∈ required_351, + (∃ j, x ∈ childrenC_351 j) ∨ ∀ j, x ∈ childrenD_351 j := by decide +kernel +theorem required_exact_351 : required_351 = + ((Finset.univ.biUnion childrenC_351) ∪ commonEnvelope childrenD_351).erase (3, 1) := by + exact required_eq_combination childrenC_351 childrenD_351 (3, 1) required_351 + (by decide +kernel) child_required_sub_351 common_sub_351 required_origin_351 +theorem envelope_origin_351 : ∀ x ∈ envelope_351, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_351 j := by decide +kernel +theorem envelope_exact_351 : envelope_351 = + insert (3, 1) (Finset.univ.biUnion childrenD_351) := by + exact envelope_eq_combination childrenD_351 (3, 1) envelope_351 + pivot_mem_351 child_envelope_sub_351 envelope_origin_351 +def checked_351 : CheckedCard where + required := required_351 + envelope := envelope_351 + height := height_351 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_351 +def height_354_i0 : ℕ := 3 +def childrenH_354_i0 : Fin 2 → ℕ := ![height_5, height_70] +theorem height_exact_354_i0 : height_354_i0 = 1 + Finset.univ.sup childrenH_354_i0 := by decide +kernel +theorem required_origin_354_i0 : ∀ x ∈ required_354_i0, + (∃ j, x ∈ childrenC_354_i0 j) ∨ ∀ j, x ∈ childrenD_354_i0 j := by decide +kernel +theorem required_exact_354_i0 : required_354_i0 = + ((Finset.univ.biUnion childrenC_354_i0) ∪ commonEnvelope childrenD_354_i0).erase (3, 2) := by + exact required_eq_combination childrenC_354_i0 childrenD_354_i0 (3, 2) required_354_i0 + (by decide +kernel) child_required_sub_354_i0 common_sub_354_i0 required_origin_354_i0 +theorem envelope_origin_354_i0 : ∀ x ∈ envelope_354_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_354_i0 j := by decide +kernel +theorem envelope_exact_354_i0 : envelope_354_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_354_i0) := by + exact envelope_eq_combination childrenD_354_i0 (3, 2) envelope_354_i0 + pivot_mem_354_i0 child_envelope_sub_354_i0 envelope_origin_354_i0 +def checked_354_i0 : CheckedCard where + required := required_354_i0 + envelope := envelope_354_i0 + height := height_354_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_354_i0 +def height_354 : ℕ := 4 +def childrenH_354 : Fin 2 → ℕ := ![height_5, height_354_i0] +theorem height_exact_354 : height_354 = 1 + Finset.univ.sup childrenH_354 := by decide +kernel +theorem required_origin_354 : ∀ x ∈ required_354, + (∃ j, x ∈ childrenC_354 j) ∨ ∀ j, x ∈ childrenD_354 j := by decide +kernel +theorem required_exact_354 : required_354 = + ((Finset.univ.biUnion childrenC_354) ∪ commonEnvelope childrenD_354).erase (3, 0) := by + exact required_eq_combination childrenC_354 childrenD_354 (3, 0) required_354 + (by decide +kernel) child_required_sub_354 common_sub_354 required_origin_354 +theorem envelope_origin_354 : ∀ x ∈ envelope_354, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_354 j := by decide +kernel +theorem envelope_exact_354 : envelope_354 = + insert (3, 0) (Finset.univ.biUnion childrenD_354) := by + exact envelope_eq_combination childrenD_354 (3, 0) envelope_354 + pivot_mem_354 child_envelope_sub_354 envelope_origin_354 +def checked_354 : CheckedCard where + required := required_354 + envelope := envelope_354 + height := height_354 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_354 +def height_365_i1 : ℕ := 2 +def childrenH_365_i1 : Fin 2 → ℕ := ![height_0, height_0] +theorem height_exact_365_i1 : height_365_i1 = 1 + Finset.univ.sup childrenH_365_i1 := by decide +kernel +theorem required_origin_365_i1 : ∀ x ∈ required_365_i1, + (∃ j, x ∈ childrenC_365_i1 j) ∨ ∀ j, x ∈ childrenD_365_i1 j := by decide +kernel +theorem required_exact_365_i1 : required_365_i1 = + ((Finset.univ.biUnion childrenC_365_i1) ∪ commonEnvelope childrenD_365_i1).erase (0, 4) := by + exact required_eq_combination childrenC_365_i1 childrenD_365_i1 (0, 4) required_365_i1 + (by decide +kernel) child_required_sub_365_i1 common_sub_365_i1 required_origin_365_i1 +theorem envelope_origin_365_i1 : ∀ x ∈ envelope_365_i1, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_365_i1 j := by decide +kernel +theorem envelope_exact_365_i1 : envelope_365_i1 = + insert (0, 4) (Finset.univ.biUnion childrenD_365_i1) := by + exact envelope_eq_combination childrenD_365_i1 (0, 4) envelope_365_i1 + pivot_mem_365_i1 child_envelope_sub_365_i1 envelope_origin_365_i1 +def checked_365_i1 : CheckedCard where + required := required_365_i1 + envelope := envelope_365_i1 + height := height_365_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_365_i1 +def height_365_i0 : ℕ := 3 +def childrenH_365_i0 : Fin 2 → ℕ := ![height_5, height_365_i1] +theorem height_exact_365_i0 : height_365_i0 = 1 + Finset.univ.sup childrenH_365_i0 := by decide +kernel +theorem required_origin_365_i0 : ∀ x ∈ required_365_i0, + (∃ j, x ∈ childrenC_365_i0 j) ∨ ∀ j, x ∈ childrenD_365_i0 j := by decide +kernel +theorem required_exact_365_i0 : required_365_i0 = + ((Finset.univ.biUnion childrenC_365_i0) ∪ commonEnvelope childrenD_365_i0).erase (0, 3) := by + exact required_eq_combination childrenC_365_i0 childrenD_365_i0 (0, 3) required_365_i0 + (by decide +kernel) child_required_sub_365_i0 common_sub_365_i0 required_origin_365_i0 +theorem envelope_origin_365_i0 : ∀ x ∈ envelope_365_i0, + x = (0, 3) ∨ ∃ j, x ∈ childrenD_365_i0 j := by decide +kernel +theorem envelope_exact_365_i0 : envelope_365_i0 = + insert (0, 3) (Finset.univ.biUnion childrenD_365_i0) := by + exact envelope_eq_combination childrenD_365_i0 (0, 3) envelope_365_i0 + pivot_mem_365_i0 child_envelope_sub_365_i0 envelope_origin_365_i0 +def checked_365_i0 : CheckedCard where + required := required_365_i0 + envelope := envelope_365_i0 + height := height_365_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_365_i0 +def height_365 : ℕ := 4 +def childrenH_365 : Fin 2 → ℕ := ![height_6, height_365_i0] +theorem height_exact_365 : height_365 = 1 + Finset.univ.sup childrenH_365 := by decide +kernel +theorem required_origin_365 : ∀ x ∈ required_365, + (∃ j, x ∈ childrenC_365 j) ∨ ∀ j, x ∈ childrenD_365 j := by decide +kernel +theorem required_exact_365 : required_365 = + ((Finset.univ.biUnion childrenC_365) ∪ commonEnvelope childrenD_365).erase (1, 6) := by + exact required_eq_combination childrenC_365 childrenD_365 (1, 6) required_365 + (by decide +kernel) child_required_sub_365 common_sub_365 required_origin_365 +theorem envelope_origin_365 : ∀ x ∈ envelope_365, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_365 j := by decide +kernel +theorem envelope_exact_365 : envelope_365 = + insert (1, 6) (Finset.univ.biUnion childrenD_365) := by + exact envelope_eq_combination childrenD_365 (1, 6) envelope_365 + pivot_mem_365 child_envelope_sub_365 envelope_origin_365 +def checked_365 : CheckedCard where + required := required_365 + envelope := envelope_365 + height := height_365 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_365 +def height_375 : ℕ := 4 +def childrenH_375 : Fin 2 → ℕ := ![height_5, height_374] +theorem height_exact_375 : height_375 = 1 + Finset.univ.sup childrenH_375 := by decide +kernel +theorem required_origin_375 : ∀ x ∈ required_375, + (∃ j, x ∈ childrenC_375 j) ∨ ∀ j, x ∈ childrenD_375 j := by decide +kernel +theorem required_exact_375 : required_375 = + ((Finset.univ.biUnion childrenC_375) ∪ commonEnvelope childrenD_375).erase (3, 1) := by + exact required_eq_combination childrenC_375 childrenD_375 (3, 1) required_375 + (by decide +kernel) child_required_sub_375 common_sub_375 required_origin_375 +theorem envelope_origin_375 : ∀ x ∈ envelope_375, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_375 j := by decide +kernel +theorem envelope_exact_375 : envelope_375 = + insert (3, 1) (Finset.univ.biUnion childrenD_375) := by + exact envelope_eq_combination childrenD_375 (3, 1) envelope_375 + pivot_mem_375 child_envelope_sub_375 envelope_origin_375 +def checked_375 : CheckedCard where + required := required_375 + envelope := envelope_375 + height := height_375 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_375 +def height_376_i0 : ℕ := 3 +def childrenH_376_i0 : Fin 2 → ℕ := ![height_2, height_77] +theorem height_exact_376_i0 : height_376_i0 = 1 + Finset.univ.sup childrenH_376_i0 := by decide +kernel +theorem required_origin_376_i0 : ∀ x ∈ required_376_i0, + (∃ j, x ∈ childrenC_376_i0 j) ∨ ∀ j, x ∈ childrenD_376_i0 j := by decide +kernel +theorem required_exact_376_i0 : required_376_i0 = + ((Finset.univ.biUnion childrenC_376_i0) ∪ commonEnvelope childrenD_376_i0).erase (2, 4) := by + exact required_eq_combination childrenC_376_i0 childrenD_376_i0 (2, 4) required_376_i0 + (by decide +kernel) child_required_sub_376_i0 common_sub_376_i0 required_origin_376_i0 +theorem envelope_origin_376_i0 : ∀ x ∈ envelope_376_i0, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_376_i0 j := by decide +kernel +theorem envelope_exact_376_i0 : envelope_376_i0 = + insert (2, 4) (Finset.univ.biUnion childrenD_376_i0) := by + exact envelope_eq_combination childrenD_376_i0 (2, 4) envelope_376_i0 + pivot_mem_376_i0 child_envelope_sub_376_i0 envelope_origin_376_i0 +def checked_376_i0 : CheckedCard where + required := required_376_i0 + envelope := envelope_376_i0 + height := height_376_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_376_i0 +def height_376 : ℕ := 4 +def childrenH_376 : Fin 2 → ℕ := ![height_5, height_376_i0] +theorem height_exact_376 : height_376 = 1 + Finset.univ.sup childrenH_376 := by decide +kernel +theorem required_origin_376 : ∀ x ∈ required_376, + (∃ j, x ∈ childrenC_376 j) ∨ ∀ j, x ∈ childrenD_376 j := by decide +kernel +theorem required_exact_376 : required_376 = + ((Finset.univ.biUnion childrenC_376) ∪ commonEnvelope childrenD_376).erase (3, 0) := by + exact required_eq_combination childrenC_376 childrenD_376 (3, 0) required_376 + (by decide +kernel) child_required_sub_376 common_sub_376 required_origin_376 +theorem envelope_origin_376 : ∀ x ∈ envelope_376, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_376 j := by decide +kernel +theorem envelope_exact_376 : envelope_376 = + insert (3, 0) (Finset.univ.biUnion childrenD_376) := by + exact envelope_eq_combination childrenD_376 (3, 0) envelope_376 + pivot_mem_376 child_envelope_sub_376 envelope_origin_376 +def checked_376 : CheckedCard where + required := required_376 + envelope := envelope_376 + height := height_376 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_376 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part05.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part05.lean new file mode 100644 index 0000000..0304d9e --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part05.lean @@ -0,0 +1,466 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_381_i1 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (3, 2), (3, 3), (4, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_381_i1 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (5, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_381_i1 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) required_0), (placed21 4 (1, 1) required_5)] +def childrenD_381_i1 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) envelope_0), (placed21 4 (1, 1) envelope_5)] +theorem common_sub_381_i1 : commonEnvelope childrenD_381_i1 ⊆ insert (4, 1) required_381_i1 := by decide +kernel +theorem child_required_sub_381_i1 : ∀ j, childrenC_381_i1 j ⊆ insert (4, 1) required_381_i1 := by decide +kernel +theorem child_envelope_sub_381_i1 : ∀ j, childrenD_381_i1 j ⊆ envelope_381_i1 := by decide +kernel +theorem pivot_mem_381_i1 : (4, 1) ∈ envelope_381_i1 := by decide +kernel +theorem children_work_381_i1 : ∀ j, Template HasSnaky 1 (childrenC_381_i1 j) (childrenD_381_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 4 (1, 1)).mono (by decide +kernel) +theorem row_works_381_i1 : Template HasSnaky 2 required_381_i1 envelope_381_i1 := by + refine compose HasSnaky 1 childrenC_381_i1 childrenD_381_i1 children_work_381_i1 (4, 1) + required_381_i1 envelope_381_i1 pivot_mem_381_i1 child_required_sub_381_i1 child_envelope_sub_381_i1 ?_ + intro b hb + exact common_sub_381_i1 (mem_commonEnvelope childrenD_381_i1 b hb) +def required_381_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_381_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (5, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_381_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_4), required_381_i1] +def childrenD_381_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_4), envelope_381_i1] +theorem common_sub_381_i0 : commonEnvelope childrenD_381_i0 ⊆ insert (4, 0) required_381_i0 := by decide +kernel +theorem child_required_sub_381_i0 : ∀ j, childrenC_381_i0 j ⊆ insert (4, 0) required_381_i0 := by decide +kernel +theorem child_envelope_sub_381_i0 : ∀ j, childrenD_381_i0 j ⊆ envelope_381_i0 := by decide +kernel +theorem pivot_mem_381_i0 : (4, 0) ∈ envelope_381_i0 := by decide +kernel +theorem children_work_381_i0 : ∀ j, Template HasSnaky 2 (childrenC_381_i0 j) (childrenD_381_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact row_works_381_i1.mono (by decide +kernel) +theorem row_works_381_i0 : Template HasSnaky 3 required_381_i0 envelope_381_i0 := by + refine compose HasSnaky 2 childrenC_381_i0 childrenD_381_i0 children_work_381_i0 (4, 0) + required_381_i0 envelope_381_i0 pivot_mem_381_i0 child_required_sub_381_i0 child_envelope_sub_381_i0 ?_ + intro b hb + exact common_sub_381_i0 (mem_commonEnvelope childrenD_381_i0 b hb) +def required_381 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_381 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (5, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_381 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), required_381_i0] +def childrenD_381 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), envelope_381_i0] +theorem common_sub_381 : commonEnvelope childrenD_381 ⊆ insert (3, 1) required_381 := by decide +kernel +theorem child_required_sub_381 : ∀ j, childrenC_381 j ⊆ insert (3, 1) required_381 := by decide +kernel +theorem child_envelope_sub_381 : ∀ j, childrenD_381 j ⊆ envelope_381 := by decide +kernel +theorem pivot_mem_381 : (3, 1) ∈ envelope_381 := by decide +kernel +theorem children_work_381 : ∀ j, Template HasSnaky 3 (childrenC_381 j) (childrenD_381 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact row_works_381_i0.mono (by decide +kernel) +theorem row_works_381 : Template HasSnaky 4 required_381 envelope_381 := by + refine compose HasSnaky 3 childrenC_381 childrenD_381 children_work_381 (3, 1) + required_381 envelope_381 pivot_mem_381 child_required_sub_381 child_envelope_sub_381 ?_ + intro b hb + exact common_sub_381 (mem_commonEnvelope childrenD_381 b hb) +def required_424_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_424_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_424_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_2), (placed21 0 (3, 0) required_11)] +def childrenD_424_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_2), (placed21 0 (3, 0) envelope_11)] +theorem common_sub_424_i0 : commonEnvelope childrenD_424_i0 ⊆ insert (4, 2) required_424_i0 := by decide +kernel +theorem child_required_sub_424_i0 : ∀ j, childrenC_424_i0 j ⊆ insert (4, 2) required_424_i0 := by decide +kernel +theorem child_envelope_sub_424_i0 : ∀ j, childrenD_424_i0 j ⊆ envelope_424_i0 := by decide +kernel +theorem pivot_mem_424_i0 : (4, 2) ∈ envelope_424_i0 := by decide +kernel +theorem children_work_424_i0 : ∀ j, Template HasSnaky 2 (childrenC_424_i0 j) (childrenD_424_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_11 0 (3, 0)).mono (by decide +kernel) +theorem row_works_424_i0 : Template HasSnaky 3 required_424_i0 envelope_424_i0 := by + refine compose HasSnaky 2 childrenC_424_i0 childrenD_424_i0 children_work_424_i0 (4, 2) + required_424_i0 envelope_424_i0 pivot_mem_424_i0 child_required_sub_424_i0 child_envelope_sub_424_i0 ?_ + intro b hb + exact common_sub_424_i0 (mem_commonEnvelope childrenD_424_i0 b hb) +def required_424 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_424 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_424 : Fin 3 → Finset Cell := ![(placed21 0 (3, 0) required_7), (placed21 5 (4, 1) required_25), required_424_i0] +def childrenD_424 : Fin 3 → Finset Cell := ![(placed21 0 (3, 0) envelope_7), (placed21 5 (4, 1) envelope_25), envelope_424_i0] +theorem common_sub_424 : commonEnvelope childrenD_424 ⊆ insert (3, 4) required_424 := by decide +kernel +theorem child_required_sub_424 : ∀ j, childrenC_424 j ⊆ insert (3, 4) required_424 := by decide +kernel +theorem child_envelope_sub_424 : ∀ j, childrenD_424 j ⊆ envelope_424 := by decide +kernel +theorem pivot_mem_424 : (3, 4) ∈ envelope_424 := by decide +kernel +theorem children_work_424 : ∀ j, Template HasSnaky 3 (childrenC_424 j) (childrenD_424 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_25 5 (4, 1)).mono (by decide +kernel) + · exact row_works_424_i0.mono (by decide +kernel) +theorem row_works_424 : Template HasSnaky 4 required_424 envelope_424 := by + refine compose HasSnaky 3 childrenC_424 childrenD_424 children_work_424 (3, 4) + required_424 envelope_424 pivot_mem_424 child_required_sub_424 child_envelope_sub_424 ?_ + intro b hb + exact common_sub_424 (mem_commonEnvelope childrenD_424 b hb) +def required_432_i0 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (3, 3), (4, 0), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_432_i0 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_432_i0 : Fin 2 → Finset Cell := ![(placed21 4 (1, 1) required_5), (placed21 5 (5, 0) required_146)] +def childrenD_432_i0 : Fin 2 → Finset Cell := ![(placed21 4 (1, 1) envelope_5), (placed21 5 (5, 0) envelope_146)] +theorem common_sub_432_i0 : commonEnvelope childrenD_432_i0 ⊆ insert (4, 1) required_432_i0 := by decide +kernel +theorem child_required_sub_432_i0 : ∀ j, childrenC_432_i0 j ⊆ insert (4, 1) required_432_i0 := by decide +kernel +theorem child_envelope_sub_432_i0 : ∀ j, childrenD_432_i0 j ⊆ envelope_432_i0 := by decide +kernel +theorem pivot_mem_432_i0 : (4, 1) ∈ envelope_432_i0 := by decide +kernel +theorem children_work_432_i0 : ∀ j, Template HasSnaky 2 (childrenC_432_i0 j) (childrenD_432_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_146 5 (5, 0)).mono (by decide +kernel) +theorem row_works_432_i0 : Template HasSnaky 3 required_432_i0 envelope_432_i0 := by + refine compose HasSnaky 2 childrenC_432_i0 childrenD_432_i0 children_work_432_i0 (4, 1) + required_432_i0 envelope_432_i0 pivot_mem_432_i0 child_required_sub_432_i0 child_envelope_sub_432_i0 ?_ + intro b hb + exact common_sub_432_i0 (mem_commonEnvelope childrenD_432_i0 b hb) +def required_432 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_432 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_432 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_4), required_432_i0] +def childrenD_432 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_4), envelope_432_i0] +theorem common_sub_432 : commonEnvelope childrenD_432 ⊆ insert (4, 0) required_432 := by decide +kernel +theorem child_required_sub_432 : ∀ j, childrenC_432 j ⊆ insert (4, 0) required_432 := by decide +kernel +theorem child_envelope_sub_432 : ∀ j, childrenD_432 j ⊆ envelope_432 := by decide +kernel +theorem pivot_mem_432 : (4, 0) ∈ envelope_432 := by decide +kernel +theorem children_work_432 : ∀ j, Template HasSnaky 3 (childrenC_432 j) (childrenD_432 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact row_works_432_i0.mono (by decide +kernel) +theorem row_works_432 : Template HasSnaky 4 required_432 envelope_432 := by + refine compose HasSnaky 3 childrenC_432 childrenD_432 children_work_432 (4, 0) + required_432 envelope_432 pivot_mem_432 child_required_sub_432 child_envelope_sub_432 ?_ + intro b hb + exact common_sub_432 (mem_commonEnvelope childrenD_432 b hb) +def required_496_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (1, 1), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_496_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (2, 1), (3, 1), (3, 2), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_496_i0 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) required_0), (placed21 1 (0, 1) required_30)] +def childrenD_496_i0 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) envelope_0), (placed21 1 (0, 1) envelope_30)] +theorem common_sub_496_i0 : commonEnvelope childrenD_496_i0 ⊆ insert (1, 2) required_496_i0 := by decide +kernel +theorem child_required_sub_496_i0 : ∀ j, childrenC_496_i0 j ⊆ insert (1, 2) required_496_i0 := by decide +kernel +theorem child_envelope_sub_496_i0 : ∀ j, childrenD_496_i0 j ⊆ envelope_496_i0 := by decide +kernel +theorem pivot_mem_496_i0 : (1, 2) ∈ envelope_496_i0 := by decide +kernel +theorem children_work_496_i0 : ∀ j, Template HasSnaky 2 (childrenC_496_i0 j) (childrenD_496_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_30 1 (0, 1)).mono (by decide +kernel) +theorem row_works_496_i0 : Template HasSnaky 3 required_496_i0 envelope_496_i0 := by + refine compose HasSnaky 2 childrenC_496_i0 childrenD_496_i0 children_work_496_i0 (1, 2) + required_496_i0 envelope_496_i0 pivot_mem_496_i0 child_required_sub_496_i0 child_envelope_sub_496_i0 ?_ + intro b hb + exact common_sub_496_i0 (mem_commonEnvelope childrenD_496_i0 b hb) +def required_496 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_496 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (2, 1), (3, 1), (3, 2), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_496 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_5), required_496_i0] +def childrenD_496 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_5), envelope_496_i0] +theorem common_sub_496 : commonEnvelope childrenD_496 ⊆ insert (1, 1) required_496 := by decide +kernel +theorem child_required_sub_496 : ∀ j, childrenC_496 j ⊆ insert (1, 1) required_496 := by decide +kernel +theorem child_envelope_sub_496 : ∀ j, childrenD_496 j ⊆ envelope_496 := by decide +kernel +theorem pivot_mem_496 : (1, 1) ∈ envelope_496 := by decide +kernel +theorem children_work_496 : ∀ j, Template HasSnaky 3 (childrenC_496 j) (childrenD_496 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (0, 4)).mono (by decide +kernel) + · exact row_works_496_i0.mono (by decide +kernel) +theorem row_works_496 : Template HasSnaky 4 required_496 envelope_496 := by + refine compose HasSnaky 3 childrenC_496 childrenD_496 children_work_496 (1, 1) + required_496 envelope_496 pivot_mem_496 child_required_sub_496 child_envelope_sub_496 ?_ + intro b hb + exact common_sub_496 (mem_commonEnvelope childrenD_496 b hb) +def required_500_i0 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 2), (1, 3), (1, 4), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_500_i0 : Finset Cell := ⟨(([(0, 1), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (3, 1), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_500_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 1) required_5), required_146] +def childrenD_500_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 1) envelope_5), envelope_146] +theorem common_sub_500_i0 : commonEnvelope childrenD_500_i0 ⊆ insert (1, 1) required_500_i0 := by decide +kernel +theorem child_required_sub_500_i0 : ∀ j, childrenC_500_i0 j ⊆ insert (1, 1) required_500_i0 := by decide +kernel +theorem child_envelope_sub_500_i0 : ∀ j, childrenD_500_i0 j ⊆ envelope_500_i0 := by decide +kernel +theorem pivot_mem_500_i0 : (1, 1) ∈ envelope_500_i0 := by decide +kernel +theorem children_work_500_i0 : ∀ j, Template HasSnaky 2 (childrenC_500_i0 j) (childrenD_500_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (1, 1)).mono (by decide +kernel) + · exact row_works_146.mono (by decide +kernel) +theorem row_works_500_i0 : Template HasSnaky 3 required_500_i0 envelope_500_i0 := by + refine compose HasSnaky 2 childrenC_500_i0 childrenD_500_i0 children_work_500_i0 (1, 1) + required_500_i0 envelope_500_i0 pivot_mem_500_i0 child_required_sub_500_i0 child_envelope_sub_500_i0 ?_ + intro b hb + exact common_sub_500_i0 (mem_commonEnvelope childrenD_500_i0 b hb) +def required_500 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 3), (1, 4), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_500 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (3, 1), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_500 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), required_500_i0] +def childrenD_500 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), envelope_500_i0] +theorem common_sub_500 : commonEnvelope childrenD_500 ⊆ insert (1, 2) required_500 := by decide +kernel +theorem child_required_sub_500 : ∀ j, childrenC_500 j ⊆ insert (1, 2) required_500 := by decide +kernel +theorem child_envelope_sub_500 : ∀ j, childrenD_500 j ⊆ envelope_500 := by decide +kernel +theorem pivot_mem_500 : (1, 2) ∈ envelope_500 := by decide +kernel +theorem children_work_500 : ∀ j, Template HasSnaky 3 (childrenC_500 j) (childrenD_500 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact row_works_500_i0.mono (by decide +kernel) +theorem row_works_500 : Template HasSnaky 4 required_500 envelope_500 := by + refine compose HasSnaky 3 childrenC_500 childrenD_500 children_work_500 (1, 2) + required_500 envelope_500 pivot_mem_500 child_required_sub_500 child_envelope_sub_500 ?_ + intro b hb + exact common_sub_500 (mem_commonEnvelope childrenD_500 b hb) +def height_381_i1 : ℕ := 2 +def childrenH_381_i1 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_381_i1 : height_381_i1 = 1 + Finset.univ.sup childrenH_381_i1 := by decide +kernel +theorem required_origin_381_i1 : ∀ x ∈ required_381_i1, + (∃ j, x ∈ childrenC_381_i1 j) ∨ ∀ j, x ∈ childrenD_381_i1 j := by decide +kernel +theorem required_exact_381_i1 : required_381_i1 = + ((Finset.univ.biUnion childrenC_381_i1) ∪ commonEnvelope childrenD_381_i1).erase (4, 1) := by + exact required_eq_combination childrenC_381_i1 childrenD_381_i1 (4, 1) required_381_i1 + (by decide +kernel) child_required_sub_381_i1 common_sub_381_i1 required_origin_381_i1 +theorem envelope_origin_381_i1 : ∀ x ∈ envelope_381_i1, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_381_i1 j := by decide +kernel +theorem envelope_exact_381_i1 : envelope_381_i1 = + insert (4, 1) (Finset.univ.biUnion childrenD_381_i1) := by + exact envelope_eq_combination childrenD_381_i1 (4, 1) envelope_381_i1 + pivot_mem_381_i1 child_envelope_sub_381_i1 envelope_origin_381_i1 +def checked_381_i1 : CheckedCard where + required := required_381_i1 + envelope := envelope_381_i1 + height := height_381_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_381_i1 +def height_381_i0 : ℕ := 3 +def childrenH_381_i0 : Fin 2 → ℕ := ![height_4, height_381_i1] +theorem height_exact_381_i0 : height_381_i0 = 1 + Finset.univ.sup childrenH_381_i0 := by decide +kernel +theorem required_origin_381_i0 : ∀ x ∈ required_381_i0, + (∃ j, x ∈ childrenC_381_i0 j) ∨ ∀ j, x ∈ childrenD_381_i0 j := by decide +kernel +theorem required_exact_381_i0 : required_381_i0 = + ((Finset.univ.biUnion childrenC_381_i0) ∪ commonEnvelope childrenD_381_i0).erase (4, 0) := by + exact required_eq_combination childrenC_381_i0 childrenD_381_i0 (4, 0) required_381_i0 + (by decide +kernel) child_required_sub_381_i0 common_sub_381_i0 required_origin_381_i0 +theorem envelope_origin_381_i0 : ∀ x ∈ envelope_381_i0, + x = (4, 0) ∨ ∃ j, x ∈ childrenD_381_i0 j := by decide +kernel +theorem envelope_exact_381_i0 : envelope_381_i0 = + insert (4, 0) (Finset.univ.biUnion childrenD_381_i0) := by + exact envelope_eq_combination childrenD_381_i0 (4, 0) envelope_381_i0 + pivot_mem_381_i0 child_envelope_sub_381_i0 envelope_origin_381_i0 +def checked_381_i0 : CheckedCard where + required := required_381_i0 + envelope := envelope_381_i0 + height := height_381_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_381_i0 +def height_381 : ℕ := 4 +def childrenH_381 : Fin 2 → ℕ := ![height_5, height_381_i0] +theorem height_exact_381 : height_381 = 1 + Finset.univ.sup childrenH_381 := by decide +kernel +theorem required_origin_381 : ∀ x ∈ required_381, + (∃ j, x ∈ childrenC_381 j) ∨ ∀ j, x ∈ childrenD_381 j := by decide +kernel +theorem required_exact_381 : required_381 = + ((Finset.univ.biUnion childrenC_381) ∪ commonEnvelope childrenD_381).erase (3, 1) := by + exact required_eq_combination childrenC_381 childrenD_381 (3, 1) required_381 + (by decide +kernel) child_required_sub_381 common_sub_381 required_origin_381 +theorem envelope_origin_381 : ∀ x ∈ envelope_381, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_381 j := by decide +kernel +theorem envelope_exact_381 : envelope_381 = + insert (3, 1) (Finset.univ.biUnion childrenD_381) := by + exact envelope_eq_combination childrenD_381 (3, 1) envelope_381 + pivot_mem_381 child_envelope_sub_381 envelope_origin_381 +def checked_381 : CheckedCard where + required := required_381 + envelope := envelope_381 + height := height_381 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_381 +def height_424_i0 : ℕ := 3 +def childrenH_424_i0 : Fin 2 → ℕ := ![height_2, height_11] +theorem height_exact_424_i0 : height_424_i0 = 1 + Finset.univ.sup childrenH_424_i0 := by decide +kernel +theorem required_origin_424_i0 : ∀ x ∈ required_424_i0, + (∃ j, x ∈ childrenC_424_i0 j) ∨ ∀ j, x ∈ childrenD_424_i0 j := by decide +kernel +theorem required_exact_424_i0 : required_424_i0 = + ((Finset.univ.biUnion childrenC_424_i0) ∪ commonEnvelope childrenD_424_i0).erase (4, 2) := by + exact required_eq_combination childrenC_424_i0 childrenD_424_i0 (4, 2) required_424_i0 + (by decide +kernel) child_required_sub_424_i0 common_sub_424_i0 required_origin_424_i0 +theorem envelope_origin_424_i0 : ∀ x ∈ envelope_424_i0, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_424_i0 j := by decide +kernel +theorem envelope_exact_424_i0 : envelope_424_i0 = + insert (4, 2) (Finset.univ.biUnion childrenD_424_i0) := by + exact envelope_eq_combination childrenD_424_i0 (4, 2) envelope_424_i0 + pivot_mem_424_i0 child_envelope_sub_424_i0 envelope_origin_424_i0 +def checked_424_i0 : CheckedCard where + required := required_424_i0 + envelope := envelope_424_i0 + height := height_424_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_424_i0 +def height_424 : ℕ := 4 +def childrenH_424 : Fin 3 → ℕ := ![height_7, height_25, height_424_i0] +theorem height_exact_424 : height_424 = 1 + Finset.univ.sup childrenH_424 := by decide +kernel +theorem required_origin_424 : ∀ x ∈ required_424, + (∃ j, x ∈ childrenC_424 j) ∨ ∀ j, x ∈ childrenD_424 j := by decide +kernel +theorem required_exact_424 : required_424 = + ((Finset.univ.biUnion childrenC_424) ∪ commonEnvelope childrenD_424).erase (3, 4) := by + exact required_eq_combination childrenC_424 childrenD_424 (3, 4) required_424 + (by decide +kernel) child_required_sub_424 common_sub_424 required_origin_424 +theorem envelope_origin_424 : ∀ x ∈ envelope_424, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_424 j := by decide +kernel +theorem envelope_exact_424 : envelope_424 = + insert (3, 4) (Finset.univ.biUnion childrenD_424) := by + exact envelope_eq_combination childrenD_424 (3, 4) envelope_424 + pivot_mem_424 child_envelope_sub_424 envelope_origin_424 +def checked_424 : CheckedCard where + required := required_424 + envelope := envelope_424 + height := height_424 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_424 +def height_432_i0 : ℕ := 3 +def childrenH_432_i0 : Fin 2 → ℕ := ![height_5, height_146] +theorem height_exact_432_i0 : height_432_i0 = 1 + Finset.univ.sup childrenH_432_i0 := by decide +kernel +theorem required_origin_432_i0 : ∀ x ∈ required_432_i0, + (∃ j, x ∈ childrenC_432_i0 j) ∨ ∀ j, x ∈ childrenD_432_i0 j := by decide +kernel +theorem required_exact_432_i0 : required_432_i0 = + ((Finset.univ.biUnion childrenC_432_i0) ∪ commonEnvelope childrenD_432_i0).erase (4, 1) := by + exact required_eq_combination childrenC_432_i0 childrenD_432_i0 (4, 1) required_432_i0 + (by decide +kernel) child_required_sub_432_i0 common_sub_432_i0 required_origin_432_i0 +theorem envelope_origin_432_i0 : ∀ x ∈ envelope_432_i0, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_432_i0 j := by decide +kernel +theorem envelope_exact_432_i0 : envelope_432_i0 = + insert (4, 1) (Finset.univ.biUnion childrenD_432_i0) := by + exact envelope_eq_combination childrenD_432_i0 (4, 1) envelope_432_i0 + pivot_mem_432_i0 child_envelope_sub_432_i0 envelope_origin_432_i0 +def checked_432_i0 : CheckedCard where + required := required_432_i0 + envelope := envelope_432_i0 + height := height_432_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_432_i0 +def height_432 : ℕ := 4 +def childrenH_432 : Fin 2 → ℕ := ![height_4, height_432_i0] +theorem height_exact_432 : height_432 = 1 + Finset.univ.sup childrenH_432 := by decide +kernel +theorem required_origin_432 : ∀ x ∈ required_432, + (∃ j, x ∈ childrenC_432 j) ∨ ∀ j, x ∈ childrenD_432 j := by decide +kernel +theorem required_exact_432 : required_432 = + ((Finset.univ.biUnion childrenC_432) ∪ commonEnvelope childrenD_432).erase (4, 0) := by + exact required_eq_combination childrenC_432 childrenD_432 (4, 0) required_432 + (by decide +kernel) child_required_sub_432 common_sub_432 required_origin_432 +theorem envelope_origin_432 : ∀ x ∈ envelope_432, + x = (4, 0) ∨ ∃ j, x ∈ childrenD_432 j := by decide +kernel +theorem envelope_exact_432 : envelope_432 = + insert (4, 0) (Finset.univ.biUnion childrenD_432) := by + exact envelope_eq_combination childrenD_432 (4, 0) envelope_432 + pivot_mem_432 child_envelope_sub_432 envelope_origin_432 +def checked_432 : CheckedCard where + required := required_432 + envelope := envelope_432 + height := height_432 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_432 +def height_496_i0 : ℕ := 3 +def childrenH_496_i0 : Fin 2 → ℕ := ![height_0, height_30] +theorem height_exact_496_i0 : height_496_i0 = 1 + Finset.univ.sup childrenH_496_i0 := by decide +kernel +theorem required_origin_496_i0 : ∀ x ∈ required_496_i0, + (∃ j, x ∈ childrenC_496_i0 j) ∨ ∀ j, x ∈ childrenD_496_i0 j := by decide +kernel +theorem required_exact_496_i0 : required_496_i0 = + ((Finset.univ.biUnion childrenC_496_i0) ∪ commonEnvelope childrenD_496_i0).erase (1, 2) := by + exact required_eq_combination childrenC_496_i0 childrenD_496_i0 (1, 2) required_496_i0 + (by decide +kernel) child_required_sub_496_i0 common_sub_496_i0 required_origin_496_i0 +theorem envelope_origin_496_i0 : ∀ x ∈ envelope_496_i0, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_496_i0 j := by decide +kernel +theorem envelope_exact_496_i0 : envelope_496_i0 = + insert (1, 2) (Finset.univ.biUnion childrenD_496_i0) := by + exact envelope_eq_combination childrenD_496_i0 (1, 2) envelope_496_i0 + pivot_mem_496_i0 child_envelope_sub_496_i0 envelope_origin_496_i0 +def checked_496_i0 : CheckedCard where + required := required_496_i0 + envelope := envelope_496_i0 + height := height_496_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_496_i0 +def height_496 : ℕ := 4 +def childrenH_496 : Fin 2 → ℕ := ![height_5, height_496_i0] +theorem height_exact_496 : height_496 = 1 + Finset.univ.sup childrenH_496 := by decide +kernel +theorem required_origin_496 : ∀ x ∈ required_496, + (∃ j, x ∈ childrenC_496 j) ∨ ∀ j, x ∈ childrenD_496 j := by decide +kernel +theorem required_exact_496 : required_496 = + ((Finset.univ.biUnion childrenC_496) ∪ commonEnvelope childrenD_496).erase (1, 1) := by + exact required_eq_combination childrenC_496 childrenD_496 (1, 1) required_496 + (by decide +kernel) child_required_sub_496 common_sub_496 required_origin_496 +theorem envelope_origin_496 : ∀ x ∈ envelope_496, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_496 j := by decide +kernel +theorem envelope_exact_496 : envelope_496 = + insert (1, 1) (Finset.univ.biUnion childrenD_496) := by + exact envelope_eq_combination childrenD_496 (1, 1) envelope_496 + pivot_mem_496 child_envelope_sub_496 envelope_origin_496 +def checked_496 : CheckedCard where + required := required_496 + envelope := envelope_496 + height := height_496 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_496 +def height_500_i0 : ℕ := 3 +def childrenH_500_i0 : Fin 2 → ℕ := ![height_5, height_146] +theorem height_exact_500_i0 : height_500_i0 = 1 + Finset.univ.sup childrenH_500_i0 := by decide +kernel +theorem required_origin_500_i0 : ∀ x ∈ required_500_i0, + (∃ j, x ∈ childrenC_500_i0 j) ∨ ∀ j, x ∈ childrenD_500_i0 j := by decide +kernel +theorem required_exact_500_i0 : required_500_i0 = + ((Finset.univ.biUnion childrenC_500_i0) ∪ commonEnvelope childrenD_500_i0).erase (1, 1) := by + exact required_eq_combination childrenC_500_i0 childrenD_500_i0 (1, 1) required_500_i0 + (by decide +kernel) child_required_sub_500_i0 common_sub_500_i0 required_origin_500_i0 +theorem envelope_origin_500_i0 : ∀ x ∈ envelope_500_i0, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_500_i0 j := by decide +kernel +theorem envelope_exact_500_i0 : envelope_500_i0 = + insert (1, 1) (Finset.univ.biUnion childrenD_500_i0) := by + exact envelope_eq_combination childrenD_500_i0 (1, 1) envelope_500_i0 + pivot_mem_500_i0 child_envelope_sub_500_i0 envelope_origin_500_i0 +def checked_500_i0 : CheckedCard where + required := required_500_i0 + envelope := envelope_500_i0 + height := height_500_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_500_i0 +def height_500 : ℕ := 4 +def childrenH_500 : Fin 2 → ℕ := ![height_0, height_500_i0] +theorem height_exact_500 : height_500 = 1 + Finset.univ.sup childrenH_500 := by decide +kernel +theorem required_origin_500 : ∀ x ∈ required_500, + (∃ j, x ∈ childrenC_500 j) ∨ ∀ j, x ∈ childrenD_500 j := by decide +kernel +theorem required_exact_500 : required_500 = + ((Finset.univ.biUnion childrenC_500) ∪ commonEnvelope childrenD_500).erase (1, 2) := by + exact required_eq_combination childrenC_500 childrenD_500 (1, 2) required_500 + (by decide +kernel) child_required_sub_500 common_sub_500 required_origin_500 +theorem envelope_origin_500 : ∀ x ∈ envelope_500, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_500 j := by decide +kernel +theorem envelope_exact_500 : envelope_500 = + insert (1, 2) (Finset.univ.biUnion childrenD_500) := by + exact envelope_eq_combination childrenD_500 (1, 2) envelope_500 + pivot_mem_500 child_envelope_sub_500 envelope_origin_500 +def checked_500 : CheckedCard where + required := required_500 + envelope := envelope_500 + height := height_500 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_500 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part01.lean new file mode 100644 index 0000000..d4dcbd3 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part01.lean @@ -0,0 +1,1009 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_19 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_19 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_19 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 0 (0, 1) required_18)] +def childrenD_19 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 0 (0, 1) envelope_18)] +theorem common_sub_19 : commonEnvelope childrenD_19 ⊆ insert (0, 1) required_19 := by decide +kernel +theorem child_required_sub_19 : ∀ j, childrenC_19 j ⊆ insert (0, 1) required_19 := by decide +kernel +theorem child_envelope_sub_19 : ∀ j, childrenD_19 j ⊆ envelope_19 := by decide +kernel +theorem pivot_mem_19 : (0, 1) ∈ envelope_19 := by decide +kernel +theorem children_work_19 : ∀ j, Template HasSnaky 4 (childrenC_19 j) (childrenD_19 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_18 0 (0, 1)).mono (by decide +kernel) +theorem row_works_19 : Template HasSnaky 5 required_19 envelope_19 := by + refine compose HasSnaky 4 childrenC_19 childrenD_19 children_work_19 (0, 1) + required_19 envelope_19 pivot_mem_19 child_required_sub_19 child_envelope_sub_19 ?_ + intro b hb + exact common_sub_19 (mem_commonEnvelope childrenD_19 b hb) +def required_47 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_47 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_47 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) required_7), (placed21 3 (0, 3) required_9), (placed21 0 (1, 0) required_46)] +def childrenD_47 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) envelope_7), (placed21 3 (0, 3) envelope_9), (placed21 0 (1, 0) envelope_46)] +theorem common_sub_47 : commonEnvelope childrenD_47 ⊆ insert (4, 2) required_47 := by decide +kernel +theorem child_required_sub_47 : ∀ j, childrenC_47 j ⊆ insert (4, 2) required_47 := by decide +kernel +theorem child_envelope_sub_47 : ∀ j, childrenD_47 j ⊆ envelope_47 := by decide +kernel +theorem pivot_mem_47 : (4, 2) ∈ envelope_47 := by decide +kernel +theorem children_work_47 : ∀ j, Template HasSnaky 4 (childrenC_47 j) (childrenD_47 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_46 0 (1, 0)).mono (by decide +kernel) +theorem row_works_47 : Template HasSnaky 5 required_47 envelope_47 := by + refine compose HasSnaky 4 childrenC_47 childrenD_47 children_work_47 (4, 2) + required_47 envelope_47 pivot_mem_47 child_required_sub_47 child_envelope_sub_47 ?_ + intro b hb + exact common_sub_47 (mem_commonEnvelope childrenD_47 b hb) +def required_59 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_59 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_59 : Fin 3 → Finset Cell := ![(placed21 5 (4, 2) required_28), (placed21 0 (2, 0) required_31), (placed21 0 (0, 1) required_58)] +def childrenD_59 : Fin 3 → Finset Cell := ![(placed21 5 (4, 2) envelope_28), (placed21 0 (2, 0) envelope_31), (placed21 0 (0, 1) envelope_58)] +theorem common_sub_59 : commonEnvelope childrenD_59 ⊆ insert (3, 2) required_59 := by decide +kernel +theorem child_required_sub_59 : ∀ j, childrenC_59 j ⊆ insert (3, 2) required_59 := by decide +kernel +theorem child_envelope_sub_59 : ∀ j, childrenD_59 j ⊆ envelope_59 := by decide +kernel +theorem pivot_mem_59 : (3, 2) ∈ envelope_59 := by decide +kernel +theorem children_work_59 : ∀ j, Template HasSnaky 4 (childrenC_59 j) (childrenD_59 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_28 5 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_31 0 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_58 0 (0, 1)).mono (by decide +kernel) +theorem row_works_59 : Template HasSnaky 5 required_59 envelope_59 := by + refine compose HasSnaky 4 childrenC_59 childrenD_59 children_work_59 (3, 2) + required_59 envelope_59 pivot_mem_59 child_required_sub_59 child_envelope_sub_59 ?_ + intro b hb + exact common_sub_59 (mem_commonEnvelope childrenD_59 b hb) +def required_71 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_71 : Finset Cell := ⟨(([(0, 2), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 4), (2, 5), (2, 6), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_71 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_0), (placed21 2 (2, 0) required_10)] +def childrenD_71 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_0), (placed21 2 (2, 0) envelope_10)] +theorem common_sub_71 : commonEnvelope childrenD_71 ⊆ insert (2, 1) required_71 := by decide +kernel +theorem child_required_sub_71 : ∀ j, childrenC_71 j ⊆ insert (2, 1) required_71 := by decide +kernel +theorem child_envelope_sub_71 : ∀ j, childrenD_71 j ⊆ envelope_71 := by decide +kernel +theorem pivot_mem_71 : (2, 1) ∈ envelope_71 := by decide +kernel +theorem children_work_71 : ∀ j, Template HasSnaky 4 (childrenC_71 j) (childrenD_71 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_10 2 (2, 0)).mono (by decide +kernel) +theorem row_works_71 : Template HasSnaky 5 required_71 envelope_71 := by + refine compose HasSnaky 4 childrenC_71 childrenD_71 children_work_71 (2, 1) + required_71 envelope_71 pivot_mem_71 child_required_sub_71 child_envelope_sub_71 ?_ + intro b hb + exact common_sub_71 (mem_commonEnvelope childrenD_71 b hb) +def required_72 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_72 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_72 : Fin 3 → Finset Cell := ![(placed21 1 (0, 1) required_20), (placed21 3 (0, 2) required_29), required_46] +def childrenD_72 : Fin 3 → Finset Cell := ![(placed21 1 (0, 1) envelope_20), (placed21 3 (0, 2) envelope_29), envelope_46] +theorem common_sub_72 : commonEnvelope childrenD_72 ⊆ insert (3, 2) required_72 := by decide +kernel +theorem child_required_sub_72 : ∀ j, childrenC_72 j ⊆ insert (3, 2) required_72 := by decide +kernel +theorem child_envelope_sub_72 : ∀ j, childrenD_72 j ⊆ envelope_72 := by decide +kernel +theorem pivot_mem_72 : (3, 2) ∈ envelope_72 := by decide +kernel +theorem children_work_72 : ∀ j, Template HasSnaky 4 (childrenC_72 j) (childrenD_72 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_20 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_29 3 (0, 2)).mono (by decide +kernel) + · exact row_works_46.mono (by decide +kernel) +theorem row_works_72 : Template HasSnaky 5 required_72 envelope_72 := by + refine compose HasSnaky 4 childrenC_72 childrenD_72 children_work_72 (3, 2) + required_72 envelope_72 pivot_mem_72 child_required_sub_72 child_envelope_sub_72 ?_ + intro b hb + exact common_sub_72 (mem_commonEnvelope childrenD_72 b hb) +def required_81 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_81 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_81 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), (placed21 0 (2, 0) required_42)] +def childrenD_81 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), (placed21 0 (2, 0) envelope_42)] +theorem common_sub_81 : commonEnvelope childrenD_81 ⊆ insert (3, 2) required_81 := by decide +kernel +theorem child_required_sub_81 : ∀ j, childrenC_81 j ⊆ insert (3, 2) required_81 := by decide +kernel +theorem child_envelope_sub_81 : ∀ j, childrenD_81 j ⊆ envelope_81 := by decide +kernel +theorem pivot_mem_81 : (3, 2) ∈ envelope_81 := by decide +kernel +theorem children_work_81 : ∀ j, Template HasSnaky 4 (childrenC_81 j) (childrenD_81 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_42 0 (2, 0)).mono (by decide +kernel) +theorem row_works_81 : Template HasSnaky 5 required_81 envelope_81 := by + refine compose HasSnaky 4 childrenC_81 childrenD_81 children_work_81 (3, 2) + required_81 envelope_81 pivot_mem_81 child_required_sub_81 child_envelope_sub_81 ?_ + intro b hb + exact common_sub_81 (mem_commonEnvelope childrenD_81 b hb) +def required_84 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_84 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_84 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) required_6), (placed21 0 (0, 2) required_17)] +def childrenD_84 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) envelope_6), (placed21 0 (0, 2) envelope_17)] +theorem common_sub_84 : commonEnvelope childrenD_84 ⊆ insert (1, 5) required_84 := by decide +kernel +theorem child_required_sub_84 : ∀ j, childrenC_84 j ⊆ insert (1, 5) required_84 := by decide +kernel +theorem child_envelope_sub_84 : ∀ j, childrenD_84 j ⊆ envelope_84 := by decide +kernel +theorem pivot_mem_84 : (1, 5) ∈ envelope_84 := by decide +kernel +theorem children_work_84 : ∀ j, Template HasSnaky 4 (childrenC_84 j) (childrenD_84 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_17 0 (0, 2)).mono (by decide +kernel) +theorem row_works_84 : Template HasSnaky 5 required_84 envelope_84 := by + refine compose HasSnaky 4 childrenC_84 childrenD_84 children_work_84 (1, 5) + required_84 envelope_84 pivot_mem_84 child_required_sub_84 child_envelope_sub_84 ?_ + intro b hb + exact common_sub_84 (mem_commonEnvelope childrenD_84 b hb) +def required_100 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_100 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_100 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_2), (placed21 2 (4, 0) required_10)] +def childrenD_100 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_2), (placed21 2 (4, 0) envelope_10)] +theorem common_sub_100 : commonEnvelope childrenD_100 ⊆ insert (4, 1) required_100 := by decide +kernel +theorem child_required_sub_100 : ∀ j, childrenC_100 j ⊆ insert (4, 1) required_100 := by decide +kernel +theorem child_envelope_sub_100 : ∀ j, childrenD_100 j ⊆ envelope_100 := by decide +kernel +theorem pivot_mem_100 : (4, 1) ∈ envelope_100 := by decide +kernel +theorem children_work_100 : ∀ j, Template HasSnaky 4 (childrenC_100 j) (childrenD_100 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_10 2 (4, 0)).mono (by decide +kernel) +theorem row_works_100 : Template HasSnaky 5 required_100 envelope_100 := by + refine compose HasSnaky 4 childrenC_100 childrenD_100 children_work_100 (4, 1) + required_100 envelope_100 pivot_mem_100 child_required_sub_100 child_envelope_sub_100 ?_ + intro b hb + exact common_sub_100 (mem_commonEnvelope childrenD_100 b hb) +def required_104 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_104 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 6), (2, 7), (2, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_104 : Fin 4 → Finset Cell := ![(placed21 0 (0, 2) required_10), (placed21 4 (0, 6) required_10), (placed21 2 (1, 2) required_52), (placed21 6 (1, 6) required_52)] +def childrenD_104 : Fin 4 → Finset Cell := ![(placed21 0 (0, 2) envelope_10), (placed21 4 (0, 6) envelope_10), (placed21 2 (1, 2) envelope_52), (placed21 6 (1, 6) envelope_52)] +theorem common_sub_104 : commonEnvelope childrenD_104 ⊆ insert (1, 4) required_104 := by decide +kernel +theorem child_required_sub_104 : ∀ j, childrenC_104 j ⊆ insert (1, 4) required_104 := by decide +kernel +theorem child_envelope_sub_104 : ∀ j, childrenD_104 j ⊆ envelope_104 := by decide +kernel +theorem pivot_mem_104 : (1, 4) ∈ envelope_104 := by decide +kernel +theorem children_work_104 : ∀ j, Template HasSnaky 4 (childrenC_104 j) (childrenD_104 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_10 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (1, 6)).mono (by decide +kernel) +theorem row_works_104 : Template HasSnaky 5 required_104 envelope_104 := by + refine compose HasSnaky 4 childrenC_104 childrenD_104 children_work_104 (1, 4) + required_104 envelope_104 pivot_mem_104 child_required_sub_104 child_envelope_sub_104 ?_ + intro b hb + exact common_sub_104 (mem_commonEnvelope childrenD_104 b hb) +def required_107 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_107 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_107 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_3), (placed21 0 (0, 1) required_18)] +def childrenD_107 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_3), (placed21 0 (0, 1) envelope_18)] +theorem common_sub_107 : commonEnvelope childrenD_107 ⊆ insert (1, 2) required_107 := by decide +kernel +theorem child_required_sub_107 : ∀ j, childrenC_107 j ⊆ insert (1, 2) required_107 := by decide +kernel +theorem child_envelope_sub_107 : ∀ j, childrenD_107 j ⊆ envelope_107 := by decide +kernel +theorem pivot_mem_107 : (1, 2) ∈ envelope_107 := by decide +kernel +theorem children_work_107 : ∀ j, Template HasSnaky 4 (childrenC_107 j) (childrenD_107 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_18 0 (0, 1)).mono (by decide +kernel) +theorem row_works_107 : Template HasSnaky 5 required_107 envelope_107 := by + refine compose HasSnaky 4 childrenC_107 childrenD_107 children_work_107 (1, 2) + required_107 envelope_107 pivot_mem_107 child_required_sub_107 child_envelope_sub_107 ?_ + intro b hb + exact common_sub_107 (mem_commonEnvelope childrenD_107 b hb) +def required_111 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_111 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_111 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) required_17), (placed21 2 (4, 0) required_55)] +def childrenD_111 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) envelope_17), (placed21 2 (4, 0) envelope_55)] +theorem common_sub_111 : commonEnvelope childrenD_111 ⊆ insert (4, 3) required_111 := by decide +kernel +theorem child_required_sub_111 : ∀ j, childrenC_111 j ⊆ insert (4, 3) required_111 := by decide +kernel +theorem child_envelope_sub_111 : ∀ j, childrenD_111 j ⊆ envelope_111 := by decide +kernel +theorem pivot_mem_111 : (4, 3) ∈ envelope_111 := by decide +kernel +theorem children_work_111 : ∀ j, Template HasSnaky 4 (childrenC_111 j) (childrenD_111 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_17 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_55 2 (4, 0)).mono (by decide +kernel) +theorem row_works_111 : Template HasSnaky 5 required_111 envelope_111 := by + refine compose HasSnaky 4 childrenC_111 childrenD_111 children_work_111 (4, 3) + required_111 envelope_111 pivot_mem_111 child_required_sub_111 child_envelope_sub_111 ?_ + intro b hb + exact common_sub_111 (mem_commonEnvelope childrenD_111 b hb) +def required_114 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_114 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_114 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_5), (placed21 0 (2, 0) required_14)] +def childrenD_114 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_5), (placed21 0 (2, 0) envelope_14)] +theorem common_sub_114 : commonEnvelope childrenD_114 ⊆ insert (3, 4) required_114 := by decide +kernel +theorem child_required_sub_114 : ∀ j, childrenC_114 j ⊆ insert (3, 4) required_114 := by decide +kernel +theorem child_envelope_sub_114 : ∀ j, childrenD_114 j ⊆ envelope_114 := by decide +kernel +theorem pivot_mem_114 : (3, 4) ∈ envelope_114 := by decide +kernel +theorem children_work_114 : ∀ j, Template HasSnaky 4 (childrenC_114 j) (childrenD_114 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_14 0 (2, 0)).mono (by decide +kernel) +theorem row_works_114 : Template HasSnaky 5 required_114 envelope_114 := by + refine compose HasSnaky 4 childrenC_114 childrenD_114 children_work_114 (3, 4) + required_114 envelope_114 pivot_mem_114 child_required_sub_114 child_envelope_sub_114 ?_ + intro b hb + exact common_sub_114 (mem_commonEnvelope childrenD_114 b hb) +def required_122 : Finset Cell := ⟨(([(1, 2), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_122 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 4), (3, 5), (3, 6), (4, 1), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_122 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_8), (placed21 3 (0, 4) required_46)] +def childrenD_122 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_8), (placed21 3 (0, 4) envelope_46)] +theorem common_sub_122 : commonEnvelope childrenD_122 ⊆ insert (2, 4) required_122 := by decide +kernel +theorem child_required_sub_122 : ∀ j, childrenC_122 j ⊆ insert (2, 4) required_122 := by decide +kernel +theorem child_envelope_sub_122 : ∀ j, childrenD_122 j ⊆ envelope_122 := by decide +kernel +theorem pivot_mem_122 : (2, 4) ∈ envelope_122 := by decide +kernel +theorem children_work_122 : ∀ j, Template HasSnaky 4 (childrenC_122 j) (childrenD_122 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_46 3 (0, 4)).mono (by decide +kernel) +theorem row_works_122 : Template HasSnaky 5 required_122 envelope_122 := by + refine compose HasSnaky 4 childrenC_122 childrenD_122 children_work_122 (2, 4) + required_122 envelope_122 pivot_mem_122 child_required_sub_122 child_envelope_sub_122 ?_ + intro b hb + exact common_sub_122 (mem_commonEnvelope childrenD_122 b hb) +def required_133 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_133 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_133 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_5), required_132] +def childrenD_133 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_5), envelope_132] +theorem common_sub_133 : commonEnvelope childrenD_133 ⊆ insert (1, 1) required_133 := by decide +kernel +theorem child_required_sub_133 : ∀ j, childrenC_133 j ⊆ insert (1, 1) required_133 := by decide +kernel +theorem child_envelope_sub_133 : ∀ j, childrenD_133 j ⊆ envelope_133 := by decide +kernel +theorem pivot_mem_133 : (1, 1) ∈ envelope_133 := by decide +kernel +theorem children_work_133 : ∀ j, Template HasSnaky 4 (childrenC_133 j) (childrenD_133 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact row_works_132.mono (by decide +kernel) +theorem row_works_133 : Template HasSnaky 5 required_133 envelope_133 := by + refine compose HasSnaky 4 childrenC_133 childrenD_133 children_work_133 (1, 1) + required_133 envelope_133 pivot_mem_133 child_required_sub_133 child_envelope_sub_133 ?_ + intro b hb + exact common_sub_133 (mem_commonEnvelope childrenD_133 b hb) +def required_142 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_142 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_142 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_5), (placed21 0 (1, 0) required_141)] +def childrenD_142 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_5), (placed21 0 (1, 0) envelope_141)] +theorem common_sub_142 : commonEnvelope childrenD_142 ⊆ insert (1, 2) required_142 := by decide +kernel +theorem child_required_sub_142 : ∀ j, childrenC_142 j ⊆ insert (1, 2) required_142 := by decide +kernel +theorem child_envelope_sub_142 : ∀ j, childrenD_142 j ⊆ envelope_142 := by decide +kernel +theorem pivot_mem_142 : (1, 2) ∈ envelope_142 := by decide +kernel +theorem children_work_142 : ∀ j, Template HasSnaky 4 (childrenC_142 j) (childrenD_142 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_141 0 (1, 0)).mono (by decide +kernel) +theorem row_works_142 : Template HasSnaky 5 required_142 envelope_142 := by + refine compose HasSnaky 4 childrenC_142 childrenD_142 children_work_142 (1, 2) + required_142 envelope_142 pivot_mem_142 child_required_sub_142 child_envelope_sub_142 ?_ + intro b hb + exact common_sub_142 (mem_commonEnvelope childrenD_142 b hb) +def required_144 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_144 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_144 : Fin 3 → Finset Cell := ![required_46, (placed21 3 (0, 2) required_103), (placed21 0 (0, 1) required_143)] +def childrenD_144 : Fin 3 → Finset Cell := ![envelope_46, (placed21 3 (0, 2) envelope_103), (placed21 0 (0, 1) envelope_143)] +theorem common_sub_144 : commonEnvelope childrenD_144 ⊆ insert (3, 2) required_144 := by decide +kernel +theorem child_required_sub_144 : ∀ j, childrenC_144 j ⊆ insert (3, 2) required_144 := by decide +kernel +theorem child_envelope_sub_144 : ∀ j, childrenD_144 j ⊆ envelope_144 := by decide +kernel +theorem pivot_mem_144 : (3, 2) ∈ envelope_144 := by decide +kernel +theorem children_work_144 : ∀ j, Template HasSnaky 4 (childrenC_144 j) (childrenD_144 j) := by + intro j + fin_cases j + · exact row_works_46.mono (by decide +kernel) + · exact (placed21_template row_works_103 3 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_143 0 (0, 1)).mono (by decide +kernel) +theorem row_works_144 : Template HasSnaky 5 required_144 envelope_144 := by + refine compose HasSnaky 4 childrenC_144 childrenD_144 children_work_144 (3, 2) + required_144 envelope_144 pivot_mem_144 child_required_sub_144 child_envelope_sub_144 ?_ + intro b hb + exact common_sub_144 (mem_commonEnvelope childrenD_144 b hb) +def required_145 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_145 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_145 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), (placed21 0 (2, 0) required_10)] +def childrenD_145 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), (placed21 0 (2, 0) envelope_10)] +theorem common_sub_145 : commonEnvelope childrenD_145 ⊆ insert (3, 2) required_145 := by decide +kernel +theorem child_required_sub_145 : ∀ j, childrenC_145 j ⊆ insert (3, 2) required_145 := by decide +kernel +theorem child_envelope_sub_145 : ∀ j, childrenD_145 j ⊆ envelope_145 := by decide +kernel +theorem pivot_mem_145 : (3, 2) ∈ envelope_145 := by decide +kernel +theorem children_work_145 : ∀ j, Template HasSnaky 4 (childrenC_145 j) (childrenD_145 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_10 0 (2, 0)).mono (by decide +kernel) +theorem row_works_145 : Template HasSnaky 5 required_145 envelope_145 := by + refine compose HasSnaky 4 childrenC_145 childrenD_145 children_work_145 (3, 2) + required_145 envelope_145 pivot_mem_145 child_required_sub_145 child_envelope_sub_145 ?_ + intro b hb + exact common_sub_145 (mem_commonEnvelope childrenD_145 b hb) +def required_147 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_147 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_147 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), (placed21 0 (2, 0) required_39)] +def childrenD_147 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), (placed21 0 (2, 0) envelope_39)] +theorem common_sub_147 : commonEnvelope childrenD_147 ⊆ insert (3, 2) required_147 := by decide +kernel +theorem child_required_sub_147 : ∀ j, childrenC_147 j ⊆ insert (3, 2) required_147 := by decide +kernel +theorem child_envelope_sub_147 : ∀ j, childrenD_147 j ⊆ envelope_147 := by decide +kernel +theorem pivot_mem_147 : (3, 2) ∈ envelope_147 := by decide +kernel +theorem children_work_147 : ∀ j, Template HasSnaky 4 (childrenC_147 j) (childrenD_147 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_39 0 (2, 0)).mono (by decide +kernel) +theorem row_works_147 : Template HasSnaky 5 required_147 envelope_147 := by + refine compose HasSnaky 4 childrenC_147 childrenD_147 children_work_147 (3, 2) + required_147 envelope_147 pivot_mem_147 child_required_sub_147 child_envelope_sub_147 ?_ + intro b hb + exact common_sub_147 (mem_commonEnvelope childrenD_147 b hb) +def required_152 : Finset Cell := ⟨(([(1, 1), (1, 3), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_152 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (4, 2), (4, 3), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_152 : Fin 2 → Finset Cell := ![(placed21 4 (1, 3) required_5), (placed21 2 (4, 0) required_99)] +def childrenD_152 : Fin 2 → Finset Cell := ![(placed21 4 (1, 3) envelope_5), (placed21 2 (4, 0) envelope_99)] +theorem common_sub_152 : commonEnvelope childrenD_152 ⊆ insert (2, 3) required_152 := by decide +kernel +theorem child_required_sub_152 : ∀ j, childrenC_152 j ⊆ insert (2, 3) required_152 := by decide +kernel +theorem child_envelope_sub_152 : ∀ j, childrenD_152 j ⊆ envelope_152 := by decide +kernel +theorem pivot_mem_152 : (2, 3) ∈ envelope_152 := by decide +kernel +theorem children_work_152 : ∀ j, Template HasSnaky 4 (childrenC_152 j) (childrenD_152 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_99 2 (4, 0)).mono (by decide +kernel) +theorem row_works_152 : Template HasSnaky 5 required_152 envelope_152 := by + refine compose HasSnaky 4 childrenC_152 childrenD_152 children_work_152 (2, 3) + required_152 envelope_152 pivot_mem_152 child_required_sub_152 child_envelope_sub_152 ?_ + intro b hb + exact common_sub_152 (mem_commonEnvelope childrenD_152 b hb) +def required_155 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_155 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_155 : Fin 3 → Finset Cell := ![(placed21 3 (0, 2) required_7), (placed21 1 (0, 1) required_9), (placed21 0 (1, 0) required_46)] +def childrenD_155 : Fin 3 → Finset Cell := ![(placed21 3 (0, 2) envelope_7), (placed21 1 (0, 1) envelope_9), (placed21 0 (1, 0) envelope_46)] +theorem common_sub_155 : commonEnvelope childrenD_155 ⊆ insert (4, 2) required_155 := by decide +kernel +theorem child_required_sub_155 : ∀ j, childrenC_155 j ⊆ insert (4, 2) required_155 := by decide +kernel +theorem child_envelope_sub_155 : ∀ j, childrenD_155 j ⊆ envelope_155 := by decide +kernel +theorem pivot_mem_155 : (4, 2) ∈ envelope_155 := by decide +kernel +theorem children_work_155 : ∀ j, Template HasSnaky 4 (childrenC_155 j) (childrenD_155 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 3 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_46 0 (1, 0)).mono (by decide +kernel) +theorem row_works_155 : Template HasSnaky 5 required_155 envelope_155 := by + refine compose HasSnaky 4 childrenC_155 childrenD_155 children_work_155 (4, 2) + required_155 envelope_155 pivot_mem_155 child_required_sub_155 child_envelope_sub_155 ?_ + intro b hb + exact common_sub_155 (mem_commonEnvelope childrenD_155 b hb) +def required_164 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_164 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_164 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_0), required_55] +def childrenD_164 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_0), envelope_55] +theorem common_sub_164 : commonEnvelope childrenD_164 ⊆ insert (3, 3) required_164 := by decide +kernel +theorem child_required_sub_164 : ∀ j, childrenC_164 j ⊆ insert (3, 3) required_164 := by decide +kernel +theorem child_envelope_sub_164 : ∀ j, childrenD_164 j ⊆ envelope_164 := by decide +kernel +theorem pivot_mem_164 : (3, 3) ∈ envelope_164 := by decide +kernel +theorem children_work_164 : ∀ j, Template HasSnaky 4 (childrenC_164 j) (childrenD_164 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact row_works_55.mono (by decide +kernel) +theorem row_works_164 : Template HasSnaky 5 required_164 envelope_164 := by + refine compose HasSnaky 4 childrenC_164 childrenD_164 children_work_164 (3, 3) + required_164 envelope_164 pivot_mem_164 child_required_sub_164 child_envelope_sub_164 ?_ + intro b hb + exact common_sub_164 (mem_commonEnvelope childrenD_164 b hb) +def required_175 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (2, 4), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_175 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 4), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_175 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) required_7), (placed21 1 (0, 2) required_32), (placed21 4 (0, 6) required_60)] +def childrenD_175 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) envelope_7), (placed21 1 (0, 2) envelope_32), (placed21 4 (0, 6) envelope_60)] +theorem common_sub_175 : commonEnvelope childrenD_175 ⊆ insert (1, 5) required_175 := by decide +kernel +theorem child_required_sub_175 : ∀ j, childrenC_175 j ⊆ insert (1, 5) required_175 := by decide +kernel +theorem child_envelope_sub_175 : ∀ j, childrenD_175 j ⊆ envelope_175 := by decide +kernel +theorem pivot_mem_175 : (1, 5) ∈ envelope_175 := by decide +kernel +theorem children_work_175 : ∀ j, Template HasSnaky 4 (childrenC_175 j) (childrenD_175 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_32 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_60 4 (0, 6)).mono (by decide +kernel) +theorem row_works_175 : Template HasSnaky 5 required_175 envelope_175 := by + refine compose HasSnaky 4 childrenC_175 childrenD_175 children_work_175 (1, 5) + required_175 envelope_175 pivot_mem_175 child_required_sub_175 child_envelope_sub_175 ?_ + intro b hb + exact common_sub_175 (mem_commonEnvelope childrenD_175 b hb) +def required_176 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_176 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_176 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_0), (placed21 2 (4, 0) required_60)] +def childrenD_176 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_0), (placed21 2 (4, 0) envelope_60)] +theorem common_sub_176 : commonEnvelope childrenD_176 ⊆ insert (2, 2) required_176 := by decide +kernel +theorem child_required_sub_176 : ∀ j, childrenC_176 j ⊆ insert (2, 2) required_176 := by decide +kernel +theorem child_envelope_sub_176 : ∀ j, childrenD_176 j ⊆ envelope_176 := by decide +kernel +theorem pivot_mem_176 : (2, 2) ∈ envelope_176 := by decide +kernel +theorem children_work_176 : ∀ j, Template HasSnaky 4 (childrenC_176 j) (childrenD_176 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_60 2 (4, 0)).mono (by decide +kernel) +theorem row_works_176 : Template HasSnaky 5 required_176 envelope_176 := by + refine compose HasSnaky 4 childrenC_176 childrenD_176 children_work_176 (2, 2) + required_176 envelope_176 pivot_mem_176 child_required_sub_176 child_envelope_sub_176 ?_ + intro b hb + exact common_sub_176 (mem_commonEnvelope childrenD_176 b hb) +def required_179 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_179 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (3, 2), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_179 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_5), required_178] +def childrenD_179 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_5), envelope_178] +theorem common_sub_179 : commonEnvelope childrenD_179 ⊆ insert (1, 3) required_179 := by decide +kernel +theorem child_required_sub_179 : ∀ j, childrenC_179 j ⊆ insert (1, 3) required_179 := by decide +kernel +theorem child_envelope_sub_179 : ∀ j, childrenD_179 j ⊆ envelope_179 := by decide +kernel +theorem pivot_mem_179 : (1, 3) ∈ envelope_179 := by decide +kernel +theorem children_work_179 : ∀ j, Template HasSnaky 4 (childrenC_179 j) (childrenD_179 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact row_works_178.mono (by decide +kernel) +theorem row_works_179 : Template HasSnaky 5 required_179 envelope_179 := by + refine compose HasSnaky 4 childrenC_179 childrenD_179 children_work_179 (1, 3) + required_179 envelope_179 pivot_mem_179 child_required_sub_179 child_envelope_sub_179 ?_ + intro b hb + exact common_sub_179 (mem_commonEnvelope childrenD_179 b hb) +def height_19 : ℕ := 5 +def childrenH_19 : Fin 2 → ℕ := ![height_5, height_18] +theorem height_exact_19 : height_19 = 1 + Finset.univ.sup childrenH_19 := by decide +kernel +theorem required_origin_19 : ∀ x ∈ required_19, + (∃ j, x ∈ childrenC_19 j) ∨ ∀ j, x ∈ childrenD_19 j := by decide +kernel +theorem required_exact_19 : required_19 = + ((Finset.univ.biUnion childrenC_19) ∪ commonEnvelope childrenD_19).erase (0, 1) := by + exact required_eq_combination childrenC_19 childrenD_19 (0, 1) required_19 + (by decide +kernel) child_required_sub_19 common_sub_19 required_origin_19 +theorem envelope_origin_19 : ∀ x ∈ envelope_19, + x = (0, 1) ∨ ∃ j, x ∈ childrenD_19 j := by decide +kernel +theorem envelope_exact_19 : envelope_19 = + insert (0, 1) (Finset.univ.biUnion childrenD_19) := by + exact envelope_eq_combination childrenD_19 (0, 1) envelope_19 + pivot_mem_19 child_envelope_sub_19 envelope_origin_19 +def checked_19 : CheckedCard where + required := required_19 + envelope := envelope_19 + height := height_19 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_19 +def height_47 : ℕ := 5 +def childrenH_47 : Fin 3 → ℕ := ![height_7, height_9, height_46] +theorem height_exact_47 : height_47 = 1 + Finset.univ.sup childrenH_47 := by decide +kernel +theorem required_origin_47 : ∀ x ∈ required_47, + (∃ j, x ∈ childrenC_47 j) ∨ ∀ j, x ∈ childrenD_47 j := by decide +kernel +theorem required_exact_47 : required_47 = + ((Finset.univ.biUnion childrenC_47) ∪ commonEnvelope childrenD_47).erase (4, 2) := by + exact required_eq_combination childrenC_47 childrenD_47 (4, 2) required_47 + (by decide +kernel) child_required_sub_47 common_sub_47 required_origin_47 +theorem envelope_origin_47 : ∀ x ∈ envelope_47, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_47 j := by decide +kernel +theorem envelope_exact_47 : envelope_47 = + insert (4, 2) (Finset.univ.biUnion childrenD_47) := by + exact envelope_eq_combination childrenD_47 (4, 2) envelope_47 + pivot_mem_47 child_envelope_sub_47 envelope_origin_47 +def checked_47 : CheckedCard where + required := required_47 + envelope := envelope_47 + height := height_47 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_47 +def height_59 : ℕ := 5 +def childrenH_59 : Fin 3 → ℕ := ![height_28, height_31, height_58] +theorem height_exact_59 : height_59 = 1 + Finset.univ.sup childrenH_59 := by decide +kernel +theorem required_origin_59 : ∀ x ∈ required_59, + (∃ j, x ∈ childrenC_59 j) ∨ ∀ j, x ∈ childrenD_59 j := by decide +kernel +theorem required_exact_59 : required_59 = + ((Finset.univ.biUnion childrenC_59) ∪ commonEnvelope childrenD_59).erase (3, 2) := by + exact required_eq_combination childrenC_59 childrenD_59 (3, 2) required_59 + (by decide +kernel) child_required_sub_59 common_sub_59 required_origin_59 +theorem envelope_origin_59 : ∀ x ∈ envelope_59, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_59 j := by decide +kernel +theorem envelope_exact_59 : envelope_59 = + insert (3, 2) (Finset.univ.biUnion childrenD_59) := by + exact envelope_eq_combination childrenD_59 (3, 2) envelope_59 + pivot_mem_59 child_envelope_sub_59 envelope_origin_59 +def checked_59 : CheckedCard where + required := required_59 + envelope := envelope_59 + height := height_59 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_59 +def height_71 : ℕ := 5 +def childrenH_71 : Fin 2 → ℕ := ![height_0, height_10] +theorem height_exact_71 : height_71 = 1 + Finset.univ.sup childrenH_71 := by decide +kernel +theorem required_origin_71 : ∀ x ∈ required_71, + (∃ j, x ∈ childrenC_71 j) ∨ ∀ j, x ∈ childrenD_71 j := by decide +kernel +theorem required_exact_71 : required_71 = + ((Finset.univ.biUnion childrenC_71) ∪ commonEnvelope childrenD_71).erase (2, 1) := by + exact required_eq_combination childrenC_71 childrenD_71 (2, 1) required_71 + (by decide +kernel) child_required_sub_71 common_sub_71 required_origin_71 +theorem envelope_origin_71 : ∀ x ∈ envelope_71, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_71 j := by decide +kernel +theorem envelope_exact_71 : envelope_71 = + insert (2, 1) (Finset.univ.biUnion childrenD_71) := by + exact envelope_eq_combination childrenD_71 (2, 1) envelope_71 + pivot_mem_71 child_envelope_sub_71 envelope_origin_71 +def checked_71 : CheckedCard where + required := required_71 + envelope := envelope_71 + height := height_71 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_71 +def height_72 : ℕ := 5 +def childrenH_72 : Fin 3 → ℕ := ![height_20, height_29, height_46] +theorem height_exact_72 : height_72 = 1 + Finset.univ.sup childrenH_72 := by decide +kernel +theorem required_origin_72 : ∀ x ∈ required_72, + (∃ j, x ∈ childrenC_72 j) ∨ ∀ j, x ∈ childrenD_72 j := by decide +kernel +theorem required_exact_72 : required_72 = + ((Finset.univ.biUnion childrenC_72) ∪ commonEnvelope childrenD_72).erase (3, 2) := by + exact required_eq_combination childrenC_72 childrenD_72 (3, 2) required_72 + (by decide +kernel) child_required_sub_72 common_sub_72 required_origin_72 +theorem envelope_origin_72 : ∀ x ∈ envelope_72, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_72 j := by decide +kernel +theorem envelope_exact_72 : envelope_72 = + insert (3, 2) (Finset.univ.biUnion childrenD_72) := by + exact envelope_eq_combination childrenD_72 (3, 2) envelope_72 + pivot_mem_72 child_envelope_sub_72 envelope_origin_72 +def checked_72 : CheckedCard where + required := required_72 + envelope := envelope_72 + height := height_72 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_72 +def height_81 : ℕ := 5 +def childrenH_81 : Fin 2 → ℕ := ![height_5, height_42] +theorem height_exact_81 : height_81 = 1 + Finset.univ.sup childrenH_81 := by decide +kernel +theorem required_origin_81 : ∀ x ∈ required_81, + (∃ j, x ∈ childrenC_81 j) ∨ ∀ j, x ∈ childrenD_81 j := by decide +kernel +theorem required_exact_81 : required_81 = + ((Finset.univ.biUnion childrenC_81) ∪ commonEnvelope childrenD_81).erase (3, 2) := by + exact required_eq_combination childrenC_81 childrenD_81 (3, 2) required_81 + (by decide +kernel) child_required_sub_81 common_sub_81 required_origin_81 +theorem envelope_origin_81 : ∀ x ∈ envelope_81, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_81 j := by decide +kernel +theorem envelope_exact_81 : envelope_81 = + insert (3, 2) (Finset.univ.biUnion childrenD_81) := by + exact envelope_eq_combination childrenD_81 (3, 2) envelope_81 + pivot_mem_81 child_envelope_sub_81 envelope_origin_81 +def checked_81 : CheckedCard where + required := required_81 + envelope := envelope_81 + height := height_81 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_81 +def height_84 : ℕ := 5 +def childrenH_84 : Fin 2 → ℕ := ![height_6, height_17] +theorem height_exact_84 : height_84 = 1 + Finset.univ.sup childrenH_84 := by decide +kernel +theorem required_origin_84 : ∀ x ∈ required_84, + (∃ j, x ∈ childrenC_84 j) ∨ ∀ j, x ∈ childrenD_84 j := by decide +kernel +theorem required_exact_84 : required_84 = + ((Finset.univ.biUnion childrenC_84) ∪ commonEnvelope childrenD_84).erase (1, 5) := by + exact required_eq_combination childrenC_84 childrenD_84 (1, 5) required_84 + (by decide +kernel) child_required_sub_84 common_sub_84 required_origin_84 +theorem envelope_origin_84 : ∀ x ∈ envelope_84, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_84 j := by decide +kernel +theorem envelope_exact_84 : envelope_84 = + insert (1, 5) (Finset.univ.biUnion childrenD_84) := by + exact envelope_eq_combination childrenD_84 (1, 5) envelope_84 + pivot_mem_84 child_envelope_sub_84 envelope_origin_84 +def checked_84 : CheckedCard where + required := required_84 + envelope := envelope_84 + height := height_84 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_84 +def height_100 : ℕ := 5 +def childrenH_100 : Fin 2 → ℕ := ![height_2, height_10] +theorem height_exact_100 : height_100 = 1 + Finset.univ.sup childrenH_100 := by decide +kernel +theorem required_origin_100 : ∀ x ∈ required_100, + (∃ j, x ∈ childrenC_100 j) ∨ ∀ j, x ∈ childrenD_100 j := by decide +kernel +theorem required_exact_100 : required_100 = + ((Finset.univ.biUnion childrenC_100) ∪ commonEnvelope childrenD_100).erase (4, 1) := by + exact required_eq_combination childrenC_100 childrenD_100 (4, 1) required_100 + (by decide +kernel) child_required_sub_100 common_sub_100 required_origin_100 +theorem envelope_origin_100 : ∀ x ∈ envelope_100, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_100 j := by decide +kernel +theorem envelope_exact_100 : envelope_100 = + insert (4, 1) (Finset.univ.biUnion childrenD_100) := by + exact envelope_eq_combination childrenD_100 (4, 1) envelope_100 + pivot_mem_100 child_envelope_sub_100 envelope_origin_100 +def checked_100 : CheckedCard where + required := required_100 + envelope := envelope_100 + height := height_100 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_100 +def height_104 : ℕ := 5 +def childrenH_104 : Fin 4 → ℕ := ![height_10, height_10, height_52, height_52] +theorem height_exact_104 : height_104 = 1 + Finset.univ.sup childrenH_104 := by decide +kernel +theorem required_origin_104 : ∀ x ∈ required_104, + (∃ j, x ∈ childrenC_104 j) ∨ ∀ j, x ∈ childrenD_104 j := by decide +kernel +theorem required_exact_104 : required_104 = + ((Finset.univ.biUnion childrenC_104) ∪ commonEnvelope childrenD_104).erase (1, 4) := by + exact required_eq_combination childrenC_104 childrenD_104 (1, 4) required_104 + (by decide +kernel) child_required_sub_104 common_sub_104 required_origin_104 +theorem envelope_origin_104 : ∀ x ∈ envelope_104, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_104 j := by decide +kernel +theorem envelope_exact_104 : envelope_104 = + insert (1, 4) (Finset.univ.biUnion childrenD_104) := by + exact envelope_eq_combination childrenD_104 (1, 4) envelope_104 + pivot_mem_104 child_envelope_sub_104 envelope_origin_104 +def checked_104 : CheckedCard where + required := required_104 + envelope := envelope_104 + height := height_104 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_104 +def height_107 : ℕ := 5 +def childrenH_107 : Fin 2 → ℕ := ![height_3, height_18] +theorem height_exact_107 : height_107 = 1 + Finset.univ.sup childrenH_107 := by decide +kernel +theorem required_origin_107 : ∀ x ∈ required_107, + (∃ j, x ∈ childrenC_107 j) ∨ ∀ j, x ∈ childrenD_107 j := by decide +kernel +theorem required_exact_107 : required_107 = + ((Finset.univ.biUnion childrenC_107) ∪ commonEnvelope childrenD_107).erase (1, 2) := by + exact required_eq_combination childrenC_107 childrenD_107 (1, 2) required_107 + (by decide +kernel) child_required_sub_107 common_sub_107 required_origin_107 +theorem envelope_origin_107 : ∀ x ∈ envelope_107, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_107 j := by decide +kernel +theorem envelope_exact_107 : envelope_107 = + insert (1, 2) (Finset.univ.biUnion childrenD_107) := by + exact envelope_eq_combination childrenD_107 (1, 2) envelope_107 + pivot_mem_107 child_envelope_sub_107 envelope_origin_107 +def checked_107 : CheckedCard where + required := required_107 + envelope := envelope_107 + height := height_107 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_107 +def height_111 : ℕ := 5 +def childrenH_111 : Fin 2 → ℕ := ![height_17, height_55] +theorem height_exact_111 : height_111 = 1 + Finset.univ.sup childrenH_111 := by decide +kernel +theorem required_origin_111 : ∀ x ∈ required_111, + (∃ j, x ∈ childrenC_111 j) ∨ ∀ j, x ∈ childrenD_111 j := by decide +kernel +theorem required_exact_111 : required_111 = + ((Finset.univ.biUnion childrenC_111) ∪ commonEnvelope childrenD_111).erase (4, 3) := by + exact required_eq_combination childrenC_111 childrenD_111 (4, 3) required_111 + (by decide +kernel) child_required_sub_111 common_sub_111 required_origin_111 +theorem envelope_origin_111 : ∀ x ∈ envelope_111, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_111 j := by decide +kernel +theorem envelope_exact_111 : envelope_111 = + insert (4, 3) (Finset.univ.biUnion childrenD_111) := by + exact envelope_eq_combination childrenD_111 (4, 3) envelope_111 + pivot_mem_111 child_envelope_sub_111 envelope_origin_111 +def checked_111 : CheckedCard where + required := required_111 + envelope := envelope_111 + height := height_111 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_111 +def height_114 : ℕ := 5 +def childrenH_114 : Fin 2 → ℕ := ![height_5, height_14] +theorem height_exact_114 : height_114 = 1 + Finset.univ.sup childrenH_114 := by decide +kernel +theorem required_origin_114 : ∀ x ∈ required_114, + (∃ j, x ∈ childrenC_114 j) ∨ ∀ j, x ∈ childrenD_114 j := by decide +kernel +theorem required_exact_114 : required_114 = + ((Finset.univ.biUnion childrenC_114) ∪ commonEnvelope childrenD_114).erase (3, 4) := by + exact required_eq_combination childrenC_114 childrenD_114 (3, 4) required_114 + (by decide +kernel) child_required_sub_114 common_sub_114 required_origin_114 +theorem envelope_origin_114 : ∀ x ∈ envelope_114, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_114 j := by decide +kernel +theorem envelope_exact_114 : envelope_114 = + insert (3, 4) (Finset.univ.biUnion childrenD_114) := by + exact envelope_eq_combination childrenD_114 (3, 4) envelope_114 + pivot_mem_114 child_envelope_sub_114 envelope_origin_114 +def checked_114 : CheckedCard where + required := required_114 + envelope := envelope_114 + height := height_114 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_114 +def height_122 : ℕ := 5 +def childrenH_122 : Fin 2 → ℕ := ![height_8, height_46] +theorem height_exact_122 : height_122 = 1 + Finset.univ.sup childrenH_122 := by decide +kernel +theorem required_origin_122 : ∀ x ∈ required_122, + (∃ j, x ∈ childrenC_122 j) ∨ ∀ j, x ∈ childrenD_122 j := by decide +kernel +theorem required_exact_122 : required_122 = + ((Finset.univ.biUnion childrenC_122) ∪ commonEnvelope childrenD_122).erase (2, 4) := by + exact required_eq_combination childrenC_122 childrenD_122 (2, 4) required_122 + (by decide +kernel) child_required_sub_122 common_sub_122 required_origin_122 +theorem envelope_origin_122 : ∀ x ∈ envelope_122, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_122 j := by decide +kernel +theorem envelope_exact_122 : envelope_122 = + insert (2, 4) (Finset.univ.biUnion childrenD_122) := by + exact envelope_eq_combination childrenD_122 (2, 4) envelope_122 + pivot_mem_122 child_envelope_sub_122 envelope_origin_122 +def checked_122 : CheckedCard where + required := required_122 + envelope := envelope_122 + height := height_122 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_122 +def height_133 : ℕ := 5 +def childrenH_133 : Fin 2 → ℕ := ![height_5, height_132] +theorem height_exact_133 : height_133 = 1 + Finset.univ.sup childrenH_133 := by decide +kernel +theorem required_origin_133 : ∀ x ∈ required_133, + (∃ j, x ∈ childrenC_133 j) ∨ ∀ j, x ∈ childrenD_133 j := by decide +kernel +theorem required_exact_133 : required_133 = + ((Finset.univ.biUnion childrenC_133) ∪ commonEnvelope childrenD_133).erase (1, 1) := by + exact required_eq_combination childrenC_133 childrenD_133 (1, 1) required_133 + (by decide +kernel) child_required_sub_133 common_sub_133 required_origin_133 +theorem envelope_origin_133 : ∀ x ∈ envelope_133, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_133 j := by decide +kernel +theorem envelope_exact_133 : envelope_133 = + insert (1, 1) (Finset.univ.biUnion childrenD_133) := by + exact envelope_eq_combination childrenD_133 (1, 1) envelope_133 + pivot_mem_133 child_envelope_sub_133 envelope_origin_133 +def checked_133 : CheckedCard where + required := required_133 + envelope := envelope_133 + height := height_133 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_133 +def height_142 : ℕ := 5 +def childrenH_142 : Fin 2 → ℕ := ![height_5, height_141] +theorem height_exact_142 : height_142 = 1 + Finset.univ.sup childrenH_142 := by decide +kernel +theorem required_origin_142 : ∀ x ∈ required_142, + (∃ j, x ∈ childrenC_142 j) ∨ ∀ j, x ∈ childrenD_142 j := by decide +kernel +theorem required_exact_142 : required_142 = + ((Finset.univ.biUnion childrenC_142) ∪ commonEnvelope childrenD_142).erase (1, 2) := by + exact required_eq_combination childrenC_142 childrenD_142 (1, 2) required_142 + (by decide +kernel) child_required_sub_142 common_sub_142 required_origin_142 +theorem envelope_origin_142 : ∀ x ∈ envelope_142, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_142 j := by decide +kernel +theorem envelope_exact_142 : envelope_142 = + insert (1, 2) (Finset.univ.biUnion childrenD_142) := by + exact envelope_eq_combination childrenD_142 (1, 2) envelope_142 + pivot_mem_142 child_envelope_sub_142 envelope_origin_142 +def checked_142 : CheckedCard where + required := required_142 + envelope := envelope_142 + height := height_142 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_142 +def height_144 : ℕ := 5 +def childrenH_144 : Fin 3 → ℕ := ![height_46, height_103, height_143] +theorem height_exact_144 : height_144 = 1 + Finset.univ.sup childrenH_144 := by decide +kernel +theorem required_origin_144 : ∀ x ∈ required_144, + (∃ j, x ∈ childrenC_144 j) ∨ ∀ j, x ∈ childrenD_144 j := by decide +kernel +theorem required_exact_144 : required_144 = + ((Finset.univ.biUnion childrenC_144) ∪ commonEnvelope childrenD_144).erase (3, 2) := by + exact required_eq_combination childrenC_144 childrenD_144 (3, 2) required_144 + (by decide +kernel) child_required_sub_144 common_sub_144 required_origin_144 +theorem envelope_origin_144 : ∀ x ∈ envelope_144, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_144 j := by decide +kernel +theorem envelope_exact_144 : envelope_144 = + insert (3, 2) (Finset.univ.biUnion childrenD_144) := by + exact envelope_eq_combination childrenD_144 (3, 2) envelope_144 + pivot_mem_144 child_envelope_sub_144 envelope_origin_144 +def checked_144 : CheckedCard where + required := required_144 + envelope := envelope_144 + height := height_144 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_144 +def height_145 : ℕ := 5 +def childrenH_145 : Fin 2 → ℕ := ![height_5, height_10] +theorem height_exact_145 : height_145 = 1 + Finset.univ.sup childrenH_145 := by decide +kernel +theorem required_origin_145 : ∀ x ∈ required_145, + (∃ j, x ∈ childrenC_145 j) ∨ ∀ j, x ∈ childrenD_145 j := by decide +kernel +theorem required_exact_145 : required_145 = + ((Finset.univ.biUnion childrenC_145) ∪ commonEnvelope childrenD_145).erase (3, 2) := by + exact required_eq_combination childrenC_145 childrenD_145 (3, 2) required_145 + (by decide +kernel) child_required_sub_145 common_sub_145 required_origin_145 +theorem envelope_origin_145 : ∀ x ∈ envelope_145, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_145 j := by decide +kernel +theorem envelope_exact_145 : envelope_145 = + insert (3, 2) (Finset.univ.biUnion childrenD_145) := by + exact envelope_eq_combination childrenD_145 (3, 2) envelope_145 + pivot_mem_145 child_envelope_sub_145 envelope_origin_145 +def checked_145 : CheckedCard where + required := required_145 + envelope := envelope_145 + height := height_145 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_145 +def height_147 : ℕ := 5 +def childrenH_147 : Fin 2 → ℕ := ![height_5, height_39] +theorem height_exact_147 : height_147 = 1 + Finset.univ.sup childrenH_147 := by decide +kernel +theorem required_origin_147 : ∀ x ∈ required_147, + (∃ j, x ∈ childrenC_147 j) ∨ ∀ j, x ∈ childrenD_147 j := by decide +kernel +theorem required_exact_147 : required_147 = + ((Finset.univ.biUnion childrenC_147) ∪ commonEnvelope childrenD_147).erase (3, 2) := by + exact required_eq_combination childrenC_147 childrenD_147 (3, 2) required_147 + (by decide +kernel) child_required_sub_147 common_sub_147 required_origin_147 +theorem envelope_origin_147 : ∀ x ∈ envelope_147, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_147 j := by decide +kernel +theorem envelope_exact_147 : envelope_147 = + insert (3, 2) (Finset.univ.biUnion childrenD_147) := by + exact envelope_eq_combination childrenD_147 (3, 2) envelope_147 + pivot_mem_147 child_envelope_sub_147 envelope_origin_147 +def checked_147 : CheckedCard where + required := required_147 + envelope := envelope_147 + height := height_147 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_147 +def height_152 : ℕ := 5 +def childrenH_152 : Fin 2 → ℕ := ![height_5, height_99] +theorem height_exact_152 : height_152 = 1 + Finset.univ.sup childrenH_152 := by decide +kernel +theorem required_origin_152 : ∀ x ∈ required_152, + (∃ j, x ∈ childrenC_152 j) ∨ ∀ j, x ∈ childrenD_152 j := by decide +kernel +theorem required_exact_152 : required_152 = + ((Finset.univ.biUnion childrenC_152) ∪ commonEnvelope childrenD_152).erase (2, 3) := by + exact required_eq_combination childrenC_152 childrenD_152 (2, 3) required_152 + (by decide +kernel) child_required_sub_152 common_sub_152 required_origin_152 +theorem envelope_origin_152 : ∀ x ∈ envelope_152, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_152 j := by decide +kernel +theorem envelope_exact_152 : envelope_152 = + insert (2, 3) (Finset.univ.biUnion childrenD_152) := by + exact envelope_eq_combination childrenD_152 (2, 3) envelope_152 + pivot_mem_152 child_envelope_sub_152 envelope_origin_152 +def checked_152 : CheckedCard where + required := required_152 + envelope := envelope_152 + height := height_152 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_152 +def height_155 : ℕ := 5 +def childrenH_155 : Fin 3 → ℕ := ![height_7, height_9, height_46] +theorem height_exact_155 : height_155 = 1 + Finset.univ.sup childrenH_155 := by decide +kernel +theorem required_origin_155 : ∀ x ∈ required_155, + (∃ j, x ∈ childrenC_155 j) ∨ ∀ j, x ∈ childrenD_155 j := by decide +kernel +theorem required_exact_155 : required_155 = + ((Finset.univ.biUnion childrenC_155) ∪ commonEnvelope childrenD_155).erase (4, 2) := by + exact required_eq_combination childrenC_155 childrenD_155 (4, 2) required_155 + (by decide +kernel) child_required_sub_155 common_sub_155 required_origin_155 +theorem envelope_origin_155 : ∀ x ∈ envelope_155, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_155 j := by decide +kernel +theorem envelope_exact_155 : envelope_155 = + insert (4, 2) (Finset.univ.biUnion childrenD_155) := by + exact envelope_eq_combination childrenD_155 (4, 2) envelope_155 + pivot_mem_155 child_envelope_sub_155 envelope_origin_155 +def checked_155 : CheckedCard where + required := required_155 + envelope := envelope_155 + height := height_155 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_155 +def height_164 : ℕ := 5 +def childrenH_164 : Fin 2 → ℕ := ![height_0, height_55] +theorem height_exact_164 : height_164 = 1 + Finset.univ.sup childrenH_164 := by decide +kernel +theorem required_origin_164 : ∀ x ∈ required_164, + (∃ j, x ∈ childrenC_164 j) ∨ ∀ j, x ∈ childrenD_164 j := by decide +kernel +theorem required_exact_164 : required_164 = + ((Finset.univ.biUnion childrenC_164) ∪ commonEnvelope childrenD_164).erase (3, 3) := by + exact required_eq_combination childrenC_164 childrenD_164 (3, 3) required_164 + (by decide +kernel) child_required_sub_164 common_sub_164 required_origin_164 +theorem envelope_origin_164 : ∀ x ∈ envelope_164, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_164 j := by decide +kernel +theorem envelope_exact_164 : envelope_164 = + insert (3, 3) (Finset.univ.biUnion childrenD_164) := by + exact envelope_eq_combination childrenD_164 (3, 3) envelope_164 + pivot_mem_164 child_envelope_sub_164 envelope_origin_164 +def checked_164 : CheckedCard where + required := required_164 + envelope := envelope_164 + height := height_164 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_164 +def height_175 : ℕ := 5 +def childrenH_175 : Fin 3 → ℕ := ![height_7, height_32, height_60] +theorem height_exact_175 : height_175 = 1 + Finset.univ.sup childrenH_175 := by decide +kernel +theorem required_origin_175 : ∀ x ∈ required_175, + (∃ j, x ∈ childrenC_175 j) ∨ ∀ j, x ∈ childrenD_175 j := by decide +kernel +theorem required_exact_175 : required_175 = + ((Finset.univ.biUnion childrenC_175) ∪ commonEnvelope childrenD_175).erase (1, 5) := by + exact required_eq_combination childrenC_175 childrenD_175 (1, 5) required_175 + (by decide +kernel) child_required_sub_175 common_sub_175 required_origin_175 +theorem envelope_origin_175 : ∀ x ∈ envelope_175, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_175 j := by decide +kernel +theorem envelope_exact_175 : envelope_175 = + insert (1, 5) (Finset.univ.biUnion childrenD_175) := by + exact envelope_eq_combination childrenD_175 (1, 5) envelope_175 + pivot_mem_175 child_envelope_sub_175 envelope_origin_175 +def checked_175 : CheckedCard where + required := required_175 + envelope := envelope_175 + height := height_175 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_175 +def height_176 : ℕ := 5 +def childrenH_176 : Fin 2 → ℕ := ![height_0, height_60] +theorem height_exact_176 : height_176 = 1 + Finset.univ.sup childrenH_176 := by decide +kernel +theorem required_origin_176 : ∀ x ∈ required_176, + (∃ j, x ∈ childrenC_176 j) ∨ ∀ j, x ∈ childrenD_176 j := by decide +kernel +theorem required_exact_176 : required_176 = + ((Finset.univ.biUnion childrenC_176) ∪ commonEnvelope childrenD_176).erase (2, 2) := by + exact required_eq_combination childrenC_176 childrenD_176 (2, 2) required_176 + (by decide +kernel) child_required_sub_176 common_sub_176 required_origin_176 +theorem envelope_origin_176 : ∀ x ∈ envelope_176, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_176 j := by decide +kernel +theorem envelope_exact_176 : envelope_176 = + insert (2, 2) (Finset.univ.biUnion childrenD_176) := by + exact envelope_eq_combination childrenD_176 (2, 2) envelope_176 + pivot_mem_176 child_envelope_sub_176 envelope_origin_176 +def checked_176 : CheckedCard where + required := required_176 + envelope := envelope_176 + height := height_176 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_176 +def height_179 : ℕ := 5 +def childrenH_179 : Fin 2 → ℕ := ![height_5, height_178] +theorem height_exact_179 : height_179 = 1 + Finset.univ.sup childrenH_179 := by decide +kernel +theorem required_origin_179 : ∀ x ∈ required_179, + (∃ j, x ∈ childrenC_179 j) ∨ ∀ j, x ∈ childrenD_179 j := by decide +kernel +theorem required_exact_179 : required_179 = + ((Finset.univ.biUnion childrenC_179) ∪ commonEnvelope childrenD_179).erase (1, 3) := by + exact required_eq_combination childrenC_179 childrenD_179 (1, 3) required_179 + (by decide +kernel) child_required_sub_179 common_sub_179 required_origin_179 +theorem envelope_origin_179 : ∀ x ∈ envelope_179, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_179 j := by decide +kernel +theorem envelope_exact_179 : envelope_179 = + insert (1, 3) (Finset.univ.biUnion childrenD_179) := by + exact envelope_eq_combination childrenD_179 (1, 3) envelope_179 + pivot_mem_179 child_envelope_sub_179 envelope_origin_179 +def checked_179 : CheckedCard where + required := required_179 + envelope := envelope_179 + height := height_179 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_179 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part02.lean new file mode 100644 index 0000000..549edad --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part02.lean @@ -0,0 +1,1007 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_183 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_183 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_183 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) required_5), (placed21 2 (5, 0) required_178)] +def childrenD_183 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) envelope_5), (placed21 2 (5, 0) envelope_178)] +theorem common_sub_183 : commonEnvelope childrenD_183 ⊆ insert (4, 2) required_183 := by decide +kernel +theorem child_required_sub_183 : ∀ j, childrenC_183 j ⊆ insert (4, 2) required_183 := by decide +kernel +theorem child_envelope_sub_183 : ∀ j, childrenD_183 j ⊆ envelope_183 := by decide +kernel +theorem pivot_mem_183 : (4, 2) ∈ envelope_183 := by decide +kernel +theorem children_work_183 : ∀ j, Template HasSnaky 4 (childrenC_183 j) (childrenD_183 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_178 2 (5, 0)).mono (by decide +kernel) +theorem row_works_183 : Template HasSnaky 5 required_183 envelope_183 := by + refine compose HasSnaky 4 childrenC_183 childrenD_183 children_work_183 (4, 2) + required_183 envelope_183 pivot_mem_183 child_required_sub_183 child_envelope_sub_183 ?_ + intro b hb + exact common_sub_183 (mem_commonEnvelope childrenD_183 b hb) +def required_186 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_186 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_186 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) required_6), (placed21 0 (1, 0) required_185)] +def childrenD_186 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) envelope_6), (placed21 0 (1, 0) envelope_185)] +theorem common_sub_186 : commonEnvelope childrenD_186 ⊆ insert (1, 1) required_186 := by decide +kernel +theorem child_required_sub_186 : ∀ j, childrenC_186 j ⊆ insert (1, 1) required_186 := by decide +kernel +theorem child_envelope_sub_186 : ∀ j, childrenD_186 j ⊆ envelope_186 := by decide +kernel +theorem pivot_mem_186 : (1, 1) ∈ envelope_186 := by decide +kernel +theorem children_work_186 : ∀ j, Template HasSnaky 4 (childrenC_186 j) (childrenD_186 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_185 0 (1, 0)).mono (by decide +kernel) +theorem row_works_186 : Template HasSnaky 5 required_186 envelope_186 := by + refine compose HasSnaky 4 childrenC_186 childrenD_186 children_work_186 (1, 1) + required_186 envelope_186 pivot_mem_186 child_required_sub_186 child_envelope_sub_186 ?_ + intro b hb + exact common_sub_186 (mem_commonEnvelope childrenD_186 b hb) +def required_187 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_187 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_187 : Fin 3 → Finset Cell := ![(placed21 0 (0, 2) required_6), (placed21 0 (0, 2) required_7), (placed21 4 (0, 7) required_185)] +def childrenD_187 : Fin 3 → Finset Cell := ![(placed21 0 (0, 2) envelope_6), (placed21 0 (0, 2) envelope_7), (placed21 4 (0, 7) envelope_185)] +theorem common_sub_187 : commonEnvelope childrenD_187 ⊆ insert (0, 6) required_187 := by decide +kernel +theorem child_required_sub_187 : ∀ j, childrenC_187 j ⊆ insert (0, 6) required_187 := by decide +kernel +theorem child_envelope_sub_187 : ∀ j, childrenD_187 j ⊆ envelope_187 := by decide +kernel +theorem pivot_mem_187 : (0, 6) ∈ envelope_187 := by decide +kernel +theorem children_work_187 : ∀ j, Template HasSnaky 4 (childrenC_187 j) (childrenD_187 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_7 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_185 4 (0, 7)).mono (by decide +kernel) +theorem row_works_187 : Template HasSnaky 5 required_187 envelope_187 := by + refine compose HasSnaky 4 childrenC_187 childrenD_187 children_work_187 (0, 6) + required_187 envelope_187 pivot_mem_187 child_required_sub_187 child_envelope_sub_187 ?_ + intro b hb + exact common_sub_187 (mem_commonEnvelope childrenD_187 b hb) +def required_191 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_191 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_191 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 0 (0, 1) required_89)] +def childrenD_191 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 0 (0, 1) envelope_89)] +theorem common_sub_191 : commonEnvelope childrenD_191 ⊆ insert (0, 1) required_191 := by decide +kernel +theorem child_required_sub_191 : ∀ j, childrenC_191 j ⊆ insert (0, 1) required_191 := by decide +kernel +theorem child_envelope_sub_191 : ∀ j, childrenD_191 j ⊆ envelope_191 := by decide +kernel +theorem pivot_mem_191 : (0, 1) ∈ envelope_191 := by decide +kernel +theorem children_work_191 : ∀ j, Template HasSnaky 4 (childrenC_191 j) (childrenD_191 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_89 0 (0, 1)).mono (by decide +kernel) +theorem row_works_191 : Template HasSnaky 5 required_191 envelope_191 := by + refine compose HasSnaky 4 childrenC_191 childrenD_191 children_work_191 (0, 1) + required_191 envelope_191 pivot_mem_191 child_required_sub_191 child_envelope_sub_191 ?_ + intro b hb + exact common_sub_191 (mem_commonEnvelope childrenD_191 b hb) +def required_197 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_197 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 0), (6, 1), (6, 2), (7, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_197 : Fin 4 → Finset Cell := ![(placed21 3 (0, 1) required_6), (placed21 0 (1, 0) required_8), (placed21 0 (1, 0) required_26), required_196] +def childrenD_197 : Fin 4 → Finset Cell := ![(placed21 3 (0, 1) envelope_6), (placed21 0 (1, 0) envelope_8), (placed21 0 (1, 0) envelope_26), envelope_196] +theorem common_sub_197 : commonEnvelope childrenD_197 ⊆ insert (4, 1) required_197 := by decide +kernel +theorem child_required_sub_197 : ∀ j, childrenC_197 j ⊆ insert (4, 1) required_197 := by decide +kernel +theorem child_envelope_sub_197 : ∀ j, childrenD_197 j ⊆ envelope_197 := by decide +kernel +theorem pivot_mem_197 : (4, 1) ∈ envelope_197 := by decide +kernel +theorem children_work_197 : ∀ j, Template HasSnaky 4 (childrenC_197 j) (childrenD_197 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_8 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_26 0 (1, 0)).mono (by decide +kernel) + · exact row_works_196.mono (by decide +kernel) +theorem row_works_197 : Template HasSnaky 5 required_197 envelope_197 := by + refine compose HasSnaky 4 childrenC_197 childrenD_197 children_work_197 (4, 1) + required_197 envelope_197 pivot_mem_197 child_required_sub_197 child_envelope_sub_197 ?_ + intro b hb + exact common_sub_197 (mem_commonEnvelope childrenD_197 b hb) +def required_202 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_202 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_202 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), (placed21 2 (3, 0) required_27)] +def childrenD_202 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), (placed21 2 (3, 0) envelope_27)] +theorem common_sub_202 : commonEnvelope childrenD_202 ⊆ insert (3, 2) required_202 := by decide +kernel +theorem child_required_sub_202 : ∀ j, childrenC_202 j ⊆ insert (3, 2) required_202 := by decide +kernel +theorem child_envelope_sub_202 : ∀ j, childrenD_202 j ⊆ envelope_202 := by decide +kernel +theorem pivot_mem_202 : (3, 2) ∈ envelope_202 := by decide +kernel +theorem children_work_202 : ∀ j, Template HasSnaky 4 (childrenC_202 j) (childrenD_202 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_27 2 (3, 0)).mono (by decide +kernel) +theorem row_works_202 : Template HasSnaky 5 required_202 envelope_202 := by + refine compose HasSnaky 4 childrenC_202 childrenD_202 children_work_202 (3, 2) + required_202 envelope_202 pivot_mem_202 child_required_sub_202 child_envelope_sub_202 ?_ + intro b hb + exact common_sub_202 (mem_commonEnvelope childrenD_202 b hb) +def required_211 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_211 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_211 : Fin 3 → Finset Cell := ![(placed21 6 (3, 6) required_7), (placed21 1 (2, 2) required_8), (placed21 0 (0, 1) required_151)] +def childrenD_211 : Fin 3 → Finset Cell := ![(placed21 6 (3, 6) envelope_7), (placed21 1 (2, 2) envelope_8), (placed21 0 (0, 1) envelope_151)] +theorem common_sub_211 : commonEnvelope childrenD_211 ⊆ insert (3, 5) required_211 := by decide +kernel +theorem child_required_sub_211 : ∀ j, childrenC_211 j ⊆ insert (3, 5) required_211 := by decide +kernel +theorem child_envelope_sub_211 : ∀ j, childrenD_211 j ⊆ envelope_211 := by decide +kernel +theorem pivot_mem_211 : (3, 5) ∈ envelope_211 := by decide +kernel +theorem children_work_211 : ∀ j, Template HasSnaky 4 (childrenC_211 j) (childrenD_211 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 6 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_151 0 (0, 1)).mono (by decide +kernel) +theorem row_works_211 : Template HasSnaky 5 required_211 envelope_211 := by + refine compose HasSnaky 4 childrenC_211 childrenD_211 children_work_211 (3, 5) + required_211 envelope_211 pivot_mem_211 child_required_sub_211 child_envelope_sub_211 ?_ + intro b hb + exact common_sub_211 (mem_commonEnvelope childrenD_211 b hb) +def required_214 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_214 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_214 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_5), (placed21 4 (1, 6) required_213)] +def childrenD_214 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_5), (placed21 4 (1, 6) envelope_213)] +theorem common_sub_214 : commonEnvelope childrenD_214 ⊆ insert (3, 4) required_214 := by decide +kernel +theorem child_required_sub_214 : ∀ j, childrenC_214 j ⊆ insert (3, 4) required_214 := by decide +kernel +theorem child_envelope_sub_214 : ∀ j, childrenD_214 j ⊆ envelope_214 := by decide +kernel +theorem pivot_mem_214 : (3, 4) ∈ envelope_214 := by decide +kernel +theorem children_work_214 : ∀ j, Template HasSnaky 4 (childrenC_214 j) (childrenD_214 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_213 4 (1, 6)).mono (by decide +kernel) +theorem row_works_214 : Template HasSnaky 5 required_214 envelope_214 := by + refine compose HasSnaky 4 childrenC_214 childrenD_214 children_work_214 (3, 4) + required_214 envelope_214 pivot_mem_214 child_required_sub_214 child_envelope_sub_214 ?_ + intro b hb + exact common_sub_214 (mem_commonEnvelope childrenD_214 b hb) +def required_225 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_225 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_225 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) required_6), (placed21 5 (2, 2) required_26)] +def childrenD_225 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) envelope_6), (placed21 5 (2, 2) envelope_26)] +theorem common_sub_225 : commonEnvelope childrenD_225 ⊆ insert (1, 5) required_225 := by decide +kernel +theorem child_required_sub_225 : ∀ j, childrenC_225 j ⊆ insert (1, 5) required_225 := by decide +kernel +theorem child_envelope_sub_225 : ∀ j, childrenD_225 j ⊆ envelope_225 := by decide +kernel +theorem pivot_mem_225 : (1, 5) ∈ envelope_225 := by decide +kernel +theorem children_work_225 : ∀ j, Template HasSnaky 4 (childrenC_225 j) (childrenD_225 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_26 5 (2, 2)).mono (by decide +kernel) +theorem row_works_225 : Template HasSnaky 5 required_225 envelope_225 := by + refine compose HasSnaky 4 childrenC_225 childrenD_225 children_work_225 (1, 5) + required_225 envelope_225 pivot_mem_225 child_required_sub_225 child_envelope_sub_225 ?_ + intro b hb + exact common_sub_225 (mem_commonEnvelope childrenD_225 b hb) +def required_228 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_228 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_228 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) required_52), (placed21 0 (1, 0) required_227)] +def childrenD_228 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) envelope_52), (placed21 0 (1, 0) envelope_227)] +theorem common_sub_228 : commonEnvelope childrenD_228 ⊆ insert (3, 2) required_228 := by decide +kernel +theorem child_required_sub_228 : ∀ j, childrenC_228 j ⊆ insert (3, 2) required_228 := by decide +kernel +theorem child_envelope_sub_228 : ∀ j, childrenD_228 j ⊆ envelope_228 := by decide +kernel +theorem pivot_mem_228 : (3, 2) ∈ envelope_228 := by decide +kernel +theorem children_work_228 : ∀ j, Template HasSnaky 4 (childrenC_228 j) (childrenD_228 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_227 0 (1, 0)).mono (by decide +kernel) +theorem row_works_228 : Template HasSnaky 5 required_228 envelope_228 := by + refine compose HasSnaky 4 childrenC_228 childrenD_228 children_work_228 (3, 2) + required_228 envelope_228 pivot_mem_228 child_required_sub_228 child_envelope_sub_228 ?_ + intro b hb + exact common_sub_228 (mem_commonEnvelope childrenD_228 b hb) +def required_230 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_230 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_230 : Fin 3 → Finset Cell := ![(placed21 3 (0, 2) required_7), (placed21 1 (0, 1) required_9), (placed21 0 (1, 0) required_229)] +def childrenD_230 : Fin 3 → Finset Cell := ![(placed21 3 (0, 2) envelope_7), (placed21 1 (0, 1) envelope_9), (placed21 0 (1, 0) envelope_229)] +theorem common_sub_230 : commonEnvelope childrenD_230 ⊆ insert (4, 2) required_230 := by decide +kernel +theorem child_required_sub_230 : ∀ j, childrenC_230 j ⊆ insert (4, 2) required_230 := by decide +kernel +theorem child_envelope_sub_230 : ∀ j, childrenD_230 j ⊆ envelope_230 := by decide +kernel +theorem pivot_mem_230 : (4, 2) ∈ envelope_230 := by decide +kernel +theorem children_work_230 : ∀ j, Template HasSnaky 4 (childrenC_230 j) (childrenD_230 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 3 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_229 0 (1, 0)).mono (by decide +kernel) +theorem row_works_230 : Template HasSnaky 5 required_230 envelope_230 := by + refine compose HasSnaky 4 childrenC_230 childrenD_230 children_work_230 (4, 2) + required_230 envelope_230 pivot_mem_230 child_required_sub_230 child_envelope_sub_230 ?_ + intro b hb + exact common_sub_230 (mem_commonEnvelope childrenD_230 b hb) +def required_231 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_231 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_231 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) required_8), (placed21 2 (4, 0) required_55)] +def childrenD_231 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) envelope_8), (placed21 2 (4, 0) envelope_55)] +theorem common_sub_231 : commonEnvelope childrenD_231 ⊆ insert (4, 3) required_231 := by decide +kernel +theorem child_required_sub_231 : ∀ j, childrenC_231 j ⊆ insert (4, 3) required_231 := by decide +kernel +theorem child_envelope_sub_231 : ∀ j, childrenD_231 j ⊆ envelope_231 := by decide +kernel +theorem pivot_mem_231 : (4, 3) ∈ envelope_231 := by decide +kernel +theorem children_work_231 : ∀ j, Template HasSnaky 4 (childrenC_231 j) (childrenD_231 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_55 2 (4, 0)).mono (by decide +kernel) +theorem row_works_231 : Template HasSnaky 5 required_231 envelope_231 := by + refine compose HasSnaky 4 childrenC_231 childrenD_231 children_work_231 (4, 3) + required_231 envelope_231 pivot_mem_231 child_required_sub_231 child_envelope_sub_231 ?_ + intro b hb + exact common_sub_231 (mem_commonEnvelope childrenD_231 b hb) +def required_232 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_232 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_232 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 5 (2, 1) required_26)] +def childrenD_232 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 5 (2, 1) envelope_26)] +theorem common_sub_232 : commonEnvelope childrenD_232 ⊆ insert (1, 4) required_232 := by decide +kernel +theorem child_required_sub_232 : ∀ j, childrenC_232 j ⊆ insert (1, 4) required_232 := by decide +kernel +theorem child_envelope_sub_232 : ∀ j, childrenD_232 j ⊆ envelope_232 := by decide +kernel +theorem pivot_mem_232 : (1, 4) ∈ envelope_232 := by decide +kernel +theorem children_work_232 : ∀ j, Template HasSnaky 4 (childrenC_232 j) (childrenD_232 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_26 5 (2, 1)).mono (by decide +kernel) +theorem row_works_232 : Template HasSnaky 5 required_232 envelope_232 := by + refine compose HasSnaky 4 childrenC_232 childrenD_232 children_work_232 (1, 4) + required_232 envelope_232 pivot_mem_232 child_required_sub_232 child_envelope_sub_232 ?_ + intro b hb + exact common_sub_232 (mem_commonEnvelope childrenD_232 b hb) +def required_233 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_233 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 0), (6, 1), (7, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_233 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_6), (placed21 3 (1, 1) required_27)] +def childrenD_233 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_6), (placed21 3 (1, 1) envelope_27)] +theorem common_sub_233 : commonEnvelope childrenD_233 ⊆ insert (4, 1) required_233 := by decide +kernel +theorem child_required_sub_233 : ∀ j, childrenC_233 j ⊆ insert (4, 1) required_233 := by decide +kernel +theorem child_envelope_sub_233 : ∀ j, childrenD_233 j ⊆ envelope_233 := by decide +kernel +theorem pivot_mem_233 : (4, 1) ∈ envelope_233 := by decide +kernel +theorem children_work_233 : ∀ j, Template HasSnaky 4 (childrenC_233 j) (childrenD_233 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_27 3 (1, 1)).mono (by decide +kernel) +theorem row_works_233 : Template HasSnaky 5 required_233 envelope_233 := by + refine compose HasSnaky 4 childrenC_233 childrenD_233 children_work_233 (4, 1) + required_233 envelope_233 pivot_mem_233 child_required_sub_233 child_envelope_sub_233 ?_ + intro b hb + exact common_sub_233 (mem_commonEnvelope childrenD_233 b hb) +def required_234 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_234 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_234 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 2 (2, 1) required_148)] +def childrenD_234 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 2 (2, 1) envelope_148)] +theorem common_sub_234 : commonEnvelope childrenD_234 ⊆ insert (2, 1) required_234 := by decide +kernel +theorem child_required_sub_234 : ∀ j, childrenC_234 j ⊆ insert (2, 1) required_234 := by decide +kernel +theorem child_envelope_sub_234 : ∀ j, childrenD_234 j ⊆ envelope_234 := by decide +kernel +theorem pivot_mem_234 : (2, 1) ∈ envelope_234 := by decide +kernel +theorem children_work_234 : ∀ j, Template HasSnaky 4 (childrenC_234 j) (childrenD_234 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_148 2 (2, 1)).mono (by decide +kernel) +theorem row_works_234 : Template HasSnaky 5 required_234 envelope_234 := by + refine compose HasSnaky 4 childrenC_234 childrenD_234 children_work_234 (2, 1) + required_234 envelope_234 pivot_mem_234 child_required_sub_234 child_envelope_sub_234 ?_ + intro b hb + exact common_sub_234 (mem_commonEnvelope childrenD_234 b hb) +def required_237 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_237 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 4), (2, 5), (2, 6), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_237 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_0), required_10] +def childrenD_237 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_0), envelope_10] +theorem common_sub_237 : commonEnvelope childrenD_237 ⊆ insert (0, 1) required_237 := by decide +kernel +theorem child_required_sub_237 : ∀ j, childrenC_237 j ⊆ insert (0, 1) required_237 := by decide +kernel +theorem child_envelope_sub_237 : ∀ j, childrenD_237 j ⊆ envelope_237 := by decide +kernel +theorem pivot_mem_237 : (0, 1) ∈ envelope_237 := by decide +kernel +theorem children_work_237 : ∀ j, Template HasSnaky 4 (childrenC_237 j) (childrenD_237 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 2)).mono (by decide +kernel) + · exact row_works_10.mono (by decide +kernel) +theorem row_works_237 : Template HasSnaky 5 required_237 envelope_237 := by + refine compose HasSnaky 4 childrenC_237 childrenD_237 children_work_237 (0, 1) + required_237 envelope_237 pivot_mem_237 child_required_sub_237 child_envelope_sub_237 ?_ + intro b hb + exact common_sub_237 (mem_commonEnvelope childrenD_237 b hb) +def required_241 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_241 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_241 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 2 (2, 1) required_91)] +def childrenD_241 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 2 (2, 1) envelope_91)] +theorem common_sub_241 : commonEnvelope childrenD_241 ⊆ insert (2, 1) required_241 := by decide +kernel +theorem child_required_sub_241 : ∀ j, childrenC_241 j ⊆ insert (2, 1) required_241 := by decide +kernel +theorem child_envelope_sub_241 : ∀ j, childrenD_241 j ⊆ envelope_241 := by decide +kernel +theorem pivot_mem_241 : (2, 1) ∈ envelope_241 := by decide +kernel +theorem children_work_241 : ∀ j, Template HasSnaky 4 (childrenC_241 j) (childrenD_241 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_91 2 (2, 1)).mono (by decide +kernel) +theorem row_works_241 : Template HasSnaky 5 required_241 envelope_241 := by + refine compose HasSnaky 4 childrenC_241 childrenD_241 children_work_241 (2, 1) + required_241 envelope_241 pivot_mem_241 child_required_sub_241 child_envelope_sub_241 ?_ + intro b hb + exact common_sub_241 (mem_commonEnvelope childrenD_241 b hb) +def required_243 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_243 : Finset Cell := ⟨(([(0, 3), (0, 5), (0, 6), (0, 7), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_243 : Fin 2 → Finset Cell := ![(placed21 2 (2, 1) required_10), required_242] +def childrenD_243 : Fin 2 → Finset Cell := ![(placed21 2 (2, 1) envelope_10), envelope_242] +theorem common_sub_243 : commonEnvelope childrenD_243 ⊆ insert (2, 2) required_243 := by decide +kernel +theorem child_required_sub_243 : ∀ j, childrenC_243 j ⊆ insert (2, 2) required_243 := by decide +kernel +theorem child_envelope_sub_243 : ∀ j, childrenD_243 j ⊆ envelope_243 := by decide +kernel +theorem pivot_mem_243 : (2, 2) ∈ envelope_243 := by decide +kernel +theorem children_work_243 : ∀ j, Template HasSnaky 4 (childrenC_243 j) (childrenD_243 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 2 (2, 1)).mono (by decide +kernel) + · exact row_works_242.mono (by decide +kernel) +theorem row_works_243 : Template HasSnaky 5 required_243 envelope_243 := by + refine compose HasSnaky 4 childrenC_243 childrenD_243 children_work_243 (2, 2) + required_243 envelope_243 pivot_mem_243 child_required_sub_243 child_envelope_sub_243 ?_ + intro b hb + exact common_sub_243 (mem_commonEnvelope childrenD_243 b hb) +def required_249 : Finset Cell := ⟨(([(0, 1), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_249 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_249 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_17), (placed21 7 (4, 4) required_35)] +def childrenD_249 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_17), (placed21 7 (4, 4) envelope_35)] +theorem common_sub_249 : commonEnvelope childrenD_249 ⊆ insert (4, 2) required_249 := by decide +kernel +theorem child_required_sub_249 : ∀ j, childrenC_249 j ⊆ insert (4, 2) required_249 := by decide +kernel +theorem child_envelope_sub_249 : ∀ j, childrenD_249 j ⊆ envelope_249 := by decide +kernel +theorem pivot_mem_249 : (4, 2) ∈ envelope_249 := by decide +kernel +theorem children_work_249 : ∀ j, Template HasSnaky 4 (childrenC_249 j) (childrenD_249 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_17 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_35 7 (4, 4)).mono (by decide +kernel) +theorem row_works_249 : Template HasSnaky 5 required_249 envelope_249 := by + refine compose HasSnaky 4 childrenC_249 childrenD_249 children_work_249 (4, 2) + required_249 envelope_249 pivot_mem_249 child_required_sub_249 child_envelope_sub_249 ?_ + intro b hb + exact common_sub_249 (mem_commonEnvelope childrenD_249 b hb) +def required_250 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 4), (1, 1), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_250 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_250 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) required_0), required_195] +def childrenD_250 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) envelope_0), envelope_195] +theorem common_sub_250 : commonEnvelope childrenD_250 ⊆ insert (1, 2) required_250 := by decide +kernel +theorem child_required_sub_250 : ∀ j, childrenC_250 j ⊆ insert (1, 2) required_250 := by decide +kernel +theorem child_envelope_sub_250 : ∀ j, childrenD_250 j ⊆ envelope_250 := by decide +kernel +theorem pivot_mem_250 : (1, 2) ∈ envelope_250 := by decide +kernel +theorem children_work_250 : ∀ j, Template HasSnaky 4 (childrenC_250 j) (childrenD_250 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 5 (1, 0)).mono (by decide +kernel) + · exact row_works_195.mono (by decide +kernel) +theorem row_works_250 : Template HasSnaky 5 required_250 envelope_250 := by + refine compose HasSnaky 4 childrenC_250 childrenD_250 children_work_250 (1, 2) + required_250 envelope_250 pivot_mem_250 child_required_sub_250 child_envelope_sub_250 ?_ + intro b hb + exact common_sub_250 (mem_commonEnvelope childrenD_250 b hb) +def required_252 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_252 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (5, 3), (5, 4), (6, 3), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_252 : Fin 3 → Finset Cell := ![(placed21 4 (0, 6) required_55), (placed21 4 (0, 6) required_56), (placed21 1 (1, 2) required_91)] +def childrenD_252 : Fin 3 → Finset Cell := ![(placed21 4 (0, 6) envelope_55), (placed21 4 (0, 6) envelope_56), (placed21 1 (1, 2) envelope_91)] +theorem common_sub_252 : commonEnvelope childrenD_252 ⊆ insert (2, 4) required_252 := by decide +kernel +theorem child_required_sub_252 : ∀ j, childrenC_252 j ⊆ insert (2, 4) required_252 := by decide +kernel +theorem child_envelope_sub_252 : ∀ j, childrenD_252 j ⊆ envelope_252 := by decide +kernel +theorem pivot_mem_252 : (2, 4) ∈ envelope_252 := by decide +kernel +theorem children_work_252 : ∀ j, Template HasSnaky 4 (childrenC_252 j) (childrenD_252 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_55 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_56 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_91 1 (1, 2)).mono (by decide +kernel) +theorem row_works_252 : Template HasSnaky 5 required_252 envelope_252 := by + refine compose HasSnaky 4 childrenC_252 childrenD_252 children_work_252 (2, 4) + required_252 envelope_252 pivot_mem_252 child_required_sub_252 child_envelope_sub_252 ?_ + intro b hb + exact common_sub_252 (mem_commonEnvelope childrenD_252 b hb) +def required_254 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_254 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_254 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) required_11), required_75, (placed21 6 (1, 5) required_103)] +def childrenD_254 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) envelope_11), envelope_75, (placed21 6 (1, 5) envelope_103)] +theorem common_sub_254 : commonEnvelope childrenD_254 ⊆ insert (1, 5) required_254 := by decide +kernel +theorem child_required_sub_254 : ∀ j, childrenC_254 j ⊆ insert (1, 5) required_254 := by decide +kernel +theorem child_envelope_sub_254 : ∀ j, childrenD_254 j ⊆ envelope_254 := by decide +kernel +theorem pivot_mem_254 : (1, 5) ∈ envelope_254 := by decide +kernel +theorem children_work_254 : ∀ j, Template HasSnaky 4 (childrenC_254 j) (childrenD_254 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 2 (1, 1)).mono (by decide +kernel) + · exact row_works_75.mono (by decide +kernel) + · exact (placed21_template row_works_103 6 (1, 5)).mono (by decide +kernel) +theorem row_works_254 : Template HasSnaky 5 required_254 envelope_254 := by + refine compose HasSnaky 4 childrenC_254 childrenD_254 children_work_254 (1, 5) + required_254 envelope_254 pivot_mem_254 child_required_sub_254 child_envelope_sub_254 ?_ + intro b hb + exact common_sub_254 (mem_commonEnvelope childrenD_254 b hb) +def required_260 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 3), (2, 1), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_260 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 3), (1, 4), (2, 1), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_260 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), (placed21 5 (4, 0) required_208)] +def childrenD_260 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), (placed21 5 (4, 0) envelope_208)] +theorem common_sub_260 : commonEnvelope childrenD_260 ⊆ insert (3, 0) required_260 := by decide +kernel +theorem child_required_sub_260 : ∀ j, childrenC_260 j ⊆ insert (3, 0) required_260 := by decide +kernel +theorem child_envelope_sub_260 : ∀ j, childrenD_260 j ⊆ envelope_260 := by decide +kernel +theorem pivot_mem_260 : (3, 0) ∈ envelope_260 := by decide +kernel +theorem children_work_260 : ∀ j, Template HasSnaky 4 (childrenC_260 j) (childrenD_260 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_208 5 (4, 0)).mono (by decide +kernel) +theorem row_works_260 : Template HasSnaky 5 required_260 envelope_260 := by + refine compose HasSnaky 4 childrenC_260 childrenD_260 children_work_260 (3, 0) + required_260 envelope_260 pivot_mem_260 child_required_sub_260 child_envelope_sub_260 ?_ + intro b hb + exact common_sub_260 (mem_commonEnvelope childrenD_260 b hb) +def required_265 : Finset Cell := ⟨(([(0, 0), (0, 3), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_265 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_265 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_4), (placed21 1 (0, 1) required_93)] +def childrenD_265 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_4), (placed21 1 (0, 1) envelope_93)] +theorem common_sub_265 : commonEnvelope childrenD_265 ⊆ insert (1, 4) required_265 := by decide +kernel +theorem child_required_sub_265 : ∀ j, childrenC_265 j ⊆ insert (1, 4) required_265 := by decide +kernel +theorem child_envelope_sub_265 : ∀ j, childrenD_265 j ⊆ envelope_265 := by decide +kernel +theorem pivot_mem_265 : (1, 4) ∈ envelope_265 := by decide +kernel +theorem children_work_265 : ∀ j, Template HasSnaky 4 (childrenC_265 j) (childrenD_265 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_93 1 (0, 1)).mono (by decide +kernel) +theorem row_works_265 : Template HasSnaky 5 required_265 envelope_265 := by + refine compose HasSnaky 4 childrenC_265 childrenD_265 children_work_265 (1, 4) + required_265 envelope_265 pivot_mem_265 child_required_sub_265 child_envelope_sub_265 ?_ + intro b hb + exact common_sub_265 (mem_commonEnvelope childrenD_265 b hb) +def height_183 : ℕ := 5 +def childrenH_183 : Fin 2 → ℕ := ![height_5, height_178] +theorem height_exact_183 : height_183 = 1 + Finset.univ.sup childrenH_183 := by decide +kernel +theorem required_origin_183 : ∀ x ∈ required_183, + (∃ j, x ∈ childrenC_183 j) ∨ ∀ j, x ∈ childrenD_183 j := by decide +kernel +theorem required_exact_183 : required_183 = + ((Finset.univ.biUnion childrenC_183) ∪ commonEnvelope childrenD_183).erase (4, 2) := by + exact required_eq_combination childrenC_183 childrenD_183 (4, 2) required_183 + (by decide +kernel) child_required_sub_183 common_sub_183 required_origin_183 +theorem envelope_origin_183 : ∀ x ∈ envelope_183, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_183 j := by decide +kernel +theorem envelope_exact_183 : envelope_183 = + insert (4, 2) (Finset.univ.biUnion childrenD_183) := by + exact envelope_eq_combination childrenD_183 (4, 2) envelope_183 + pivot_mem_183 child_envelope_sub_183 envelope_origin_183 +def checked_183 : CheckedCard where + required := required_183 + envelope := envelope_183 + height := height_183 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_183 +def height_186 : ℕ := 5 +def childrenH_186 : Fin 2 → ℕ := ![height_6, height_185] +theorem height_exact_186 : height_186 = 1 + Finset.univ.sup childrenH_186 := by decide +kernel +theorem required_origin_186 : ∀ x ∈ required_186, + (∃ j, x ∈ childrenC_186 j) ∨ ∀ j, x ∈ childrenD_186 j := by decide +kernel +theorem required_exact_186 : required_186 = + ((Finset.univ.biUnion childrenC_186) ∪ commonEnvelope childrenD_186).erase (1, 1) := by + exact required_eq_combination childrenC_186 childrenD_186 (1, 1) required_186 + (by decide +kernel) child_required_sub_186 common_sub_186 required_origin_186 +theorem envelope_origin_186 : ∀ x ∈ envelope_186, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_186 j := by decide +kernel +theorem envelope_exact_186 : envelope_186 = + insert (1, 1) (Finset.univ.biUnion childrenD_186) := by + exact envelope_eq_combination childrenD_186 (1, 1) envelope_186 + pivot_mem_186 child_envelope_sub_186 envelope_origin_186 +def checked_186 : CheckedCard where + required := required_186 + envelope := envelope_186 + height := height_186 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_186 +def height_187 : ℕ := 5 +def childrenH_187 : Fin 3 → ℕ := ![height_6, height_7, height_185] +theorem height_exact_187 : height_187 = 1 + Finset.univ.sup childrenH_187 := by decide +kernel +theorem required_origin_187 : ∀ x ∈ required_187, + (∃ j, x ∈ childrenC_187 j) ∨ ∀ j, x ∈ childrenD_187 j := by decide +kernel +theorem required_exact_187 : required_187 = + ((Finset.univ.biUnion childrenC_187) ∪ commonEnvelope childrenD_187).erase (0, 6) := by + exact required_eq_combination childrenC_187 childrenD_187 (0, 6) required_187 + (by decide +kernel) child_required_sub_187 common_sub_187 required_origin_187 +theorem envelope_origin_187 : ∀ x ∈ envelope_187, + x = (0, 6) ∨ ∃ j, x ∈ childrenD_187 j := by decide +kernel +theorem envelope_exact_187 : envelope_187 = + insert (0, 6) (Finset.univ.biUnion childrenD_187) := by + exact envelope_eq_combination childrenD_187 (0, 6) envelope_187 + pivot_mem_187 child_envelope_sub_187 envelope_origin_187 +def checked_187 : CheckedCard where + required := required_187 + envelope := envelope_187 + height := height_187 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_187 +def height_191 : ℕ := 5 +def childrenH_191 : Fin 2 → ℕ := ![height_5, height_89] +theorem height_exact_191 : height_191 = 1 + Finset.univ.sup childrenH_191 := by decide +kernel +theorem required_origin_191 : ∀ x ∈ required_191, + (∃ j, x ∈ childrenC_191 j) ∨ ∀ j, x ∈ childrenD_191 j := by decide +kernel +theorem required_exact_191 : required_191 = + ((Finset.univ.biUnion childrenC_191) ∪ commonEnvelope childrenD_191).erase (0, 1) := by + exact required_eq_combination childrenC_191 childrenD_191 (0, 1) required_191 + (by decide +kernel) child_required_sub_191 common_sub_191 required_origin_191 +theorem envelope_origin_191 : ∀ x ∈ envelope_191, + x = (0, 1) ∨ ∃ j, x ∈ childrenD_191 j := by decide +kernel +theorem envelope_exact_191 : envelope_191 = + insert (0, 1) (Finset.univ.biUnion childrenD_191) := by + exact envelope_eq_combination childrenD_191 (0, 1) envelope_191 + pivot_mem_191 child_envelope_sub_191 envelope_origin_191 +def checked_191 : CheckedCard where + required := required_191 + envelope := envelope_191 + height := height_191 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_191 +def height_197 : ℕ := 5 +def childrenH_197 : Fin 4 → ℕ := ![height_6, height_8, height_26, height_196] +theorem height_exact_197 : height_197 = 1 + Finset.univ.sup childrenH_197 := by decide +kernel +theorem required_origin_197 : ∀ x ∈ required_197, + (∃ j, x ∈ childrenC_197 j) ∨ ∀ j, x ∈ childrenD_197 j := by decide +kernel +theorem required_exact_197 : required_197 = + ((Finset.univ.biUnion childrenC_197) ∪ commonEnvelope childrenD_197).erase (4, 1) := by + exact required_eq_combination childrenC_197 childrenD_197 (4, 1) required_197 + (by decide +kernel) child_required_sub_197 common_sub_197 required_origin_197 +theorem envelope_origin_197 : ∀ x ∈ envelope_197, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_197 j := by decide +kernel +theorem envelope_exact_197 : envelope_197 = + insert (4, 1) (Finset.univ.biUnion childrenD_197) := by + exact envelope_eq_combination childrenD_197 (4, 1) envelope_197 + pivot_mem_197 child_envelope_sub_197 envelope_origin_197 +def checked_197 : CheckedCard where + required := required_197 + envelope := envelope_197 + height := height_197 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_197 +def height_202 : ℕ := 5 +def childrenH_202 : Fin 2 → ℕ := ![height_5, height_27] +theorem height_exact_202 : height_202 = 1 + Finset.univ.sup childrenH_202 := by decide +kernel +theorem required_origin_202 : ∀ x ∈ required_202, + (∃ j, x ∈ childrenC_202 j) ∨ ∀ j, x ∈ childrenD_202 j := by decide +kernel +theorem required_exact_202 : required_202 = + ((Finset.univ.biUnion childrenC_202) ∪ commonEnvelope childrenD_202).erase (3, 2) := by + exact required_eq_combination childrenC_202 childrenD_202 (3, 2) required_202 + (by decide +kernel) child_required_sub_202 common_sub_202 required_origin_202 +theorem envelope_origin_202 : ∀ x ∈ envelope_202, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_202 j := by decide +kernel +theorem envelope_exact_202 : envelope_202 = + insert (3, 2) (Finset.univ.biUnion childrenD_202) := by + exact envelope_eq_combination childrenD_202 (3, 2) envelope_202 + pivot_mem_202 child_envelope_sub_202 envelope_origin_202 +def checked_202 : CheckedCard where + required := required_202 + envelope := envelope_202 + height := height_202 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_202 +def height_211 : ℕ := 5 +def childrenH_211 : Fin 3 → ℕ := ![height_7, height_8, height_151] +theorem height_exact_211 : height_211 = 1 + Finset.univ.sup childrenH_211 := by decide +kernel +theorem required_origin_211 : ∀ x ∈ required_211, + (∃ j, x ∈ childrenC_211 j) ∨ ∀ j, x ∈ childrenD_211 j := by decide +kernel +theorem required_exact_211 : required_211 = + ((Finset.univ.biUnion childrenC_211) ∪ commonEnvelope childrenD_211).erase (3, 5) := by + exact required_eq_combination childrenC_211 childrenD_211 (3, 5) required_211 + (by decide +kernel) child_required_sub_211 common_sub_211 required_origin_211 +theorem envelope_origin_211 : ∀ x ∈ envelope_211, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_211 j := by decide +kernel +theorem envelope_exact_211 : envelope_211 = + insert (3, 5) (Finset.univ.biUnion childrenD_211) := by + exact envelope_eq_combination childrenD_211 (3, 5) envelope_211 + pivot_mem_211 child_envelope_sub_211 envelope_origin_211 +def checked_211 : CheckedCard where + required := required_211 + envelope := envelope_211 + height := height_211 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_211 +def height_214 : ℕ := 5 +def childrenH_214 : Fin 2 → ℕ := ![height_5, height_213] +theorem height_exact_214 : height_214 = 1 + Finset.univ.sup childrenH_214 := by decide +kernel +theorem required_origin_214 : ∀ x ∈ required_214, + (∃ j, x ∈ childrenC_214 j) ∨ ∀ j, x ∈ childrenD_214 j := by decide +kernel +theorem required_exact_214 : required_214 = + ((Finset.univ.biUnion childrenC_214) ∪ commonEnvelope childrenD_214).erase (3, 4) := by + exact required_eq_combination childrenC_214 childrenD_214 (3, 4) required_214 + (by decide +kernel) child_required_sub_214 common_sub_214 required_origin_214 +theorem envelope_origin_214 : ∀ x ∈ envelope_214, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_214 j := by decide +kernel +theorem envelope_exact_214 : envelope_214 = + insert (3, 4) (Finset.univ.biUnion childrenD_214) := by + exact envelope_eq_combination childrenD_214 (3, 4) envelope_214 + pivot_mem_214 child_envelope_sub_214 envelope_origin_214 +def checked_214 : CheckedCard where + required := required_214 + envelope := envelope_214 + height := height_214 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_214 +def height_225 : ℕ := 5 +def childrenH_225 : Fin 2 → ℕ := ![height_6, height_26] +theorem height_exact_225 : height_225 = 1 + Finset.univ.sup childrenH_225 := by decide +kernel +theorem required_origin_225 : ∀ x ∈ required_225, + (∃ j, x ∈ childrenC_225 j) ∨ ∀ j, x ∈ childrenD_225 j := by decide +kernel +theorem required_exact_225 : required_225 = + ((Finset.univ.biUnion childrenC_225) ∪ commonEnvelope childrenD_225).erase (1, 5) := by + exact required_eq_combination childrenC_225 childrenD_225 (1, 5) required_225 + (by decide +kernel) child_required_sub_225 common_sub_225 required_origin_225 +theorem envelope_origin_225 : ∀ x ∈ envelope_225, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_225 j := by decide +kernel +theorem envelope_exact_225 : envelope_225 = + insert (1, 5) (Finset.univ.biUnion childrenD_225) := by + exact envelope_eq_combination childrenD_225 (1, 5) envelope_225 + pivot_mem_225 child_envelope_sub_225 envelope_origin_225 +def checked_225 : CheckedCard where + required := required_225 + envelope := envelope_225 + height := height_225 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_225 +def height_228 : ℕ := 5 +def childrenH_228 : Fin 2 → ℕ := ![height_52, height_227] +theorem height_exact_228 : height_228 = 1 + Finset.univ.sup childrenH_228 := by decide +kernel +theorem required_origin_228 : ∀ x ∈ required_228, + (∃ j, x ∈ childrenC_228 j) ∨ ∀ j, x ∈ childrenD_228 j := by decide +kernel +theorem required_exact_228 : required_228 = + ((Finset.univ.biUnion childrenC_228) ∪ commonEnvelope childrenD_228).erase (3, 2) := by + exact required_eq_combination childrenC_228 childrenD_228 (3, 2) required_228 + (by decide +kernel) child_required_sub_228 common_sub_228 required_origin_228 +theorem envelope_origin_228 : ∀ x ∈ envelope_228, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_228 j := by decide +kernel +theorem envelope_exact_228 : envelope_228 = + insert (3, 2) (Finset.univ.biUnion childrenD_228) := by + exact envelope_eq_combination childrenD_228 (3, 2) envelope_228 + pivot_mem_228 child_envelope_sub_228 envelope_origin_228 +def checked_228 : CheckedCard where + required := required_228 + envelope := envelope_228 + height := height_228 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_228 +def height_230 : ℕ := 5 +def childrenH_230 : Fin 3 → ℕ := ![height_7, height_9, height_229] +theorem height_exact_230 : height_230 = 1 + Finset.univ.sup childrenH_230 := by decide +kernel +theorem required_origin_230 : ∀ x ∈ required_230, + (∃ j, x ∈ childrenC_230 j) ∨ ∀ j, x ∈ childrenD_230 j := by decide +kernel +theorem required_exact_230 : required_230 = + ((Finset.univ.biUnion childrenC_230) ∪ commonEnvelope childrenD_230).erase (4, 2) := by + exact required_eq_combination childrenC_230 childrenD_230 (4, 2) required_230 + (by decide +kernel) child_required_sub_230 common_sub_230 required_origin_230 +theorem envelope_origin_230 : ∀ x ∈ envelope_230, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_230 j := by decide +kernel +theorem envelope_exact_230 : envelope_230 = + insert (4, 2) (Finset.univ.biUnion childrenD_230) := by + exact envelope_eq_combination childrenD_230 (4, 2) envelope_230 + pivot_mem_230 child_envelope_sub_230 envelope_origin_230 +def checked_230 : CheckedCard where + required := required_230 + envelope := envelope_230 + height := height_230 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_230 +def height_231 : ℕ := 5 +def childrenH_231 : Fin 2 → ℕ := ![height_8, height_55] +theorem height_exact_231 : height_231 = 1 + Finset.univ.sup childrenH_231 := by decide +kernel +theorem required_origin_231 : ∀ x ∈ required_231, + (∃ j, x ∈ childrenC_231 j) ∨ ∀ j, x ∈ childrenD_231 j := by decide +kernel +theorem required_exact_231 : required_231 = + ((Finset.univ.biUnion childrenC_231) ∪ commonEnvelope childrenD_231).erase (4, 3) := by + exact required_eq_combination childrenC_231 childrenD_231 (4, 3) required_231 + (by decide +kernel) child_required_sub_231 common_sub_231 required_origin_231 +theorem envelope_origin_231 : ∀ x ∈ envelope_231, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_231 j := by decide +kernel +theorem envelope_exact_231 : envelope_231 = + insert (4, 3) (Finset.univ.biUnion childrenD_231) := by + exact envelope_eq_combination childrenD_231 (4, 3) envelope_231 + pivot_mem_231 child_envelope_sub_231 envelope_origin_231 +def checked_231 : CheckedCard where + required := required_231 + envelope := envelope_231 + height := height_231 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_231 +def height_232 : ℕ := 5 +def childrenH_232 : Fin 2 → ℕ := ![height_5, height_26] +theorem height_exact_232 : height_232 = 1 + Finset.univ.sup childrenH_232 := by decide +kernel +theorem required_origin_232 : ∀ x ∈ required_232, + (∃ j, x ∈ childrenC_232 j) ∨ ∀ j, x ∈ childrenD_232 j := by decide +kernel +theorem required_exact_232 : required_232 = + ((Finset.univ.biUnion childrenC_232) ∪ commonEnvelope childrenD_232).erase (1, 4) := by + exact required_eq_combination childrenC_232 childrenD_232 (1, 4) required_232 + (by decide +kernel) child_required_sub_232 common_sub_232 required_origin_232 +theorem envelope_origin_232 : ∀ x ∈ envelope_232, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_232 j := by decide +kernel +theorem envelope_exact_232 : envelope_232 = + insert (1, 4) (Finset.univ.biUnion childrenD_232) := by + exact envelope_eq_combination childrenD_232 (1, 4) envelope_232 + pivot_mem_232 child_envelope_sub_232 envelope_origin_232 +def checked_232 : CheckedCard where + required := required_232 + envelope := envelope_232 + height := height_232 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_232 +def height_233 : ℕ := 5 +def childrenH_233 : Fin 2 → ℕ := ![height_6, height_27] +theorem height_exact_233 : height_233 = 1 + Finset.univ.sup childrenH_233 := by decide +kernel +theorem required_origin_233 : ∀ x ∈ required_233, + (∃ j, x ∈ childrenC_233 j) ∨ ∀ j, x ∈ childrenD_233 j := by decide +kernel +theorem required_exact_233 : required_233 = + ((Finset.univ.biUnion childrenC_233) ∪ commonEnvelope childrenD_233).erase (4, 1) := by + exact required_eq_combination childrenC_233 childrenD_233 (4, 1) required_233 + (by decide +kernel) child_required_sub_233 common_sub_233 required_origin_233 +theorem envelope_origin_233 : ∀ x ∈ envelope_233, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_233 j := by decide +kernel +theorem envelope_exact_233 : envelope_233 = + insert (4, 1) (Finset.univ.biUnion childrenD_233) := by + exact envelope_eq_combination childrenD_233 (4, 1) envelope_233 + pivot_mem_233 child_envelope_sub_233 envelope_origin_233 +def checked_233 : CheckedCard where + required := required_233 + envelope := envelope_233 + height := height_233 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_233 +def height_234 : ℕ := 5 +def childrenH_234 : Fin 2 → ℕ := ![height_5, height_148] +theorem height_exact_234 : height_234 = 1 + Finset.univ.sup childrenH_234 := by decide +kernel +theorem required_origin_234 : ∀ x ∈ required_234, + (∃ j, x ∈ childrenC_234 j) ∨ ∀ j, x ∈ childrenD_234 j := by decide +kernel +theorem required_exact_234 : required_234 = + ((Finset.univ.biUnion childrenC_234) ∪ commonEnvelope childrenD_234).erase (2, 1) := by + exact required_eq_combination childrenC_234 childrenD_234 (2, 1) required_234 + (by decide +kernel) child_required_sub_234 common_sub_234 required_origin_234 +theorem envelope_origin_234 : ∀ x ∈ envelope_234, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_234 j := by decide +kernel +theorem envelope_exact_234 : envelope_234 = + insert (2, 1) (Finset.univ.biUnion childrenD_234) := by + exact envelope_eq_combination childrenD_234 (2, 1) envelope_234 + pivot_mem_234 child_envelope_sub_234 envelope_origin_234 +def checked_234 : CheckedCard where + required := required_234 + envelope := envelope_234 + height := height_234 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_234 +def height_237 : ℕ := 5 +def childrenH_237 : Fin 2 → ℕ := ![height_0, height_10] +theorem height_exact_237 : height_237 = 1 + Finset.univ.sup childrenH_237 := by decide +kernel +theorem required_origin_237 : ∀ x ∈ required_237, + (∃ j, x ∈ childrenC_237 j) ∨ ∀ j, x ∈ childrenD_237 j := by decide +kernel +theorem required_exact_237 : required_237 = + ((Finset.univ.biUnion childrenC_237) ∪ commonEnvelope childrenD_237).erase (0, 1) := by + exact required_eq_combination childrenC_237 childrenD_237 (0, 1) required_237 + (by decide +kernel) child_required_sub_237 common_sub_237 required_origin_237 +theorem envelope_origin_237 : ∀ x ∈ envelope_237, + x = (0, 1) ∨ ∃ j, x ∈ childrenD_237 j := by decide +kernel +theorem envelope_exact_237 : envelope_237 = + insert (0, 1) (Finset.univ.biUnion childrenD_237) := by + exact envelope_eq_combination childrenD_237 (0, 1) envelope_237 + pivot_mem_237 child_envelope_sub_237 envelope_origin_237 +def checked_237 : CheckedCard where + required := required_237 + envelope := envelope_237 + height := height_237 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_237 +def height_241 : ℕ := 5 +def childrenH_241 : Fin 2 → ℕ := ![height_5, height_91] +theorem height_exact_241 : height_241 = 1 + Finset.univ.sup childrenH_241 := by decide +kernel +theorem required_origin_241 : ∀ x ∈ required_241, + (∃ j, x ∈ childrenC_241 j) ∨ ∀ j, x ∈ childrenD_241 j := by decide +kernel +theorem required_exact_241 : required_241 = + ((Finset.univ.biUnion childrenC_241) ∪ commonEnvelope childrenD_241).erase (2, 1) := by + exact required_eq_combination childrenC_241 childrenD_241 (2, 1) required_241 + (by decide +kernel) child_required_sub_241 common_sub_241 required_origin_241 +theorem envelope_origin_241 : ∀ x ∈ envelope_241, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_241 j := by decide +kernel +theorem envelope_exact_241 : envelope_241 = + insert (2, 1) (Finset.univ.biUnion childrenD_241) := by + exact envelope_eq_combination childrenD_241 (2, 1) envelope_241 + pivot_mem_241 child_envelope_sub_241 envelope_origin_241 +def checked_241 : CheckedCard where + required := required_241 + envelope := envelope_241 + height := height_241 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_241 +def height_243 : ℕ := 5 +def childrenH_243 : Fin 2 → ℕ := ![height_10, height_242] +theorem height_exact_243 : height_243 = 1 + Finset.univ.sup childrenH_243 := by decide +kernel +theorem required_origin_243 : ∀ x ∈ required_243, + (∃ j, x ∈ childrenC_243 j) ∨ ∀ j, x ∈ childrenD_243 j := by decide +kernel +theorem required_exact_243 : required_243 = + ((Finset.univ.biUnion childrenC_243) ∪ commonEnvelope childrenD_243).erase (2, 2) := by + exact required_eq_combination childrenC_243 childrenD_243 (2, 2) required_243 + (by decide +kernel) child_required_sub_243 common_sub_243 required_origin_243 +theorem envelope_origin_243 : ∀ x ∈ envelope_243, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_243 j := by decide +kernel +theorem envelope_exact_243 : envelope_243 = + insert (2, 2) (Finset.univ.biUnion childrenD_243) := by + exact envelope_eq_combination childrenD_243 (2, 2) envelope_243 + pivot_mem_243 child_envelope_sub_243 envelope_origin_243 +def checked_243 : CheckedCard where + required := required_243 + envelope := envelope_243 + height := height_243 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_243 +def height_249 : ℕ := 5 +def childrenH_249 : Fin 2 → ℕ := ![height_17, height_35] +theorem height_exact_249 : height_249 = 1 + Finset.univ.sup childrenH_249 := by decide +kernel +theorem required_origin_249 : ∀ x ∈ required_249, + (∃ j, x ∈ childrenC_249 j) ∨ ∀ j, x ∈ childrenD_249 j := by decide +kernel +theorem required_exact_249 : required_249 = + ((Finset.univ.biUnion childrenC_249) ∪ commonEnvelope childrenD_249).erase (4, 2) := by + exact required_eq_combination childrenC_249 childrenD_249 (4, 2) required_249 + (by decide +kernel) child_required_sub_249 common_sub_249 required_origin_249 +theorem envelope_origin_249 : ∀ x ∈ envelope_249, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_249 j := by decide +kernel +theorem envelope_exact_249 : envelope_249 = + insert (4, 2) (Finset.univ.biUnion childrenD_249) := by + exact envelope_eq_combination childrenD_249 (4, 2) envelope_249 + pivot_mem_249 child_envelope_sub_249 envelope_origin_249 +def checked_249 : CheckedCard where + required := required_249 + envelope := envelope_249 + height := height_249 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_249 +def height_250 : ℕ := 5 +def childrenH_250 : Fin 2 → ℕ := ![height_0, height_195] +theorem height_exact_250 : height_250 = 1 + Finset.univ.sup childrenH_250 := by decide +kernel +theorem required_origin_250 : ∀ x ∈ required_250, + (∃ j, x ∈ childrenC_250 j) ∨ ∀ j, x ∈ childrenD_250 j := by decide +kernel +theorem required_exact_250 : required_250 = + ((Finset.univ.biUnion childrenC_250) ∪ commonEnvelope childrenD_250).erase (1, 2) := by + exact required_eq_combination childrenC_250 childrenD_250 (1, 2) required_250 + (by decide +kernel) child_required_sub_250 common_sub_250 required_origin_250 +theorem envelope_origin_250 : ∀ x ∈ envelope_250, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_250 j := by decide +kernel +theorem envelope_exact_250 : envelope_250 = + insert (1, 2) (Finset.univ.biUnion childrenD_250) := by + exact envelope_eq_combination childrenD_250 (1, 2) envelope_250 + pivot_mem_250 child_envelope_sub_250 envelope_origin_250 +def checked_250 : CheckedCard where + required := required_250 + envelope := envelope_250 + height := height_250 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_250 +def height_252 : ℕ := 5 +def childrenH_252 : Fin 3 → ℕ := ![height_55, height_56, height_91] +theorem height_exact_252 : height_252 = 1 + Finset.univ.sup childrenH_252 := by decide +kernel +theorem required_origin_252 : ∀ x ∈ required_252, + (∃ j, x ∈ childrenC_252 j) ∨ ∀ j, x ∈ childrenD_252 j := by decide +kernel +theorem required_exact_252 : required_252 = + ((Finset.univ.biUnion childrenC_252) ∪ commonEnvelope childrenD_252).erase (2, 4) := by + exact required_eq_combination childrenC_252 childrenD_252 (2, 4) required_252 + (by decide +kernel) child_required_sub_252 common_sub_252 required_origin_252 +theorem envelope_origin_252 : ∀ x ∈ envelope_252, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_252 j := by decide +kernel +theorem envelope_exact_252 : envelope_252 = + insert (2, 4) (Finset.univ.biUnion childrenD_252) := by + exact envelope_eq_combination childrenD_252 (2, 4) envelope_252 + pivot_mem_252 child_envelope_sub_252 envelope_origin_252 +def checked_252 : CheckedCard where + required := required_252 + envelope := envelope_252 + height := height_252 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_252 +def height_254 : ℕ := 5 +def childrenH_254 : Fin 3 → ℕ := ![height_11, height_75, height_103] +theorem height_exact_254 : height_254 = 1 + Finset.univ.sup childrenH_254 := by decide +kernel +theorem required_origin_254 : ∀ x ∈ required_254, + (∃ j, x ∈ childrenC_254 j) ∨ ∀ j, x ∈ childrenD_254 j := by decide +kernel +theorem required_exact_254 : required_254 = + ((Finset.univ.biUnion childrenC_254) ∪ commonEnvelope childrenD_254).erase (1, 5) := by + exact required_eq_combination childrenC_254 childrenD_254 (1, 5) required_254 + (by decide +kernel) child_required_sub_254 common_sub_254 required_origin_254 +theorem envelope_origin_254 : ∀ x ∈ envelope_254, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_254 j := by decide +kernel +theorem envelope_exact_254 : envelope_254 = + insert (1, 5) (Finset.univ.biUnion childrenD_254) := by + exact envelope_eq_combination childrenD_254 (1, 5) envelope_254 + pivot_mem_254 child_envelope_sub_254 envelope_origin_254 +def checked_254 : CheckedCard where + required := required_254 + envelope := envelope_254 + height := height_254 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_254 +def height_260 : ℕ := 5 +def childrenH_260 : Fin 2 → ℕ := ![height_5, height_208] +theorem height_exact_260 : height_260 = 1 + Finset.univ.sup childrenH_260 := by decide +kernel +theorem required_origin_260 : ∀ x ∈ required_260, + (∃ j, x ∈ childrenC_260 j) ∨ ∀ j, x ∈ childrenD_260 j := by decide +kernel +theorem required_exact_260 : required_260 = + ((Finset.univ.biUnion childrenC_260) ∪ commonEnvelope childrenD_260).erase (3, 0) := by + exact required_eq_combination childrenC_260 childrenD_260 (3, 0) required_260 + (by decide +kernel) child_required_sub_260 common_sub_260 required_origin_260 +theorem envelope_origin_260 : ∀ x ∈ envelope_260, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_260 j := by decide +kernel +theorem envelope_exact_260 : envelope_260 = + insert (3, 0) (Finset.univ.biUnion childrenD_260) := by + exact envelope_eq_combination childrenD_260 (3, 0) envelope_260 + pivot_mem_260 child_envelope_sub_260 envelope_origin_260 +def checked_260 : CheckedCard where + required := required_260 + envelope := envelope_260 + height := height_260 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_260 +def height_265 : ℕ := 5 +def childrenH_265 : Fin 2 → ℕ := ![height_4, height_93] +theorem height_exact_265 : height_265 = 1 + Finset.univ.sup childrenH_265 := by decide +kernel +theorem required_origin_265 : ∀ x ∈ required_265, + (∃ j, x ∈ childrenC_265 j) ∨ ∀ j, x ∈ childrenD_265 j := by decide +kernel +theorem required_exact_265 : required_265 = + ((Finset.univ.biUnion childrenC_265) ∪ commonEnvelope childrenD_265).erase (1, 4) := by + exact required_eq_combination childrenC_265 childrenD_265 (1, 4) required_265 + (by decide +kernel) child_required_sub_265 common_sub_265 required_origin_265 +theorem envelope_origin_265 : ∀ x ∈ envelope_265, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_265 j := by decide +kernel +theorem envelope_exact_265 : envelope_265 = + insert (1, 4) (Finset.univ.biUnion childrenD_265) := by + exact envelope_eq_combination childrenD_265 (1, 4) envelope_265 + pivot_mem_265 child_envelope_sub_265 envelope_origin_265 +def checked_265 : CheckedCard where + required := required_265 + envelope := envelope_265 + height := height_265 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_265 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part03.lean new file mode 100644 index 0000000..536083b --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part03.lean @@ -0,0 +1,1011 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_272 : Finset Cell := ⟨(([(0, 1), (1, 1), (3, 1), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_272 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_272 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), (placed21 0 (2, 0) required_39)] +def childrenD_272 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), (placed21 0 (2, 0) envelope_39)] +theorem common_sub_272 : commonEnvelope childrenD_272 ⊆ insert (2, 1) required_272 := by decide +kernel +theorem child_required_sub_272 : ∀ j, childrenC_272 j ⊆ insert (2, 1) required_272 := by decide +kernel +theorem child_envelope_sub_272 : ∀ j, childrenD_272 j ⊆ envelope_272 := by decide +kernel +theorem pivot_mem_272 : (2, 1) ∈ envelope_272 := by decide +kernel +theorem children_work_272 : ∀ j, Template HasSnaky 4 (childrenC_272 j) (childrenD_272 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_39 0 (2, 0)).mono (by decide +kernel) +theorem row_works_272 : Template HasSnaky 5 required_272 envelope_272 := by + refine compose HasSnaky 4 childrenC_272 childrenD_272 children_work_272 (2, 1) + required_272 envelope_272 pivot_mem_272 child_required_sub_272 child_envelope_sub_272 ?_ + intro b hb + exact common_sub_272 (mem_commonEnvelope childrenD_272 b hb) +def required_273 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 4), (4, 2), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_273 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_273 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_2), (placed21 0 (3, 0) required_206)] +def childrenD_273 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_2), (placed21 0 (3, 0) envelope_206)] +theorem common_sub_273 : commonEnvelope childrenD_273 ⊆ insert (3, 3) required_273 := by decide +kernel +theorem child_required_sub_273 : ∀ j, childrenC_273 j ⊆ insert (3, 3) required_273 := by decide +kernel +theorem child_envelope_sub_273 : ∀ j, childrenD_273 j ⊆ envelope_273 := by decide +kernel +theorem pivot_mem_273 : (3, 3) ∈ envelope_273 := by decide +kernel +theorem children_work_273 : ∀ j, Template HasSnaky 4 (childrenC_273 j) (childrenD_273 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_206 0 (3, 0)).mono (by decide +kernel) +theorem row_works_273 : Template HasSnaky 5 required_273 envelope_273 := by + refine compose HasSnaky 4 childrenC_273 childrenD_273 children_work_273 (3, 3) + required_273 envelope_273 pivot_mem_273 child_required_sub_273 child_envelope_sub_273 ?_ + intro b hb + exact common_sub_273 (mem_commonEnvelope childrenD_273 b hb) +def required_274 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_274 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_274 : Fin 3 → Finset Cell := ![(placed21 0 (2, 0) required_13), (placed21 3 (0, 3) required_44), (placed21 5 (4, 2) required_83)] +def childrenD_274 : Fin 3 → Finset Cell := ![(placed21 0 (2, 0) envelope_13), (placed21 3 (0, 3) envelope_44), (placed21 5 (4, 2) envelope_83)] +theorem common_sub_274 : commonEnvelope childrenD_274 ⊆ insert (3, 2) required_274 := by decide +kernel +theorem child_required_sub_274 : ∀ j, childrenC_274 j ⊆ insert (3, 2) required_274 := by decide +kernel +theorem child_envelope_sub_274 : ∀ j, childrenD_274 j ⊆ envelope_274 := by decide +kernel +theorem pivot_mem_274 : (3, 2) ∈ envelope_274 := by decide +kernel +theorem children_work_274 : ∀ j, Template HasSnaky 4 (childrenC_274 j) (childrenD_274 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 0 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_44 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_83 5 (4, 2)).mono (by decide +kernel) +theorem row_works_274 : Template HasSnaky 5 required_274 envelope_274 := by + refine compose HasSnaky 4 childrenC_274 childrenD_274 children_work_274 (3, 2) + required_274 envelope_274 pivot_mem_274 child_required_sub_274 child_envelope_sub_274 ?_ + intro b hb + exact common_sub_274 (mem_commonEnvelope childrenD_274 b hb) +def required_278 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 3), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_278 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (4, 1), (4, 2), (5, 1), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_278 : Fin 2 → Finset Cell := ![(placed21 3 (0, 2) required_6), required_277] +def childrenD_278 : Fin 2 → Finset Cell := ![(placed21 3 (0, 2) envelope_6), envelope_277] +theorem common_sub_278 : commonEnvelope childrenD_278 ⊆ insert (4, 2) required_278 := by decide +kernel +theorem child_required_sub_278 : ∀ j, childrenC_278 j ⊆ insert (4, 2) required_278 := by decide +kernel +theorem child_envelope_sub_278 : ∀ j, childrenD_278 j ⊆ envelope_278 := by decide +kernel +theorem pivot_mem_278 : (4, 2) ∈ envelope_278 := by decide +kernel +theorem children_work_278 : ∀ j, Template HasSnaky 4 (childrenC_278 j) (childrenD_278 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 2)).mono (by decide +kernel) + · exact row_works_277.mono (by decide +kernel) +theorem row_works_278 : Template HasSnaky 5 required_278 envelope_278 := by + refine compose HasSnaky 4 childrenC_278 childrenD_278 children_work_278 (4, 2) + required_278 envelope_278 pivot_mem_278 child_required_sub_278 child_envelope_sub_278 ?_ + intro b hb + exact common_sub_278 (mem_commonEnvelope childrenD_278 b hb) +def required_279 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_279 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_279 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) required_6), (placed21 0 (1, 0) required_141)] +def childrenD_279 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) envelope_6), (placed21 0 (1, 0) envelope_141)] +theorem common_sub_279 : commonEnvelope childrenD_279 ⊆ insert (4, 3) required_279 := by decide +kernel +theorem child_required_sub_279 : ∀ j, childrenC_279 j ⊆ insert (4, 3) required_279 := by decide +kernel +theorem child_envelope_sub_279 : ∀ j, childrenD_279 j ⊆ envelope_279 := by decide +kernel +theorem pivot_mem_279 : (4, 3) ∈ envelope_279 := by decide +kernel +theorem children_work_279 : ∀ j, Template HasSnaky 4 (childrenC_279 j) (childrenD_279 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_141 0 (1, 0)).mono (by decide +kernel) +theorem row_works_279 : Template HasSnaky 5 required_279 envelope_279 := by + refine compose HasSnaky 4 childrenC_279 childrenD_279 children_work_279 (4, 3) + required_279 envelope_279 pivot_mem_279 child_required_sub_279 child_envelope_sub_279 ?_ + intro b hb + exact common_sub_279 (mem_commonEnvelope childrenD_279 b hb) +def required_282 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_282 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_282 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) required_20), (placed21 1 (0, 2) required_29), required_92] +def childrenD_282 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) envelope_20), (placed21 1 (0, 2) envelope_29), envelope_92] +theorem common_sub_282 : commonEnvelope childrenD_282 ⊆ insert (3, 2) required_282 := by decide +kernel +theorem child_required_sub_282 : ∀ j, childrenC_282 j ⊆ insert (3, 2) required_282 := by decide +kernel +theorem child_envelope_sub_282 : ∀ j, childrenD_282 j ⊆ envelope_282 := by decide +kernel +theorem pivot_mem_282 : (3, 2) ∈ envelope_282 := by decide +kernel +theorem children_work_282 : ∀ j, Template HasSnaky 4 (childrenC_282 j) (childrenD_282 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_20 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_29 1 (0, 2)).mono (by decide +kernel) + · exact row_works_92.mono (by decide +kernel) +theorem row_works_282 : Template HasSnaky 5 required_282 envelope_282 := by + refine compose HasSnaky 4 childrenC_282 childrenD_282 children_work_282 (3, 2) + required_282 envelope_282 pivot_mem_282 child_required_sub_282 child_envelope_sub_282 ?_ + intro b hb + exact common_sub_282 (mem_commonEnvelope childrenD_282 b hb) +def required_293 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_293 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_293 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) required_17), (placed21 2 (4, 0) required_56)] +def childrenD_293 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) envelope_17), (placed21 2 (4, 0) envelope_56)] +theorem common_sub_293 : commonEnvelope childrenD_293 ⊆ insert (4, 3) required_293 := by decide +kernel +theorem child_required_sub_293 : ∀ j, childrenC_293 j ⊆ insert (4, 3) required_293 := by decide +kernel +theorem child_envelope_sub_293 : ∀ j, childrenD_293 j ⊆ envelope_293 := by decide +kernel +theorem pivot_mem_293 : (4, 3) ∈ envelope_293 := by decide +kernel +theorem children_work_293 : ∀ j, Template HasSnaky 4 (childrenC_293 j) (childrenD_293 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_17 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_56 2 (4, 0)).mono (by decide +kernel) +theorem row_works_293 : Template HasSnaky 5 required_293 envelope_293 := by + refine compose HasSnaky 4 childrenC_293 childrenD_293 children_work_293 (4, 3) + required_293 envelope_293 pivot_mem_293 child_required_sub_293 child_envelope_sub_293 ?_ + intro b hb + exact common_sub_293 (mem_commonEnvelope childrenD_293 b hb) +def required_294 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 3), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_294 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_294 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) required_10), (placed21 1 (0, 2) required_48), (placed21 3 (0, 6) required_165)] +def childrenD_294 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) envelope_10), (placed21 1 (0, 2) envelope_48), (placed21 3 (0, 6) envelope_165)] +theorem common_sub_294 : commonEnvelope childrenD_294 ⊆ insert (3, 3) required_294 := by decide +kernel +theorem child_required_sub_294 : ∀ j, childrenC_294 j ⊆ insert (3, 3) required_294 := by decide +kernel +theorem child_envelope_sub_294 : ∀ j, childrenD_294 j ⊆ envelope_294 := by decide +kernel +theorem pivot_mem_294 : (3, 3) ∈ envelope_294 := by decide +kernel +theorem children_work_294 : ∀ j, Template HasSnaky 4 (childrenC_294 j) (childrenD_294 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_48 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_165 3 (0, 6)).mono (by decide +kernel) +theorem row_works_294 : Template HasSnaky 5 required_294 envelope_294 := by + refine compose HasSnaky 4 childrenC_294 childrenD_294 children_work_294 (3, 3) + required_294 envelope_294 pivot_mem_294 child_required_sub_294 child_envelope_sub_294 ?_ + intro b hb + exact common_sub_294 (mem_commonEnvelope childrenD_294 b hb) +def required_296 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 4), (2, 1), (2, 2), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_296 : Finset Cell := ⟨(([(0, 4), (1, 1), (1, 2), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_296 : Fin 2 → Finset Cell := ![(placed21 7 (2, 5) required_0), (placed21 3 (0, 5) required_132)] +def childrenD_296 : Fin 2 → Finset Cell := ![(placed21 7 (2, 5) envelope_0), (placed21 3 (0, 5) envelope_132)] +theorem common_sub_296 : commonEnvelope childrenD_296 ⊆ insert (2, 3) required_296 := by decide +kernel +theorem child_required_sub_296 : ∀ j, childrenC_296 j ⊆ insert (2, 3) required_296 := by decide +kernel +theorem child_envelope_sub_296 : ∀ j, childrenD_296 j ⊆ envelope_296 := by decide +kernel +theorem pivot_mem_296 : (2, 3) ∈ envelope_296 := by decide +kernel +theorem children_work_296 : ∀ j, Template HasSnaky 4 (childrenC_296 j) (childrenD_296 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_132 3 (0, 5)).mono (by decide +kernel) +theorem row_works_296 : Template HasSnaky 5 required_296 envelope_296 := by + refine compose HasSnaky 4 childrenC_296 childrenD_296 children_work_296 (2, 3) + required_296 envelope_296 pivot_mem_296 child_required_sub_296 child_envelope_sub_296 ?_ + intro b hb + exact common_sub_296 (mem_commonEnvelope childrenD_296 b hb) +def required_299 : Finset Cell := ⟨(([(1, 3), (1, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_299 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_299 : Fin 3 → Finset Cell := ![(placed21 4 (2, 7) required_12), (placed21 0 (0, 2) required_165), (placed21 2 (4, 2) required_264)] +def childrenD_299 : Fin 3 → Finset Cell := ![(placed21 4 (2, 7) envelope_12), (placed21 0 (0, 2) envelope_165), (placed21 2 (4, 2) envelope_264)] +theorem common_sub_299 : commonEnvelope childrenD_299 ⊆ insert (3, 5) required_299 := by decide +kernel +theorem child_required_sub_299 : ∀ j, childrenC_299 j ⊆ insert (3, 5) required_299 := by decide +kernel +theorem child_envelope_sub_299 : ∀ j, childrenD_299 j ⊆ envelope_299 := by decide +kernel +theorem pivot_mem_299 : (3, 5) ∈ envelope_299 := by decide +kernel +theorem children_work_299 : ∀ j, Template HasSnaky 4 (childrenC_299 j) (childrenD_299 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_165 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_264 2 (4, 2)).mono (by decide +kernel) +theorem row_works_299 : Template HasSnaky 5 required_299 envelope_299 := by + refine compose HasSnaky 4 childrenC_299 childrenD_299 children_work_299 (3, 5) + required_299 envelope_299 pivot_mem_299 child_required_sub_299 child_envelope_sub_299 ?_ + intro b hb + exact common_sub_299 (mem_commonEnvelope childrenD_299 b hb) +def required_301 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_301 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_301 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) required_23), required_55] +def childrenD_301 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) envelope_23), envelope_55] +theorem common_sub_301 : commonEnvelope childrenD_301 ⊆ insert (3, 3) required_301 := by decide +kernel +theorem child_required_sub_301 : ∀ j, childrenC_301 j ⊆ insert (3, 3) required_301 := by decide +kernel +theorem child_envelope_sub_301 : ∀ j, childrenD_301 j ⊆ envelope_301 := by decide +kernel +theorem pivot_mem_301 : (3, 3) ∈ envelope_301 := by decide +kernel +theorem children_work_301 : ∀ j, Template HasSnaky 4 (childrenC_301 j) (childrenD_301 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_23 3 (0, 3)).mono (by decide +kernel) + · exact row_works_55.mono (by decide +kernel) +theorem row_works_301 : Template HasSnaky 5 required_301 envelope_301 := by + refine compose HasSnaky 4 childrenC_301 childrenD_301 children_work_301 (3, 3) + required_301 envelope_301 pivot_mem_301 child_required_sub_301 child_envelope_sub_301 ?_ + intro b hb + exact common_sub_301 (mem_commonEnvelope childrenD_301 b hb) +def required_306 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_306 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_306 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_18), (placed21 7 (4, 4) required_207)] +def childrenD_306 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_18), (placed21 7 (4, 4) envelope_207)] +theorem common_sub_306 : commonEnvelope childrenD_306 ⊆ insert (4, 1) required_306 := by decide +kernel +theorem child_required_sub_306 : ∀ j, childrenC_306 j ⊆ insert (4, 1) required_306 := by decide +kernel +theorem child_envelope_sub_306 : ∀ j, childrenD_306 j ⊆ envelope_306 := by decide +kernel +theorem pivot_mem_306 : (4, 1) ∈ envelope_306 := by decide +kernel +theorem children_work_306 : ∀ j, Template HasSnaky 4 (childrenC_306 j) (childrenD_306 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_207 7 (4, 4)).mono (by decide +kernel) +theorem row_works_306 : Template HasSnaky 5 required_306 envelope_306 := by + refine compose HasSnaky 4 childrenC_306 childrenD_306 children_work_306 (4, 1) + required_306 envelope_306 pivot_mem_306 child_required_sub_306 child_envelope_sub_306 ?_ + intro b hb + exact common_sub_306 (mem_commonEnvelope childrenD_306 b hb) +def required_308 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_308 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7), (2, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_308 : Fin 4 → Finset Cell := ![(placed21 6 (1, 6) required_44), (placed21 6 (1, 6) required_52), (placed21 0 (0, 2) required_63), (placed21 6 (1, 6) required_158)] +def childrenD_308 : Fin 4 → Finset Cell := ![(placed21 6 (1, 6) envelope_44), (placed21 6 (1, 6) envelope_52), (placed21 0 (0, 2) envelope_63), (placed21 6 (1, 6) envelope_158)] +theorem common_sub_308 : commonEnvelope childrenD_308 ⊆ insert (1, 5) required_308 := by decide +kernel +theorem child_required_sub_308 : ∀ j, childrenC_308 j ⊆ insert (1, 5) required_308 := by decide +kernel +theorem child_envelope_sub_308 : ∀ j, childrenD_308 j ⊆ envelope_308 := by decide +kernel +theorem pivot_mem_308 : (1, 5) ∈ envelope_308 := by decide +kernel +theorem children_work_308 : ∀ j, Template HasSnaky 4 (childrenC_308 j) (childrenD_308 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_63 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_158 6 (1, 6)).mono (by decide +kernel) +theorem row_works_308 : Template HasSnaky 5 required_308 envelope_308 := by + refine compose HasSnaky 4 childrenC_308 childrenD_308 children_work_308 (1, 5) + required_308 envelope_308 pivot_mem_308 child_required_sub_308 child_envelope_sub_308 ?_ + intro b hb + exact common_sub_308 (mem_commonEnvelope childrenD_308 b hb) +def required_312 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_312 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_312 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 4 (0, 2) required_311)] +def childrenD_312 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 4 (0, 2) envelope_311)] +theorem common_sub_312 : commonEnvelope childrenD_312 ⊆ insert (2, 1) required_312 := by decide +kernel +theorem child_required_sub_312 : ∀ j, childrenC_312 j ⊆ insert (2, 1) required_312 := by decide +kernel +theorem child_envelope_sub_312 : ∀ j, childrenD_312 j ⊆ envelope_312 := by decide +kernel +theorem pivot_mem_312 : (2, 1) ∈ envelope_312 := by decide +kernel +theorem children_work_312 : ∀ j, Template HasSnaky 4 (childrenC_312 j) (childrenD_312 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_311 4 (0, 2)).mono (by decide +kernel) +theorem row_works_312 : Template HasSnaky 5 required_312 envelope_312 := by + refine compose HasSnaky 4 childrenC_312 childrenD_312 children_work_312 (2, 1) + required_312 envelope_312 pivot_mem_312 child_required_sub_312 child_envelope_sub_312 ?_ + intro b hb + exact common_sub_312 (mem_commonEnvelope childrenD_312 b hb) +def required_314_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_314_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1), (4, 0), (4, 1), (4, 2), (5, 1), (5, 2), (6, 1), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_314_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), (placed21 1 (1, 0) required_20)] +def childrenD_314_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), (placed21 1 (1, 0) envelope_20)] +theorem common_sub_314_i0 : commonEnvelope childrenD_314_i0 ⊆ insert (3, 0) required_314_i0 := by decide +kernel +theorem child_required_sub_314_i0 : ∀ j, childrenC_314_i0 j ⊆ insert (3, 0) required_314_i0 := by decide +kernel +theorem child_envelope_sub_314_i0 : ∀ j, childrenD_314_i0 j ⊆ envelope_314_i0 := by decide +kernel +theorem pivot_mem_314_i0 : (3, 0) ∈ envelope_314_i0 := by decide +kernel +theorem children_work_314_i0 : ∀ j, Template HasSnaky 3 (childrenC_314_i0 j) (childrenD_314_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_20 1 (1, 0)).mono (by decide +kernel) +theorem row_works_314_i0 : Template HasSnaky 4 required_314_i0 envelope_314_i0 := by + refine compose HasSnaky 3 childrenC_314_i0 childrenD_314_i0 children_work_314_i0 (3, 0) + required_314_i0 envelope_314_i0 pivot_mem_314_i0 child_required_sub_314_i0 child_envelope_sub_314_i0 ?_ + intro b hb + exact common_sub_314_i0 (mem_commonEnvelope childrenD_314_i0 b hb) +def required_314 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_314 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 0), (6, 1), (6, 2), (7, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_314 : Fin 4 → Finset Cell := ![(placed21 3 (0, 1) required_6), (placed21 0 (1, 0) required_8), (placed21 1 (1, 0) required_17), required_314_i0] +def childrenD_314 : Fin 4 → Finset Cell := ![(placed21 3 (0, 1) envelope_6), (placed21 0 (1, 0) envelope_8), (placed21 1 (1, 0) envelope_17), envelope_314_i0] +theorem common_sub_314 : commonEnvelope childrenD_314 ⊆ insert (4, 1) required_314 := by decide +kernel +theorem child_required_sub_314 : ∀ j, childrenC_314 j ⊆ insert (4, 1) required_314 := by decide +kernel +theorem child_envelope_sub_314 : ∀ j, childrenD_314 j ⊆ envelope_314 := by decide +kernel +theorem pivot_mem_314 : (4, 1) ∈ envelope_314 := by decide +kernel +theorem children_work_314 : ∀ j, Template HasSnaky 4 (childrenC_314 j) (childrenD_314 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_8 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_17 1 (1, 0)).mono (by decide +kernel) + · exact row_works_314_i0.mono (by decide +kernel) +theorem row_works_314 : Template HasSnaky 5 required_314 envelope_314 := by + refine compose HasSnaky 4 childrenC_314 childrenD_314 children_work_314 (4, 1) + required_314 envelope_314 pivot_mem_314 child_required_sub_314 child_envelope_sub_314 ?_ + intro b hb + exact common_sub_314 (mem_commonEnvelope childrenD_314 b hb) +def required_335 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 4), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_335 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 3), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_335 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) required_52), (placed21 2 (3, 0) required_334)] +def childrenD_335 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) envelope_52), (placed21 2 (3, 0) envelope_334)] +theorem common_sub_335 : commonEnvelope childrenD_335 ⊆ insert (3, 3) required_335 := by decide +kernel +theorem child_required_sub_335 : ∀ j, childrenC_335 j ⊆ insert (3, 3) required_335 := by decide +kernel +theorem child_envelope_sub_335 : ∀ j, childrenD_335 j ⊆ envelope_335 := by decide +kernel +theorem pivot_mem_335 : (3, 3) ∈ envelope_335 := by decide +kernel +theorem children_work_335 : ∀ j, Template HasSnaky 4 (childrenC_335 j) (childrenD_335 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_334 2 (3, 0)).mono (by decide +kernel) +theorem row_works_335 : Template HasSnaky 5 required_335 envelope_335 := by + refine compose HasSnaky 4 childrenC_335 childrenD_335 children_work_335 (3, 3) + required_335 envelope_335 pivot_mem_335 child_required_sub_335 child_envelope_sub_335 ?_ + intro b hb + exact common_sub_335 (mem_commonEnvelope childrenD_335 b hb) +def required_342_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_342_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_342_i0 : Fin 2 → Finset Cell := ![(placed21 2 (3, 0) required_11), (placed21 5 (4, 1) required_78)] +def childrenD_342_i0 : Fin 2 → Finset Cell := ![(placed21 2 (3, 0) envelope_11), (placed21 5 (4, 1) envelope_78)] +theorem common_sub_342_i0 : commonEnvelope childrenD_342_i0 ⊆ insert (3, 4) required_342_i0 := by decide +kernel +theorem child_required_sub_342_i0 : ∀ j, childrenC_342_i0 j ⊆ insert (3, 4) required_342_i0 := by decide +kernel +theorem child_envelope_sub_342_i0 : ∀ j, childrenD_342_i0 j ⊆ envelope_342_i0 := by decide +kernel +theorem pivot_mem_342_i0 : (3, 4) ∈ envelope_342_i0 := by decide +kernel +theorem children_work_342_i0 : ∀ j, Template HasSnaky 3 (childrenC_342_i0 j) (childrenD_342_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 2 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_78 5 (4, 1)).mono (by decide +kernel) +theorem row_works_342_i0 : Template HasSnaky 4 required_342_i0 envelope_342_i0 := by + refine compose HasSnaky 3 childrenC_342_i0 childrenD_342_i0 children_work_342_i0 (3, 4) + required_342_i0 envelope_342_i0 pivot_mem_342_i0 child_required_sub_342_i0 child_envelope_sub_342_i0 ?_ + intro b hb + exact common_sub_342_i0 (mem_commonEnvelope childrenD_342_i0 b hb) +def required_342 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_342 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_342 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_5), required_342_i0] +def childrenD_342 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_5), envelope_342_i0] +theorem common_sub_342 : commonEnvelope childrenD_342 ⊆ insert (3, 1) required_342 := by decide +kernel +theorem child_required_sub_342 : ∀ j, childrenC_342 j ⊆ insert (3, 1) required_342 := by decide +kernel +theorem child_envelope_sub_342 : ∀ j, childrenD_342 j ⊆ envelope_342 := by decide +kernel +theorem pivot_mem_342 : (3, 1) ∈ envelope_342 := by decide +kernel +theorem children_work_342 : ∀ j, Template HasSnaky 4 (childrenC_342 j) (childrenD_342 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact row_works_342_i0.mono (by decide +kernel) +theorem row_works_342 : Template HasSnaky 5 required_342 envelope_342 := by + refine compose HasSnaky 4 childrenC_342 childrenD_342 children_work_342 (3, 1) + required_342 envelope_342 pivot_mem_342 child_required_sub_342 child_envelope_sub_342 ?_ + intro b hb + exact common_sub_342 (mem_commonEnvelope childrenD_342 b hb) +def required_347_i1 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_347_i1 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 3), (2, 4), (3, 2), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_347_i1 : Fin 2 → Finset Cell := ![(placed21 1 (1, 0) required_5), (placed21 3 (0, 3) required_94)] +def childrenD_347_i1 : Fin 2 → Finset Cell := ![(placed21 1 (1, 0) envelope_5), (placed21 3 (0, 3) envelope_94)] +theorem common_sub_347_i1 : commonEnvelope childrenD_347_i1 ⊆ insert (2, 3) required_347_i1 := by decide +kernel +theorem child_required_sub_347_i1 : ∀ j, childrenC_347_i1 j ⊆ insert (2, 3) required_347_i1 := by decide +kernel +theorem child_envelope_sub_347_i1 : ∀ j, childrenD_347_i1 j ⊆ envelope_347_i1 := by decide +kernel +theorem pivot_mem_347_i1 : (2, 3) ∈ envelope_347_i1 := by decide +kernel +theorem children_work_347_i1 : ∀ j, Template HasSnaky 2 (childrenC_347_i1 j) (childrenD_347_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_94 3 (0, 3)).mono (by decide +kernel) +theorem row_works_347_i1 : Template HasSnaky 3 required_347_i1 envelope_347_i1 := by + refine compose HasSnaky 2 childrenC_347_i1 childrenD_347_i1 children_work_347_i1 (2, 3) + required_347_i1 envelope_347_i1 pivot_mem_347_i1 child_required_sub_347_i1 child_envelope_sub_347_i1 ?_ + intro b hb + exact common_sub_347_i1 (mem_commonEnvelope childrenD_347_i1 b hb) +def required_347_i0 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_347_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (2, 3), (2, 4), (3, 2), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_347_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) required_5), required_347_i1] +def childrenD_347_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) envelope_5), envelope_347_i1] +theorem common_sub_347_i0 : commonEnvelope childrenD_347_i0 ⊆ insert (0, 3) required_347_i0 := by decide +kernel +theorem child_required_sub_347_i0 : ∀ j, childrenC_347_i0 j ⊆ insert (0, 3) required_347_i0 := by decide +kernel +theorem child_envelope_sub_347_i0 : ∀ j, childrenD_347_i0 j ⊆ envelope_347_i0 := by decide +kernel +theorem pivot_mem_347_i0 : (0, 3) ∈ envelope_347_i0 := by decide +kernel +theorem children_work_347_i0 : ∀ j, Template HasSnaky 3 (childrenC_347_i0 j) (childrenD_347_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (1, 0)).mono (by decide +kernel) + · exact row_works_347_i1.mono (by decide +kernel) +theorem row_works_347_i0 : Template HasSnaky 4 required_347_i0 envelope_347_i0 := by + refine compose HasSnaky 3 childrenC_347_i0 childrenD_347_i0 children_work_347_i0 (0, 3) + required_347_i0 envelope_347_i0 pivot_mem_347_i0 child_required_sub_347_i0 child_envelope_sub_347_i0 ?_ + intro b hb + exact common_sub_347_i0 (mem_commonEnvelope childrenD_347_i0 b hb) +def required_347 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_347 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_347 : Fin 3 → Finset Cell := ![required_20, (placed21 2 (1, 0) required_29), required_347_i0] +def childrenD_347 : Fin 3 → Finset Cell := ![envelope_20, (placed21 2 (1, 0) envelope_29), envelope_347_i0] +theorem common_sub_347 : commonEnvelope childrenD_347 ⊆ insert (1, 3) required_347 := by decide +kernel +theorem child_required_sub_347 : ∀ j, childrenC_347 j ⊆ insert (1, 3) required_347 := by decide +kernel +theorem child_envelope_sub_347 : ∀ j, childrenD_347 j ⊆ envelope_347 := by decide +kernel +theorem pivot_mem_347 : (1, 3) ∈ envelope_347 := by decide +kernel +theorem children_work_347 : ∀ j, Template HasSnaky 4 (childrenC_347 j) (childrenD_347 j) := by + intro j + fin_cases j + · exact row_works_20.mono (by decide +kernel) + · exact (placed21_template row_works_29 2 (1, 0)).mono (by decide +kernel) + · exact row_works_347_i0.mono (by decide +kernel) +theorem row_works_347 : Template HasSnaky 5 required_347 envelope_347 := by + refine compose HasSnaky 4 childrenC_347 childrenD_347 children_work_347 (1, 3) + required_347 envelope_347 pivot_mem_347 child_required_sub_347 child_envelope_sub_347 ?_ + intro b hb + exact common_sub_347 (mem_commonEnvelope childrenD_347 b hb) +def required_352 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_352 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_352 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_4), (placed21 0 (1, 0) required_351)] +def childrenD_352 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_4), (placed21 0 (1, 0) envelope_351)] +theorem common_sub_352 : commonEnvelope childrenD_352 ⊆ insert (4, 2) required_352 := by decide +kernel +theorem child_required_sub_352 : ∀ j, childrenC_352 j ⊆ insert (4, 2) required_352 := by decide +kernel +theorem child_envelope_sub_352 : ∀ j, childrenD_352 j ⊆ envelope_352 := by decide +kernel +theorem pivot_mem_352 : (4, 2) ∈ envelope_352 := by decide +kernel +theorem children_work_352 : ∀ j, Template HasSnaky 4 (childrenC_352 j) (childrenD_352 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_351 0 (1, 0)).mono (by decide +kernel) +theorem row_works_352 : Template HasSnaky 5 required_352 envelope_352 := by + refine compose HasSnaky 4 childrenC_352 childrenD_352 children_work_352 (4, 2) + required_352 envelope_352 pivot_mem_352 child_required_sub_352 child_envelope_sub_352 ?_ + intro b hb + exact common_sub_352 (mem_commonEnvelope childrenD_352 b hb) +def required_355 : Finset Cell := ⟨(([(0, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_355 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_355 : Fin 2 → Finset Cell := ![(placed21 1 (2, 1) required_8), (placed21 7 (4, 4) required_354)] +def childrenD_355 : Fin 2 → Finset Cell := ![(placed21 1 (2, 1) envelope_8), (placed21 7 (4, 4) envelope_354)] +theorem common_sub_355 : commonEnvelope childrenD_355 ⊆ insert (3, 4) required_355 := by decide +kernel +theorem child_required_sub_355 : ∀ j, childrenC_355 j ⊆ insert (3, 4) required_355 := by decide +kernel +theorem child_envelope_sub_355 : ∀ j, childrenD_355 j ⊆ envelope_355 := by decide +kernel +theorem pivot_mem_355 : (3, 4) ∈ envelope_355 := by decide +kernel +theorem children_work_355 : ∀ j, Template HasSnaky 4 (childrenC_355 j) (childrenD_355 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_354 7 (4, 4)).mono (by decide +kernel) +theorem row_works_355 : Template HasSnaky 5 required_355 envelope_355 := by + refine compose HasSnaky 4 childrenC_355 childrenD_355 children_work_355 (3, 4) + required_355 envelope_355 pivot_mem_355 child_required_sub_355 child_envelope_sub_355 ?_ + intro b hb + exact common_sub_355 (mem_commonEnvelope childrenD_355 b hb) +def height_272 : ℕ := 5 +def childrenH_272 : Fin 2 → ℕ := ![height_5, height_39] +theorem height_exact_272 : height_272 = 1 + Finset.univ.sup childrenH_272 := by decide +kernel +theorem required_origin_272 : ∀ x ∈ required_272, + (∃ j, x ∈ childrenC_272 j) ∨ ∀ j, x ∈ childrenD_272 j := by decide +kernel +theorem required_exact_272 : required_272 = + ((Finset.univ.biUnion childrenC_272) ∪ commonEnvelope childrenD_272).erase (2, 1) := by + exact required_eq_combination childrenC_272 childrenD_272 (2, 1) required_272 + (by decide +kernel) child_required_sub_272 common_sub_272 required_origin_272 +theorem envelope_origin_272 : ∀ x ∈ envelope_272, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_272 j := by decide +kernel +theorem envelope_exact_272 : envelope_272 = + insert (2, 1) (Finset.univ.biUnion childrenD_272) := by + exact envelope_eq_combination childrenD_272 (2, 1) envelope_272 + pivot_mem_272 child_envelope_sub_272 envelope_origin_272 +def checked_272 : CheckedCard where + required := required_272 + envelope := envelope_272 + height := height_272 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_272 +def height_273 : ℕ := 5 +def childrenH_273 : Fin 2 → ℕ := ![height_2, height_206] +theorem height_exact_273 : height_273 = 1 + Finset.univ.sup childrenH_273 := by decide +kernel +theorem required_origin_273 : ∀ x ∈ required_273, + (∃ j, x ∈ childrenC_273 j) ∨ ∀ j, x ∈ childrenD_273 j := by decide +kernel +theorem required_exact_273 : required_273 = + ((Finset.univ.biUnion childrenC_273) ∪ commonEnvelope childrenD_273).erase (3, 3) := by + exact required_eq_combination childrenC_273 childrenD_273 (3, 3) required_273 + (by decide +kernel) child_required_sub_273 common_sub_273 required_origin_273 +theorem envelope_origin_273 : ∀ x ∈ envelope_273, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_273 j := by decide +kernel +theorem envelope_exact_273 : envelope_273 = + insert (3, 3) (Finset.univ.biUnion childrenD_273) := by + exact envelope_eq_combination childrenD_273 (3, 3) envelope_273 + pivot_mem_273 child_envelope_sub_273 envelope_origin_273 +def checked_273 : CheckedCard where + required := required_273 + envelope := envelope_273 + height := height_273 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_273 +def height_274 : ℕ := 5 +def childrenH_274 : Fin 3 → ℕ := ![height_13, height_44, height_83] +theorem height_exact_274 : height_274 = 1 + Finset.univ.sup childrenH_274 := by decide +kernel +theorem required_origin_274 : ∀ x ∈ required_274, + (∃ j, x ∈ childrenC_274 j) ∨ ∀ j, x ∈ childrenD_274 j := by decide +kernel +theorem required_exact_274 : required_274 = + ((Finset.univ.biUnion childrenC_274) ∪ commonEnvelope childrenD_274).erase (3, 2) := by + exact required_eq_combination childrenC_274 childrenD_274 (3, 2) required_274 + (by decide +kernel) child_required_sub_274 common_sub_274 required_origin_274 +theorem envelope_origin_274 : ∀ x ∈ envelope_274, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_274 j := by decide +kernel +theorem envelope_exact_274 : envelope_274 = + insert (3, 2) (Finset.univ.biUnion childrenD_274) := by + exact envelope_eq_combination childrenD_274 (3, 2) envelope_274 + pivot_mem_274 child_envelope_sub_274 envelope_origin_274 +def checked_274 : CheckedCard where + required := required_274 + envelope := envelope_274 + height := height_274 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_274 +def height_278 : ℕ := 5 +def childrenH_278 : Fin 2 → ℕ := ![height_6, height_277] +theorem height_exact_278 : height_278 = 1 + Finset.univ.sup childrenH_278 := by decide +kernel +theorem required_origin_278 : ∀ x ∈ required_278, + (∃ j, x ∈ childrenC_278 j) ∨ ∀ j, x ∈ childrenD_278 j := by decide +kernel +theorem required_exact_278 : required_278 = + ((Finset.univ.biUnion childrenC_278) ∪ commonEnvelope childrenD_278).erase (4, 2) := by + exact required_eq_combination childrenC_278 childrenD_278 (4, 2) required_278 + (by decide +kernel) child_required_sub_278 common_sub_278 required_origin_278 +theorem envelope_origin_278 : ∀ x ∈ envelope_278, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_278 j := by decide +kernel +theorem envelope_exact_278 : envelope_278 = + insert (4, 2) (Finset.univ.biUnion childrenD_278) := by + exact envelope_eq_combination childrenD_278 (4, 2) envelope_278 + pivot_mem_278 child_envelope_sub_278 envelope_origin_278 +def checked_278 : CheckedCard where + required := required_278 + envelope := envelope_278 + height := height_278 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_278 +def height_279 : ℕ := 5 +def childrenH_279 : Fin 2 → ℕ := ![height_6, height_141] +theorem height_exact_279 : height_279 = 1 + Finset.univ.sup childrenH_279 := by decide +kernel +theorem required_origin_279 : ∀ x ∈ required_279, + (∃ j, x ∈ childrenC_279 j) ∨ ∀ j, x ∈ childrenD_279 j := by decide +kernel +theorem required_exact_279 : required_279 = + ((Finset.univ.biUnion childrenC_279) ∪ commonEnvelope childrenD_279).erase (4, 3) := by + exact required_eq_combination childrenC_279 childrenD_279 (4, 3) required_279 + (by decide +kernel) child_required_sub_279 common_sub_279 required_origin_279 +theorem envelope_origin_279 : ∀ x ∈ envelope_279, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_279 j := by decide +kernel +theorem envelope_exact_279 : envelope_279 = + insert (4, 3) (Finset.univ.biUnion childrenD_279) := by + exact envelope_eq_combination childrenD_279 (4, 3) envelope_279 + pivot_mem_279 child_envelope_sub_279 envelope_origin_279 +def checked_279 : CheckedCard where + required := required_279 + envelope := envelope_279 + height := height_279 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_279 +def height_282 : ℕ := 5 +def childrenH_282 : Fin 3 → ℕ := ![height_20, height_29, height_92] +theorem height_exact_282 : height_282 = 1 + Finset.univ.sup childrenH_282 := by decide +kernel +theorem required_origin_282 : ∀ x ∈ required_282, + (∃ j, x ∈ childrenC_282 j) ∨ ∀ j, x ∈ childrenD_282 j := by decide +kernel +theorem required_exact_282 : required_282 = + ((Finset.univ.biUnion childrenC_282) ∪ commonEnvelope childrenD_282).erase (3, 2) := by + exact required_eq_combination childrenC_282 childrenD_282 (3, 2) required_282 + (by decide +kernel) child_required_sub_282 common_sub_282 required_origin_282 +theorem envelope_origin_282 : ∀ x ∈ envelope_282, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_282 j := by decide +kernel +theorem envelope_exact_282 : envelope_282 = + insert (3, 2) (Finset.univ.biUnion childrenD_282) := by + exact envelope_eq_combination childrenD_282 (3, 2) envelope_282 + pivot_mem_282 child_envelope_sub_282 envelope_origin_282 +def checked_282 : CheckedCard where + required := required_282 + envelope := envelope_282 + height := height_282 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_282 +def height_293 : ℕ := 5 +def childrenH_293 : Fin 2 → ℕ := ![height_17, height_56] +theorem height_exact_293 : height_293 = 1 + Finset.univ.sup childrenH_293 := by decide +kernel +theorem required_origin_293 : ∀ x ∈ required_293, + (∃ j, x ∈ childrenC_293 j) ∨ ∀ j, x ∈ childrenD_293 j := by decide +kernel +theorem required_exact_293 : required_293 = + ((Finset.univ.biUnion childrenC_293) ∪ commonEnvelope childrenD_293).erase (4, 3) := by + exact required_eq_combination childrenC_293 childrenD_293 (4, 3) required_293 + (by decide +kernel) child_required_sub_293 common_sub_293 required_origin_293 +theorem envelope_origin_293 : ∀ x ∈ envelope_293, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_293 j := by decide +kernel +theorem envelope_exact_293 : envelope_293 = + insert (4, 3) (Finset.univ.biUnion childrenD_293) := by + exact envelope_eq_combination childrenD_293 (4, 3) envelope_293 + pivot_mem_293 child_envelope_sub_293 envelope_origin_293 +def checked_293 : CheckedCard where + required := required_293 + envelope := envelope_293 + height := height_293 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_293 +def height_294 : ℕ := 5 +def childrenH_294 : Fin 3 → ℕ := ![height_10, height_48, height_165] +theorem height_exact_294 : height_294 = 1 + Finset.univ.sup childrenH_294 := by decide +kernel +theorem required_origin_294 : ∀ x ∈ required_294, + (∃ j, x ∈ childrenC_294 j) ∨ ∀ j, x ∈ childrenD_294 j := by decide +kernel +theorem required_exact_294 : required_294 = + ((Finset.univ.biUnion childrenC_294) ∪ commonEnvelope childrenD_294).erase (3, 3) := by + exact required_eq_combination childrenC_294 childrenD_294 (3, 3) required_294 + (by decide +kernel) child_required_sub_294 common_sub_294 required_origin_294 +theorem envelope_origin_294 : ∀ x ∈ envelope_294, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_294 j := by decide +kernel +theorem envelope_exact_294 : envelope_294 = + insert (3, 3) (Finset.univ.biUnion childrenD_294) := by + exact envelope_eq_combination childrenD_294 (3, 3) envelope_294 + pivot_mem_294 child_envelope_sub_294 envelope_origin_294 +def checked_294 : CheckedCard where + required := required_294 + envelope := envelope_294 + height := height_294 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_294 +def height_296 : ℕ := 5 +def childrenH_296 : Fin 2 → ℕ := ![height_0, height_132] +theorem height_exact_296 : height_296 = 1 + Finset.univ.sup childrenH_296 := by decide +kernel +theorem required_origin_296 : ∀ x ∈ required_296, + (∃ j, x ∈ childrenC_296 j) ∨ ∀ j, x ∈ childrenD_296 j := by decide +kernel +theorem required_exact_296 : required_296 = + ((Finset.univ.biUnion childrenC_296) ∪ commonEnvelope childrenD_296).erase (2, 3) := by + exact required_eq_combination childrenC_296 childrenD_296 (2, 3) required_296 + (by decide +kernel) child_required_sub_296 common_sub_296 required_origin_296 +theorem envelope_origin_296 : ∀ x ∈ envelope_296, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_296 j := by decide +kernel +theorem envelope_exact_296 : envelope_296 = + insert (2, 3) (Finset.univ.biUnion childrenD_296) := by + exact envelope_eq_combination childrenD_296 (2, 3) envelope_296 + pivot_mem_296 child_envelope_sub_296 envelope_origin_296 +def checked_296 : CheckedCard where + required := required_296 + envelope := envelope_296 + height := height_296 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_296 +def height_299 : ℕ := 5 +def childrenH_299 : Fin 3 → ℕ := ![height_12, height_165, height_264] +theorem height_exact_299 : height_299 = 1 + Finset.univ.sup childrenH_299 := by decide +kernel +theorem required_origin_299 : ∀ x ∈ required_299, + (∃ j, x ∈ childrenC_299 j) ∨ ∀ j, x ∈ childrenD_299 j := by decide +kernel +theorem required_exact_299 : required_299 = + ((Finset.univ.biUnion childrenC_299) ∪ commonEnvelope childrenD_299).erase (3, 5) := by + exact required_eq_combination childrenC_299 childrenD_299 (3, 5) required_299 + (by decide +kernel) child_required_sub_299 common_sub_299 required_origin_299 +theorem envelope_origin_299 : ∀ x ∈ envelope_299, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_299 j := by decide +kernel +theorem envelope_exact_299 : envelope_299 = + insert (3, 5) (Finset.univ.biUnion childrenD_299) := by + exact envelope_eq_combination childrenD_299 (3, 5) envelope_299 + pivot_mem_299 child_envelope_sub_299 envelope_origin_299 +def checked_299 : CheckedCard where + required := required_299 + envelope := envelope_299 + height := height_299 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_299 +def height_301 : ℕ := 5 +def childrenH_301 : Fin 2 → ℕ := ![height_23, height_55] +theorem height_exact_301 : height_301 = 1 + Finset.univ.sup childrenH_301 := by decide +kernel +theorem required_origin_301 : ∀ x ∈ required_301, + (∃ j, x ∈ childrenC_301 j) ∨ ∀ j, x ∈ childrenD_301 j := by decide +kernel +theorem required_exact_301 : required_301 = + ((Finset.univ.biUnion childrenC_301) ∪ commonEnvelope childrenD_301).erase (3, 3) := by + exact required_eq_combination childrenC_301 childrenD_301 (3, 3) required_301 + (by decide +kernel) child_required_sub_301 common_sub_301 required_origin_301 +theorem envelope_origin_301 : ∀ x ∈ envelope_301, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_301 j := by decide +kernel +theorem envelope_exact_301 : envelope_301 = + insert (3, 3) (Finset.univ.biUnion childrenD_301) := by + exact envelope_eq_combination childrenD_301 (3, 3) envelope_301 + pivot_mem_301 child_envelope_sub_301 envelope_origin_301 +def checked_301 : CheckedCard where + required := required_301 + envelope := envelope_301 + height := height_301 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_301 +def height_306 : ℕ := 5 +def childrenH_306 : Fin 2 → ℕ := ![height_18, height_207] +theorem height_exact_306 : height_306 = 1 + Finset.univ.sup childrenH_306 := by decide +kernel +theorem required_origin_306 : ∀ x ∈ required_306, + (∃ j, x ∈ childrenC_306 j) ∨ ∀ j, x ∈ childrenD_306 j := by decide +kernel +theorem required_exact_306 : required_306 = + ((Finset.univ.biUnion childrenC_306) ∪ commonEnvelope childrenD_306).erase (4, 1) := by + exact required_eq_combination childrenC_306 childrenD_306 (4, 1) required_306 + (by decide +kernel) child_required_sub_306 common_sub_306 required_origin_306 +theorem envelope_origin_306 : ∀ x ∈ envelope_306, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_306 j := by decide +kernel +theorem envelope_exact_306 : envelope_306 = + insert (4, 1) (Finset.univ.biUnion childrenD_306) := by + exact envelope_eq_combination childrenD_306 (4, 1) envelope_306 + pivot_mem_306 child_envelope_sub_306 envelope_origin_306 +def checked_306 : CheckedCard where + required := required_306 + envelope := envelope_306 + height := height_306 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_306 +def height_308 : ℕ := 5 +def childrenH_308 : Fin 4 → ℕ := ![height_44, height_52, height_63, height_158] +theorem height_exact_308 : height_308 = 1 + Finset.univ.sup childrenH_308 := by decide +kernel +theorem required_origin_308 : ∀ x ∈ required_308, + (∃ j, x ∈ childrenC_308 j) ∨ ∀ j, x ∈ childrenD_308 j := by decide +kernel +theorem required_exact_308 : required_308 = + ((Finset.univ.biUnion childrenC_308) ∪ commonEnvelope childrenD_308).erase (1, 5) := by + exact required_eq_combination childrenC_308 childrenD_308 (1, 5) required_308 + (by decide +kernel) child_required_sub_308 common_sub_308 required_origin_308 +theorem envelope_origin_308 : ∀ x ∈ envelope_308, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_308 j := by decide +kernel +theorem envelope_exact_308 : envelope_308 = + insert (1, 5) (Finset.univ.biUnion childrenD_308) := by + exact envelope_eq_combination childrenD_308 (1, 5) envelope_308 + pivot_mem_308 child_envelope_sub_308 envelope_origin_308 +def checked_308 : CheckedCard where + required := required_308 + envelope := envelope_308 + height := height_308 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_308 +def height_312 : ℕ := 5 +def childrenH_312 : Fin 2 → ℕ := ![height_5, height_311] +theorem height_exact_312 : height_312 = 1 + Finset.univ.sup childrenH_312 := by decide +kernel +theorem required_origin_312 : ∀ x ∈ required_312, + (∃ j, x ∈ childrenC_312 j) ∨ ∀ j, x ∈ childrenD_312 j := by decide +kernel +theorem required_exact_312 : required_312 = + ((Finset.univ.biUnion childrenC_312) ∪ commonEnvelope childrenD_312).erase (2, 1) := by + exact required_eq_combination childrenC_312 childrenD_312 (2, 1) required_312 + (by decide +kernel) child_required_sub_312 common_sub_312 required_origin_312 +theorem envelope_origin_312 : ∀ x ∈ envelope_312, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_312 j := by decide +kernel +theorem envelope_exact_312 : envelope_312 = + insert (2, 1) (Finset.univ.biUnion childrenD_312) := by + exact envelope_eq_combination childrenD_312 (2, 1) envelope_312 + pivot_mem_312 child_envelope_sub_312 envelope_origin_312 +def checked_312 : CheckedCard where + required := required_312 + envelope := envelope_312 + height := height_312 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_312 +def height_314_i0 : ℕ := 4 +def childrenH_314_i0 : Fin 2 → ℕ := ![height_5, height_20] +theorem height_exact_314_i0 : height_314_i0 = 1 + Finset.univ.sup childrenH_314_i0 := by decide +kernel +theorem required_origin_314_i0 : ∀ x ∈ required_314_i0, + (∃ j, x ∈ childrenC_314_i0 j) ∨ ∀ j, x ∈ childrenD_314_i0 j := by decide +kernel +theorem required_exact_314_i0 : required_314_i0 = + ((Finset.univ.biUnion childrenC_314_i0) ∪ commonEnvelope childrenD_314_i0).erase (3, 0) := by + exact required_eq_combination childrenC_314_i0 childrenD_314_i0 (3, 0) required_314_i0 + (by decide +kernel) child_required_sub_314_i0 common_sub_314_i0 required_origin_314_i0 +theorem envelope_origin_314_i0 : ∀ x ∈ envelope_314_i0, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_314_i0 j := by decide +kernel +theorem envelope_exact_314_i0 : envelope_314_i0 = + insert (3, 0) (Finset.univ.biUnion childrenD_314_i0) := by + exact envelope_eq_combination childrenD_314_i0 (3, 0) envelope_314_i0 + pivot_mem_314_i0 child_envelope_sub_314_i0 envelope_origin_314_i0 +def checked_314_i0 : CheckedCard where + required := required_314_i0 + envelope := envelope_314_i0 + height := height_314_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_314_i0 +def height_314 : ℕ := 5 +def childrenH_314 : Fin 4 → ℕ := ![height_6, height_8, height_17, height_314_i0] +theorem height_exact_314 : height_314 = 1 + Finset.univ.sup childrenH_314 := by decide +kernel +theorem required_origin_314 : ∀ x ∈ required_314, + (∃ j, x ∈ childrenC_314 j) ∨ ∀ j, x ∈ childrenD_314 j := by decide +kernel +theorem required_exact_314 : required_314 = + ((Finset.univ.biUnion childrenC_314) ∪ commonEnvelope childrenD_314).erase (4, 1) := by + exact required_eq_combination childrenC_314 childrenD_314 (4, 1) required_314 + (by decide +kernel) child_required_sub_314 common_sub_314 required_origin_314 +theorem envelope_origin_314 : ∀ x ∈ envelope_314, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_314 j := by decide +kernel +theorem envelope_exact_314 : envelope_314 = + insert (4, 1) (Finset.univ.biUnion childrenD_314) := by + exact envelope_eq_combination childrenD_314 (4, 1) envelope_314 + pivot_mem_314 child_envelope_sub_314 envelope_origin_314 +def checked_314 : CheckedCard where + required := required_314 + envelope := envelope_314 + height := height_314 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_314 +def height_335 : ℕ := 5 +def childrenH_335 : Fin 2 → ℕ := ![height_52, height_334] +theorem height_exact_335 : height_335 = 1 + Finset.univ.sup childrenH_335 := by decide +kernel +theorem required_origin_335 : ∀ x ∈ required_335, + (∃ j, x ∈ childrenC_335 j) ∨ ∀ j, x ∈ childrenD_335 j := by decide +kernel +theorem required_exact_335 : required_335 = + ((Finset.univ.biUnion childrenC_335) ∪ commonEnvelope childrenD_335).erase (3, 3) := by + exact required_eq_combination childrenC_335 childrenD_335 (3, 3) required_335 + (by decide +kernel) child_required_sub_335 common_sub_335 required_origin_335 +theorem envelope_origin_335 : ∀ x ∈ envelope_335, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_335 j := by decide +kernel +theorem envelope_exact_335 : envelope_335 = + insert (3, 3) (Finset.univ.biUnion childrenD_335) := by + exact envelope_eq_combination childrenD_335 (3, 3) envelope_335 + pivot_mem_335 child_envelope_sub_335 envelope_origin_335 +def checked_335 : CheckedCard where + required := required_335 + envelope := envelope_335 + height := height_335 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_335 +def height_342_i0 : ℕ := 4 +def childrenH_342_i0 : Fin 2 → ℕ := ![height_11, height_78] +theorem height_exact_342_i0 : height_342_i0 = 1 + Finset.univ.sup childrenH_342_i0 := by decide +kernel +theorem required_origin_342_i0 : ∀ x ∈ required_342_i0, + (∃ j, x ∈ childrenC_342_i0 j) ∨ ∀ j, x ∈ childrenD_342_i0 j := by decide +kernel +theorem required_exact_342_i0 : required_342_i0 = + ((Finset.univ.biUnion childrenC_342_i0) ∪ commonEnvelope childrenD_342_i0).erase (3, 4) := by + exact required_eq_combination childrenC_342_i0 childrenD_342_i0 (3, 4) required_342_i0 + (by decide +kernel) child_required_sub_342_i0 common_sub_342_i0 required_origin_342_i0 +theorem envelope_origin_342_i0 : ∀ x ∈ envelope_342_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_342_i0 j := by decide +kernel +theorem envelope_exact_342_i0 : envelope_342_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_342_i0) := by + exact envelope_eq_combination childrenD_342_i0 (3, 4) envelope_342_i0 + pivot_mem_342_i0 child_envelope_sub_342_i0 envelope_origin_342_i0 +def checked_342_i0 : CheckedCard where + required := required_342_i0 + envelope := envelope_342_i0 + height := height_342_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_342_i0 +def height_342 : ℕ := 5 +def childrenH_342 : Fin 2 → ℕ := ![height_5, height_342_i0] +theorem height_exact_342 : height_342 = 1 + Finset.univ.sup childrenH_342 := by decide +kernel +theorem required_origin_342 : ∀ x ∈ required_342, + (∃ j, x ∈ childrenC_342 j) ∨ ∀ j, x ∈ childrenD_342 j := by decide +kernel +theorem required_exact_342 : required_342 = + ((Finset.univ.biUnion childrenC_342) ∪ commonEnvelope childrenD_342).erase (3, 1) := by + exact required_eq_combination childrenC_342 childrenD_342 (3, 1) required_342 + (by decide +kernel) child_required_sub_342 common_sub_342 required_origin_342 +theorem envelope_origin_342 : ∀ x ∈ envelope_342, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_342 j := by decide +kernel +theorem envelope_exact_342 : envelope_342 = + insert (3, 1) (Finset.univ.biUnion childrenD_342) := by + exact envelope_eq_combination childrenD_342 (3, 1) envelope_342 + pivot_mem_342 child_envelope_sub_342 envelope_origin_342 +def checked_342 : CheckedCard where + required := required_342 + envelope := envelope_342 + height := height_342 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_342 +def height_347_i1 : ℕ := 3 +def childrenH_347_i1 : Fin 2 → ℕ := ![height_5, height_94] +theorem height_exact_347_i1 : height_347_i1 = 1 + Finset.univ.sup childrenH_347_i1 := by decide +kernel +theorem required_origin_347_i1 : ∀ x ∈ required_347_i1, + (∃ j, x ∈ childrenC_347_i1 j) ∨ ∀ j, x ∈ childrenD_347_i1 j := by decide +kernel +theorem required_exact_347_i1 : required_347_i1 = + ((Finset.univ.biUnion childrenC_347_i1) ∪ commonEnvelope childrenD_347_i1).erase (2, 3) := by + exact required_eq_combination childrenC_347_i1 childrenD_347_i1 (2, 3) required_347_i1 + (by decide +kernel) child_required_sub_347_i1 common_sub_347_i1 required_origin_347_i1 +theorem envelope_origin_347_i1 : ∀ x ∈ envelope_347_i1, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_347_i1 j := by decide +kernel +theorem envelope_exact_347_i1 : envelope_347_i1 = + insert (2, 3) (Finset.univ.biUnion childrenD_347_i1) := by + exact envelope_eq_combination childrenD_347_i1 (2, 3) envelope_347_i1 + pivot_mem_347_i1 child_envelope_sub_347_i1 envelope_origin_347_i1 +def checked_347_i1 : CheckedCard where + required := required_347_i1 + envelope := envelope_347_i1 + height := height_347_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_347_i1 +def height_347_i0 : ℕ := 4 +def childrenH_347_i0 : Fin 2 → ℕ := ![height_5, height_347_i1] +theorem height_exact_347_i0 : height_347_i0 = 1 + Finset.univ.sup childrenH_347_i0 := by decide +kernel +theorem required_origin_347_i0 : ∀ x ∈ required_347_i0, + (∃ j, x ∈ childrenC_347_i0 j) ∨ ∀ j, x ∈ childrenD_347_i0 j := by decide +kernel +theorem required_exact_347_i0 : required_347_i0 = + ((Finset.univ.biUnion childrenC_347_i0) ∪ commonEnvelope childrenD_347_i0).erase (0, 3) := by + exact required_eq_combination childrenC_347_i0 childrenD_347_i0 (0, 3) required_347_i0 + (by decide +kernel) child_required_sub_347_i0 common_sub_347_i0 required_origin_347_i0 +theorem envelope_origin_347_i0 : ∀ x ∈ envelope_347_i0, + x = (0, 3) ∨ ∃ j, x ∈ childrenD_347_i0 j := by decide +kernel +theorem envelope_exact_347_i0 : envelope_347_i0 = + insert (0, 3) (Finset.univ.biUnion childrenD_347_i0) := by + exact envelope_eq_combination childrenD_347_i0 (0, 3) envelope_347_i0 + pivot_mem_347_i0 child_envelope_sub_347_i0 envelope_origin_347_i0 +def checked_347_i0 : CheckedCard where + required := required_347_i0 + envelope := envelope_347_i0 + height := height_347_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_347_i0 +def height_347 : ℕ := 5 +def childrenH_347 : Fin 3 → ℕ := ![height_20, height_29, height_347_i0] +theorem height_exact_347 : height_347 = 1 + Finset.univ.sup childrenH_347 := by decide +kernel +theorem required_origin_347 : ∀ x ∈ required_347, + (∃ j, x ∈ childrenC_347 j) ∨ ∀ j, x ∈ childrenD_347 j := by decide +kernel +theorem required_exact_347 : required_347 = + ((Finset.univ.biUnion childrenC_347) ∪ commonEnvelope childrenD_347).erase (1, 3) := by + exact required_eq_combination childrenC_347 childrenD_347 (1, 3) required_347 + (by decide +kernel) child_required_sub_347 common_sub_347 required_origin_347 +theorem envelope_origin_347 : ∀ x ∈ envelope_347, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_347 j := by decide +kernel +theorem envelope_exact_347 : envelope_347 = + insert (1, 3) (Finset.univ.biUnion childrenD_347) := by + exact envelope_eq_combination childrenD_347 (1, 3) envelope_347 + pivot_mem_347 child_envelope_sub_347 envelope_origin_347 +def checked_347 : CheckedCard where + required := required_347 + envelope := envelope_347 + height := height_347 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_347 +def height_352 : ℕ := 5 +def childrenH_352 : Fin 2 → ℕ := ![height_4, height_351] +theorem height_exact_352 : height_352 = 1 + Finset.univ.sup childrenH_352 := by decide +kernel +theorem required_origin_352 : ∀ x ∈ required_352, + (∃ j, x ∈ childrenC_352 j) ∨ ∀ j, x ∈ childrenD_352 j := by decide +kernel +theorem required_exact_352 : required_352 = + ((Finset.univ.biUnion childrenC_352) ∪ commonEnvelope childrenD_352).erase (4, 2) := by + exact required_eq_combination childrenC_352 childrenD_352 (4, 2) required_352 + (by decide +kernel) child_required_sub_352 common_sub_352 required_origin_352 +theorem envelope_origin_352 : ∀ x ∈ envelope_352, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_352 j := by decide +kernel +theorem envelope_exact_352 : envelope_352 = + insert (4, 2) (Finset.univ.biUnion childrenD_352) := by + exact envelope_eq_combination childrenD_352 (4, 2) envelope_352 + pivot_mem_352 child_envelope_sub_352 envelope_origin_352 +def checked_352 : CheckedCard where + required := required_352 + envelope := envelope_352 + height := height_352 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_352 +def height_355 : ℕ := 5 +def childrenH_355 : Fin 2 → ℕ := ![height_8, height_354] +theorem height_exact_355 : height_355 = 1 + Finset.univ.sup childrenH_355 := by decide +kernel +theorem required_origin_355 : ∀ x ∈ required_355, + (∃ j, x ∈ childrenC_355 j) ∨ ∀ j, x ∈ childrenD_355 j := by decide +kernel +theorem required_exact_355 : required_355 = + ((Finset.univ.biUnion childrenC_355) ∪ commonEnvelope childrenD_355).erase (3, 4) := by + exact required_eq_combination childrenC_355 childrenD_355 (3, 4) required_355 + (by decide +kernel) child_required_sub_355 common_sub_355 required_origin_355 +theorem envelope_origin_355 : ∀ x ∈ envelope_355, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_355 j := by decide +kernel +theorem envelope_exact_355 : envelope_355 = + insert (3, 4) (Finset.univ.biUnion childrenD_355) := by + exact envelope_eq_combination childrenD_355 (3, 4) envelope_355 + pivot_mem_355 child_envelope_sub_355 envelope_origin_355 +def checked_355 : CheckedCard where + required := required_355 + envelope := envelope_355 + height := height_355 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_355 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part04.lean new file mode 100644 index 0000000..8047e2b --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part04.lean @@ -0,0 +1,926 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_356_i0 : Finset Cell := ⟨(([(0, 3), (3, 2), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_356_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_356_i0 : Fin 2 → Finset Cell := ![(placed21 2 (3, 2) required_21), (placed21 7 (4, 5) required_121)] +def childrenD_356_i0 : Fin 2 → Finset Cell := ![(placed21 2 (3, 2) envelope_21), (placed21 7 (4, 5) envelope_121)] +theorem common_sub_356_i0 : commonEnvelope childrenD_356_i0 ⊆ insert (2, 3) required_356_i0 := by decide +kernel +theorem child_required_sub_356_i0 : ∀ j, childrenC_356_i0 j ⊆ insert (2, 3) required_356_i0 := by decide +kernel +theorem child_envelope_sub_356_i0 : ∀ j, childrenD_356_i0 j ⊆ envelope_356_i0 := by decide +kernel +theorem pivot_mem_356_i0 : (2, 3) ∈ envelope_356_i0 := by decide +kernel +theorem children_work_356_i0 : ∀ j, Template HasSnaky 3 (childrenC_356_i0 j) (childrenD_356_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 2 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_121 7 (4, 5)).mono (by decide +kernel) +theorem row_works_356_i0 : Template HasSnaky 4 required_356_i0 envelope_356_i0 := by + refine compose HasSnaky 3 childrenC_356_i0 childrenD_356_i0 children_work_356_i0 (2, 3) + required_356_i0 envelope_356_i0 pivot_mem_356_i0 child_required_sub_356_i0 child_envelope_sub_356_i0 ?_ + intro b hb + exact common_sub_356_i0 (mem_commonEnvelope childrenD_356_i0 b hb) +def required_356 : Finset Cell := ⟨(([(0, 3), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_356 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_356 : Fin 3 → Finset Cell := ![(placed21 4 (3, 6) required_7), (placed21 1 (2, 2) required_8), required_356_i0] +def childrenD_356 : Fin 3 → Finset Cell := ![(placed21 4 (3, 6) envelope_7), (placed21 1 (2, 2) envelope_8), envelope_356_i0] +theorem common_sub_356 : commonEnvelope childrenD_356 ⊆ insert (3, 5) required_356 := by decide +kernel +theorem child_required_sub_356 : ∀ j, childrenC_356 j ⊆ insert (3, 5) required_356 := by decide +kernel +theorem child_envelope_sub_356 : ∀ j, childrenD_356 j ⊆ envelope_356 := by decide +kernel +theorem pivot_mem_356 : (3, 5) ∈ envelope_356 := by decide +kernel +theorem children_work_356 : ∀ j, Template HasSnaky 4 (childrenC_356 j) (childrenD_356 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (2, 2)).mono (by decide +kernel) + · exact row_works_356_i0.mono (by decide +kernel) +theorem row_works_356 : Template HasSnaky 5 required_356 envelope_356 := by + refine compose HasSnaky 4 childrenC_356 childrenD_356 children_work_356 (3, 5) + required_356 envelope_356 pivot_mem_356 child_required_sub_356 child_envelope_sub_356 ?_ + intro b hb + exact common_sub_356 (mem_commonEnvelope childrenD_356 b hb) +def required_357_i2 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_357_i2 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_357_i2 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_3), (placed21 2 (4, 3) required_5)] +def childrenD_357_i2 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_3), (placed21 2 (4, 3) envelope_5)] +theorem common_sub_357_i2 : commonEnvelope childrenD_357_i2 ⊆ insert (1, 4) required_357_i2 := by decide +kernel +theorem child_required_sub_357_i2 : ∀ j, childrenC_357_i2 j ⊆ insert (1, 4) required_357_i2 := by decide +kernel +theorem child_envelope_sub_357_i2 : ∀ j, childrenD_357_i2 j ⊆ envelope_357_i2 := by decide +kernel +theorem pivot_mem_357_i2 : (1, 4) ∈ envelope_357_i2 := by decide +kernel +theorem children_work_357_i2 : ∀ j, Template HasSnaky 1 (childrenC_357_i2 j) (childrenD_357_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_5 2 (4, 3)).mono (by decide +kernel) +theorem row_works_357_i2 : Template HasSnaky 2 required_357_i2 envelope_357_i2 := by + refine compose HasSnaky 1 childrenC_357_i2 childrenD_357_i2 children_work_357_i2 (1, 4) + required_357_i2 envelope_357_i2 pivot_mem_357_i2 child_required_sub_357_i2 child_envelope_sub_357_i2 ?_ + intro b hb + exact common_sub_357_i2 (mem_commonEnvelope childrenD_357_i2 b hb) +def required_357_i1 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_357_i1 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_357_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_4), required_357_i2] +def childrenD_357_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_4), envelope_357_i2] +theorem common_sub_357_i1 : commonEnvelope childrenD_357_i1 ⊆ insert (1, 3) required_357_i1 := by decide +kernel +theorem child_required_sub_357_i1 : ∀ j, childrenC_357_i1 j ⊆ insert (1, 3) required_357_i1 := by decide +kernel +theorem child_envelope_sub_357_i1 : ∀ j, childrenD_357_i1 j ⊆ envelope_357_i1 := by decide +kernel +theorem pivot_mem_357_i1 : (1, 3) ∈ envelope_357_i1 := by decide +kernel +theorem children_work_357_i1 : ∀ j, Template HasSnaky 2 (childrenC_357_i1 j) (childrenD_357_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 6 (4, 3)).mono (by decide +kernel) + · exact row_works_357_i2.mono (by decide +kernel) +theorem row_works_357_i1 : Template HasSnaky 3 required_357_i1 envelope_357_i1 := by + refine compose HasSnaky 2 childrenC_357_i1 childrenD_357_i1 children_work_357_i1 (1, 3) + required_357_i1 envelope_357_i1 pivot_mem_357_i1 child_required_sub_357_i1 child_envelope_sub_357_i1 ?_ + intro b hb + exact common_sub_357_i1 (mem_commonEnvelope childrenD_357_i1 b hb) +def required_357_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_357_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_357_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 0) required_5), required_357_i1] +def childrenD_357_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 0) envelope_5), envelope_357_i1] +theorem common_sub_357_i0 : commonEnvelope childrenD_357_i0 ⊆ insert (4, 3) required_357_i0 := by decide +kernel +theorem child_required_sub_357_i0 : ∀ j, childrenC_357_i0 j ⊆ insert (4, 3) required_357_i0 := by decide +kernel +theorem child_envelope_sub_357_i0 : ∀ j, childrenD_357_i0 j ⊆ envelope_357_i0 := by decide +kernel +theorem pivot_mem_357_i0 : (4, 3) ∈ envelope_357_i0 := by decide +kernel +theorem children_work_357_i0 : ∀ j, Template HasSnaky 3 (childrenC_357_i0 j) (childrenD_357_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 0)).mono (by decide +kernel) + · exact row_works_357_i1.mono (by decide +kernel) +theorem row_works_357_i0 : Template HasSnaky 4 required_357_i0 envelope_357_i0 := by + refine compose HasSnaky 3 childrenC_357_i0 childrenD_357_i0 children_work_357_i0 (4, 3) + required_357_i0 envelope_357_i0 pivot_mem_357_i0 child_required_sub_357_i0 child_envelope_sub_357_i0 ?_ + intro b hb + exact common_sub_357_i0 (mem_commonEnvelope childrenD_357_i0 b hb) +def required_357 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (3, 0), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_357 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_357 : Fin 2 → Finset Cell := ![(placed21 5 (3, 0) required_5), required_357_i0] +def childrenD_357 : Fin 2 → Finset Cell := ![(placed21 5 (3, 0) envelope_5), envelope_357_i0] +theorem common_sub_357 : commonEnvelope childrenD_357 ⊆ insert (2, 3) required_357 := by decide +kernel +theorem child_required_sub_357 : ∀ j, childrenC_357 j ⊆ insert (2, 3) required_357 := by decide +kernel +theorem child_envelope_sub_357 : ∀ j, childrenD_357 j ⊆ envelope_357 := by decide +kernel +theorem pivot_mem_357 : (2, 3) ∈ envelope_357 := by decide +kernel +theorem children_work_357 : ∀ j, Template HasSnaky 4 (childrenC_357 j) (childrenD_357 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (3, 0)).mono (by decide +kernel) + · exact row_works_357_i0.mono (by decide +kernel) +theorem row_works_357 : Template HasSnaky 5 required_357 envelope_357 := by + refine compose HasSnaky 4 childrenC_357 childrenD_357 children_work_357 (2, 3) + required_357 envelope_357 pivot_mem_357 child_required_sub_357 child_envelope_sub_357 ?_ + intro b hb + exact common_sub_357 (mem_commonEnvelope childrenD_357 b hb) +def required_359_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_359_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 6), (0, 7), (0, 8), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_359_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 6) required_5), (placed21 2 (2, 2) required_9)] +def childrenD_359_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 6) envelope_5), (placed21 2 (2, 2) envelope_9)] +theorem common_sub_359_i0 : commonEnvelope childrenD_359_i0 ⊆ insert (1, 6) required_359_i0 := by decide +kernel +theorem child_required_sub_359_i0 : ∀ j, childrenC_359_i0 j ⊆ insert (1, 6) required_359_i0 := by decide +kernel +theorem child_envelope_sub_359_i0 : ∀ j, childrenD_359_i0 j ⊆ envelope_359_i0 := by decide +kernel +theorem pivot_mem_359_i0 : (1, 6) ∈ envelope_359_i0 := by decide +kernel +theorem children_work_359_i0 : ∀ j, Template HasSnaky 3 (childrenC_359_i0 j) (childrenD_359_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (2, 2)).mono (by decide +kernel) +theorem row_works_359_i0 : Template HasSnaky 4 required_359_i0 envelope_359_i0 := by + refine compose HasSnaky 3 childrenC_359_i0 childrenD_359_i0 children_work_359_i0 (1, 6) + required_359_i0 envelope_359_i0 pivot_mem_359_i0 child_required_sub_359_i0 child_envelope_sub_359_i0 ?_ + intro b hb + exact common_sub_359_i0 (mem_commonEnvelope childrenD_359_i0 b hb) +def required_359 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_359 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_359 : Fin 4 → Finset Cell := ![(placed21 4 (0, 6) required_10), (placed21 2 (1, 2) required_52), (placed21 6 (1, 6) required_52), required_359_i0] +def childrenD_359 : Fin 4 → Finset Cell := ![(placed21 4 (0, 6) envelope_10), (placed21 2 (1, 2) envelope_52), (placed21 6 (1, 6) envelope_52), envelope_359_i0] +theorem common_sub_359 : commonEnvelope childrenD_359 ⊆ insert (1, 4) required_359 := by decide +kernel +theorem child_required_sub_359 : ∀ j, childrenC_359 j ⊆ insert (1, 4) required_359 := by decide +kernel +theorem child_envelope_sub_359 : ∀ j, childrenD_359 j ⊆ envelope_359 := by decide +kernel +theorem pivot_mem_359 : (1, 4) ∈ envelope_359 := by decide +kernel +theorem children_work_359 : ∀ j, Template HasSnaky 4 (childrenC_359 j) (childrenD_359 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (1, 6)).mono (by decide +kernel) + · exact row_works_359_i0.mono (by decide +kernel) +theorem row_works_359 : Template HasSnaky 5 required_359 envelope_359 := by + refine compose HasSnaky 4 childrenC_359 childrenD_359 children_work_359 (1, 4) + required_359 envelope_359 pivot_mem_359 child_required_sub_359 child_envelope_sub_359 ?_ + intro b hb + exact common_sub_359 (mem_commonEnvelope childrenD_359 b hb) +def required_362_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_362_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 4), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_362_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) required_2), (placed21 6 (1, 6) required_53)] +def childrenD_362_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) envelope_2), (placed21 6 (1, 6) envelope_53)] +theorem common_sub_362_i0 : commonEnvelope childrenD_362_i0 ⊆ insert (1, 4) required_362_i0 := by decide +kernel +theorem child_required_sub_362_i0 : ∀ j, childrenC_362_i0 j ⊆ insert (1, 4) required_362_i0 := by decide +kernel +theorem child_envelope_sub_362_i0 : ∀ j, childrenD_362_i0 j ⊆ envelope_362_i0 := by decide +kernel +theorem pivot_mem_362_i0 : (1, 4) ∈ envelope_362_i0 := by decide +kernel +theorem children_work_362_i0 : ∀ j, Template HasSnaky 3 (childrenC_362_i0 j) (childrenD_362_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 6 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_53 6 (1, 6)).mono (by decide +kernel) +theorem row_works_362_i0 : Template HasSnaky 4 required_362_i0 envelope_362_i0 := by + refine compose HasSnaky 3 childrenC_362_i0 childrenD_362_i0 children_work_362_i0 (1, 4) + required_362_i0 envelope_362_i0 pivot_mem_362_i0 child_required_sub_362_i0 child_envelope_sub_362_i0 ?_ + intro b hb + exact common_sub_362_i0 (mem_commonEnvelope childrenD_362_i0 b hb) +def required_362 : Finset Cell := ⟨(([(0, 2), (0, 3), (3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_362 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_362 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_2), required_362_i0] +def childrenD_362 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_2), envelope_362_i0] +theorem common_sub_362 : commonEnvelope childrenD_362 ⊆ insert (1, 3) required_362 := by decide +kernel +theorem child_required_sub_362 : ∀ j, childrenC_362 j ⊆ insert (1, 3) required_362 := by decide +kernel +theorem child_envelope_sub_362 : ∀ j, childrenD_362 j ⊆ envelope_362 := by decide +kernel +theorem pivot_mem_362 : (1, 3) ∈ envelope_362 := by decide +kernel +theorem children_work_362 : ∀ j, Template HasSnaky 4 (childrenC_362 j) (childrenD_362 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 3)).mono (by decide +kernel) + · exact row_works_362_i0.mono (by decide +kernel) +theorem row_works_362 : Template HasSnaky 5 required_362 envelope_362 := by + refine compose HasSnaky 4 childrenC_362 childrenD_362 children_work_362 (1, 3) + required_362 envelope_362 pivot_mem_362 child_required_sub_362 child_envelope_sub_362 ?_ + intro b hb + exact common_sub_362 (mem_commonEnvelope childrenD_362 b hb) +def required_366 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_366 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_366 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) required_6), (placed21 2 (2, 0) required_365)] +def childrenD_366 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) envelope_6), (placed21 2 (2, 0) envelope_365)] +theorem common_sub_366 : commonEnvelope childrenD_366 ⊆ insert (1, 1) required_366 := by decide +kernel +theorem child_required_sub_366 : ∀ j, childrenC_366 j ⊆ insert (1, 1) required_366 := by decide +kernel +theorem child_envelope_sub_366 : ∀ j, childrenD_366 j ⊆ envelope_366 := by decide +kernel +theorem pivot_mem_366 : (1, 1) ∈ envelope_366 := by decide +kernel +theorem children_work_366 : ∀ j, Template HasSnaky 4 (childrenC_366 j) (childrenD_366 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_365 2 (2, 0)).mono (by decide +kernel) +theorem row_works_366 : Template HasSnaky 5 required_366 envelope_366 := by + refine compose HasSnaky 4 childrenC_366 childrenD_366 children_work_366 (1, 1) + required_366 envelope_366 pivot_mem_366 child_required_sub_366 child_envelope_sub_366 ?_ + intro b hb + exact common_sub_366 (mem_commonEnvelope childrenD_366 b hb) +def required_370_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 1), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_370_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (3, 1), (4, 1), (4, 2), (5, 1), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_370_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_16), required_210] +def childrenD_370_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_16), envelope_210] +theorem common_sub_370_i0 : commonEnvelope childrenD_370_i0 ⊆ insert (1, 2) required_370_i0 := by decide +kernel +theorem child_required_sub_370_i0 : ∀ j, childrenC_370_i0 j ⊆ insert (1, 2) required_370_i0 := by decide +kernel +theorem child_envelope_sub_370_i0 : ∀ j, childrenD_370_i0 j ⊆ envelope_370_i0 := by decide +kernel +theorem pivot_mem_370_i0 : (1, 2) ∈ envelope_370_i0 := by decide +kernel +theorem children_work_370_i0 : ∀ j, Template HasSnaky 3 (childrenC_370_i0 j) (childrenD_370_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_16 1 (1, 1)).mono (by decide +kernel) + · exact row_works_210.mono (by decide +kernel) +theorem row_works_370_i0 : Template HasSnaky 4 required_370_i0 envelope_370_i0 := by + refine compose HasSnaky 3 childrenC_370_i0 childrenD_370_i0 children_work_370_i0 (1, 2) + required_370_i0 envelope_370_i0 pivot_mem_370_i0 child_required_sub_370_i0 child_envelope_sub_370_i0 ?_ + intro b hb + exact common_sub_370_i0 (mem_commonEnvelope childrenD_370_i0 b hb) +def required_370 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_370 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (3, 0), (3, 1), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_370 : Fin 2 → Finset Cell := ![(placed21 3 (0, 1) required_6), required_370_i0] +def childrenD_370 : Fin 2 → Finset Cell := ![(placed21 3 (0, 1) envelope_6), envelope_370_i0] +theorem common_sub_370 : commonEnvelope childrenD_370 ⊆ insert (4, 1) required_370 := by decide +kernel +theorem child_required_sub_370 : ∀ j, childrenC_370 j ⊆ insert (4, 1) required_370 := by decide +kernel +theorem child_envelope_sub_370 : ∀ j, childrenD_370 j ⊆ envelope_370 := by decide +kernel +theorem pivot_mem_370 : (4, 1) ∈ envelope_370 := by decide +kernel +theorem children_work_370 : ∀ j, Template HasSnaky 4 (childrenC_370 j) (childrenD_370 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact row_works_370_i0.mono (by decide +kernel) +theorem row_works_370 : Template HasSnaky 5 required_370 envelope_370 := by + refine compose HasSnaky 4 childrenC_370 childrenD_370 children_work_370 (4, 1) + required_370 envelope_370 pivot_mem_370 child_required_sub_370 child_envelope_sub_370 ?_ + intro b hb + exact common_sub_370 (mem_commonEnvelope childrenD_370 b hb) +def required_377 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_377 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_377 : Fin 3 → Finset Cell := ![(placed21 2 (1, 0) required_7), required_9, (placed21 1 (0, 1) required_376)] +def childrenD_377 : Fin 3 → Finset Cell := ![(placed21 2 (1, 0) envelope_7), envelope_9, (placed21 1 (0, 1) envelope_376)] +theorem common_sub_377 : commonEnvelope childrenD_377 ⊆ insert (1, 4) required_377 := by decide +kernel +theorem child_required_sub_377 : ∀ j, childrenC_377 j ⊆ insert (1, 4) required_377 := by decide +kernel +theorem child_envelope_sub_377 : ∀ j, childrenD_377 j ⊆ envelope_377 := by decide +kernel +theorem pivot_mem_377 : (1, 4) ∈ envelope_377 := by decide +kernel +theorem children_work_377 : ∀ j, Template HasSnaky 4 (childrenC_377 j) (childrenD_377 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (1, 0)).mono (by decide +kernel) + · exact row_works_9.mono (by decide +kernel) + · exact (placed21_template row_works_376 1 (0, 1)).mono (by decide +kernel) +theorem row_works_377 : Template HasSnaky 5 required_377 envelope_377 := by + refine compose HasSnaky 4 childrenC_377 childrenD_377 children_work_377 (1, 4) + required_377 envelope_377 pivot_mem_377 child_required_sub_377 child_envelope_sub_377 ?_ + intro b hb + exact common_sub_377 (mem_commonEnvelope childrenD_377 b hb) +def required_382 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 4), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_382 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_382 : Fin 2 → Finset Cell := ![(placed21 2 (1, 0) required_22), (placed21 5 (4, 1) required_381)] +def childrenD_382 : Fin 2 → Finset Cell := ![(placed21 2 (1, 0) envelope_22), (placed21 5 (4, 1) envelope_381)] +theorem common_sub_382 : commonEnvelope childrenD_382 ⊆ insert (1, 4) required_382 := by decide +kernel +theorem child_required_sub_382 : ∀ j, childrenC_382 j ⊆ insert (1, 4) required_382 := by decide +kernel +theorem child_envelope_sub_382 : ∀ j, childrenD_382 j ⊆ envelope_382 := by decide +kernel +theorem pivot_mem_382 : (1, 4) ∈ envelope_382 := by decide +kernel +theorem children_work_382 : ∀ j, Template HasSnaky 4 (childrenC_382 j) (childrenD_382 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 2 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_381 5 (4, 1)).mono (by decide +kernel) +theorem row_works_382 : Template HasSnaky 5 required_382 envelope_382 := by + refine compose HasSnaky 4 childrenC_382 childrenD_382 children_work_382 (1, 4) + required_382 envelope_382 pivot_mem_382 child_required_sub_382 child_envelope_sub_382 ?_ + intro b hb + exact common_sub_382 (mem_commonEnvelope childrenD_382 b hb) +def required_383_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 5), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_383_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_383_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), (placed21 4 (2, 5) required_219)] +def childrenD_383_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), (placed21 4 (2, 5) envelope_219)] +theorem common_sub_383_i0 : commonEnvelope childrenD_383_i0 ⊆ insert (3, 3) required_383_i0 := by decide +kernel +theorem child_required_sub_383_i0 : ∀ j, childrenC_383_i0 j ⊆ insert (3, 3) required_383_i0 := by decide +kernel +theorem child_envelope_sub_383_i0 : ∀ j, childrenD_383_i0 j ⊆ envelope_383_i0 := by decide +kernel +theorem pivot_mem_383_i0 : (3, 3) ∈ envelope_383_i0 := by decide +kernel +theorem children_work_383_i0 : ∀ j, Template HasSnaky 3 (childrenC_383_i0 j) (childrenD_383_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_219 4 (2, 5)).mono (by decide +kernel) +theorem row_works_383_i0 : Template HasSnaky 4 required_383_i0 envelope_383_i0 := by + refine compose HasSnaky 3 childrenC_383_i0 childrenD_383_i0 children_work_383_i0 (3, 3) + required_383_i0 envelope_383_i0 pivot_mem_383_i0 child_required_sub_383_i0 child_envelope_sub_383_i0 ?_ + intro b hb + exact common_sub_383_i0 (mem_commonEnvelope childrenD_383_i0 b hb) +def required_383 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 5), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_383 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_383 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_5), required_383_i0] +def childrenD_383 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_5), envelope_383_i0] +theorem common_sub_383 : commonEnvelope childrenD_383 ⊆ insert (3, 1) required_383 := by decide +kernel +theorem child_required_sub_383 : ∀ j, childrenC_383 j ⊆ insert (3, 1) required_383 := by decide +kernel +theorem child_envelope_sub_383 : ∀ j, childrenD_383 j ⊆ envelope_383 := by decide +kernel +theorem pivot_mem_383 : (3, 1) ∈ envelope_383 := by decide +kernel +theorem children_work_383 : ∀ j, Template HasSnaky 4 (childrenC_383 j) (childrenD_383 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact row_works_383_i0.mono (by decide +kernel) +theorem row_works_383 : Template HasSnaky 5 required_383 envelope_383 := by + refine compose HasSnaky 4 childrenC_383 childrenD_383 children_work_383 (3, 1) + required_383 envelope_383 pivot_mem_383 child_required_sub_383 child_envelope_sub_383 ?_ + intro b hb + exact common_sub_383 (mem_commonEnvelope childrenD_383 b hb) +def required_386_i1 : Finset Cell := ⟨(([(2, 2), (2, 4), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_386_i1 : Finset Cell := ⟨(([(2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_386_i1 : Fin 2 → Finset Cell := ![(placed21 5 (3, 1) required_5), (placed21 2 (3, 0) required_11)] +def childrenD_386_i1 : Fin 2 → Finset Cell := ![(placed21 5 (3, 1) envelope_5), (placed21 2 (3, 0) envelope_11)] +theorem common_sub_386_i1 : commonEnvelope childrenD_386_i1 ⊆ insert (3, 4) required_386_i1 := by decide +kernel +theorem child_required_sub_386_i1 : ∀ j, childrenC_386_i1 j ⊆ insert (3, 4) required_386_i1 := by decide +kernel +theorem child_envelope_sub_386_i1 : ∀ j, childrenD_386_i1 j ⊆ envelope_386_i1 := by decide +kernel +theorem pivot_mem_386_i1 : (3, 4) ∈ envelope_386_i1 := by decide +kernel +theorem children_work_386_i1 : ∀ j, Template HasSnaky 2 (childrenC_386_i1 j) (childrenD_386_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_11 2 (3, 0)).mono (by decide +kernel) +theorem row_works_386_i1 : Template HasSnaky 3 required_386_i1 envelope_386_i1 := by + refine compose HasSnaky 2 childrenC_386_i1 childrenD_386_i1 children_work_386_i1 (3, 4) + required_386_i1 envelope_386_i1 pivot_mem_386_i1 child_required_sub_386_i1 child_envelope_sub_386_i1 ?_ + intro b hb + exact common_sub_386_i1 (mem_commonEnvelope childrenD_386_i1 b hb) +def required_386_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 4), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_386_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_386_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), required_386_i1] +def childrenD_386_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), envelope_386_i1] +theorem common_sub_386_i0 : commonEnvelope childrenD_386_i0 ⊆ insert (3, 3) required_386_i0 := by decide +kernel +theorem child_required_sub_386_i0 : ∀ j, childrenC_386_i0 j ⊆ insert (3, 3) required_386_i0 := by decide +kernel +theorem child_envelope_sub_386_i0 : ∀ j, childrenD_386_i0 j ⊆ envelope_386_i0 := by decide +kernel +theorem pivot_mem_386_i0 : (3, 3) ∈ envelope_386_i0 := by decide +kernel +theorem children_work_386_i0 : ∀ j, Template HasSnaky 3 (childrenC_386_i0 j) (childrenD_386_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact row_works_386_i1.mono (by decide +kernel) +theorem row_works_386_i0 : Template HasSnaky 4 required_386_i0 envelope_386_i0 := by + refine compose HasSnaky 3 childrenC_386_i0 childrenD_386_i0 children_work_386_i0 (3, 3) + required_386_i0 envelope_386_i0 pivot_mem_386_i0 child_required_sub_386_i0 child_envelope_sub_386_i0 ?_ + intro b hb + exact common_sub_386_i0 (mem_commonEnvelope childrenD_386_i0 b hb) +def required_386 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 4), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_386 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_386 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_5), required_386_i0] +def childrenD_386 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_5), envelope_386_i0] +theorem common_sub_386 : commonEnvelope childrenD_386 ⊆ insert (3, 1) required_386 := by decide +kernel +theorem child_required_sub_386 : ∀ j, childrenC_386 j ⊆ insert (3, 1) required_386 := by decide +kernel +theorem child_envelope_sub_386 : ∀ j, childrenD_386 j ⊆ envelope_386 := by decide +kernel +theorem pivot_mem_386 : (3, 1) ∈ envelope_386 := by decide +kernel +theorem children_work_386 : ∀ j, Template HasSnaky 4 (childrenC_386 j) (childrenD_386 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact row_works_386_i0.mono (by decide +kernel) +theorem row_works_386 : Template HasSnaky 5 required_386 envelope_386 := by + refine compose HasSnaky 4 childrenC_386 childrenD_386 children_work_386 (3, 1) + required_386 envelope_386 pivot_mem_386 child_required_sub_386 child_envelope_sub_386 ?_ + intro b hb + exact common_sub_386 (mem_commonEnvelope childrenD_386 b hb) +def required_389_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_389_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_389_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_5), (placed21 0 (0, 1) required_23)] +def childrenD_389_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_5), (placed21 0 (0, 1) envelope_23)] +theorem common_sub_389_i0 : commonEnvelope childrenD_389_i0 ⊆ insert (1, 3) required_389_i0 := by decide +kernel +theorem child_required_sub_389_i0 : ∀ j, childrenC_389_i0 j ⊆ insert (1, 3) required_389_i0 := by decide +kernel +theorem child_envelope_sub_389_i0 : ∀ j, childrenD_389_i0 j ⊆ envelope_389_i0 := by decide +kernel +theorem pivot_mem_389_i0 : (1, 3) ∈ envelope_389_i0 := by decide +kernel +theorem children_work_389_i0 : ∀ j, Template HasSnaky 2 (childrenC_389_i0 j) (childrenD_389_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_23 0 (0, 1)).mono (by decide +kernel) +theorem row_works_389_i0 : Template HasSnaky 3 required_389_i0 envelope_389_i0 := by + refine compose HasSnaky 2 childrenC_389_i0 childrenD_389_i0 children_work_389_i0 (1, 3) + required_389_i0 envelope_389_i0 pivot_mem_389_i0 child_required_sub_389_i0 child_envelope_sub_389_i0 ?_ + intro b hb + exact common_sub_389_i0 (mem_commonEnvelope childrenD_389_i0 b hb) +def required_389 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_389 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_389 : Fin 4 → Finset Cell := ![required_6, (placed21 0 (0, 1) required_21), (placed21 0 (0, 1) required_27), required_389_i0] +def childrenD_389 : Fin 4 → Finset Cell := ![envelope_6, (placed21 0 (0, 1) envelope_21), (placed21 0 (0, 1) envelope_27), envelope_389_i0] +theorem common_sub_389 : commonEnvelope childrenD_389 ⊆ insert (0, 4) required_389 := by decide +kernel +theorem child_required_sub_389 : ∀ j, childrenC_389 j ⊆ insert (0, 4) required_389 := by decide +kernel +theorem child_envelope_sub_389 : ∀ j, childrenD_389 j ⊆ envelope_389 := by decide +kernel +theorem pivot_mem_389 : (0, 4) ∈ envelope_389 := by decide +kernel +theorem children_work_389 : ∀ j, Template HasSnaky 4 (childrenC_389 j) (childrenD_389 j) := by + intro j + fin_cases j + · exact row_works_6.mono (by decide +kernel) + · exact (placed21_template row_works_21 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_27 0 (0, 1)).mono (by decide +kernel) + · exact row_works_389_i0.mono (by decide +kernel) +theorem row_works_389 : Template HasSnaky 5 required_389 envelope_389 := by + refine compose HasSnaky 4 childrenC_389 childrenD_389 children_work_389 (0, 4) + required_389 envelope_389 pivot_mem_389 child_required_sub_389 child_envelope_sub_389 ?_ + intro b hb + exact common_sub_389 (mem_commonEnvelope childrenD_389 b hb) +def height_356_i0 : ℕ := 4 +def childrenH_356_i0 : Fin 2 → ℕ := ![height_21, height_121] +theorem height_exact_356_i0 : height_356_i0 = 1 + Finset.univ.sup childrenH_356_i0 := by decide +kernel +theorem required_origin_356_i0 : ∀ x ∈ required_356_i0, + (∃ j, x ∈ childrenC_356_i0 j) ∨ ∀ j, x ∈ childrenD_356_i0 j := by decide +kernel +theorem required_exact_356_i0 : required_356_i0 = + ((Finset.univ.biUnion childrenC_356_i0) ∪ commonEnvelope childrenD_356_i0).erase (2, 3) := by + exact required_eq_combination childrenC_356_i0 childrenD_356_i0 (2, 3) required_356_i0 + (by decide +kernel) child_required_sub_356_i0 common_sub_356_i0 required_origin_356_i0 +theorem envelope_origin_356_i0 : ∀ x ∈ envelope_356_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_356_i0 j := by decide +kernel +theorem envelope_exact_356_i0 : envelope_356_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_356_i0) := by + exact envelope_eq_combination childrenD_356_i0 (2, 3) envelope_356_i0 + pivot_mem_356_i0 child_envelope_sub_356_i0 envelope_origin_356_i0 +def checked_356_i0 : CheckedCard where + required := required_356_i0 + envelope := envelope_356_i0 + height := height_356_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_356_i0 +def height_356 : ℕ := 5 +def childrenH_356 : Fin 3 → ℕ := ![height_7, height_8, height_356_i0] +theorem height_exact_356 : height_356 = 1 + Finset.univ.sup childrenH_356 := by decide +kernel +theorem required_origin_356 : ∀ x ∈ required_356, + (∃ j, x ∈ childrenC_356 j) ∨ ∀ j, x ∈ childrenD_356 j := by decide +kernel +theorem required_exact_356 : required_356 = + ((Finset.univ.biUnion childrenC_356) ∪ commonEnvelope childrenD_356).erase (3, 5) := by + exact required_eq_combination childrenC_356 childrenD_356 (3, 5) required_356 + (by decide +kernel) child_required_sub_356 common_sub_356 required_origin_356 +theorem envelope_origin_356 : ∀ x ∈ envelope_356, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_356 j := by decide +kernel +theorem envelope_exact_356 : envelope_356 = + insert (3, 5) (Finset.univ.biUnion childrenD_356) := by + exact envelope_eq_combination childrenD_356 (3, 5) envelope_356 + pivot_mem_356 child_envelope_sub_356 envelope_origin_356 +def checked_356 : CheckedCard where + required := required_356 + envelope := envelope_356 + height := height_356 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_356 +def height_357_i2 : ℕ := 2 +def childrenH_357_i2 : Fin 2 → ℕ := ![height_3, height_5] +theorem height_exact_357_i2 : height_357_i2 = 1 + Finset.univ.sup childrenH_357_i2 := by decide +kernel +theorem required_origin_357_i2 : ∀ x ∈ required_357_i2, + (∃ j, x ∈ childrenC_357_i2 j) ∨ ∀ j, x ∈ childrenD_357_i2 j := by decide +kernel +theorem required_exact_357_i2 : required_357_i2 = + ((Finset.univ.biUnion childrenC_357_i2) ∪ commonEnvelope childrenD_357_i2).erase (1, 4) := by + exact required_eq_combination childrenC_357_i2 childrenD_357_i2 (1, 4) required_357_i2 + (by decide +kernel) child_required_sub_357_i2 common_sub_357_i2 required_origin_357_i2 +theorem envelope_origin_357_i2 : ∀ x ∈ envelope_357_i2, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_357_i2 j := by decide +kernel +theorem envelope_exact_357_i2 : envelope_357_i2 = + insert (1, 4) (Finset.univ.biUnion childrenD_357_i2) := by + exact envelope_eq_combination childrenD_357_i2 (1, 4) envelope_357_i2 + pivot_mem_357_i2 child_envelope_sub_357_i2 envelope_origin_357_i2 +def checked_357_i2 : CheckedCard where + required := required_357_i2 + envelope := envelope_357_i2 + height := height_357_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_357_i2 +def height_357_i1 : ℕ := 3 +def childrenH_357_i1 : Fin 2 → ℕ := ![height_4, height_357_i2] +theorem height_exact_357_i1 : height_357_i1 = 1 + Finset.univ.sup childrenH_357_i1 := by decide +kernel +theorem required_origin_357_i1 : ∀ x ∈ required_357_i1, + (∃ j, x ∈ childrenC_357_i1 j) ∨ ∀ j, x ∈ childrenD_357_i1 j := by decide +kernel +theorem required_exact_357_i1 : required_357_i1 = + ((Finset.univ.biUnion childrenC_357_i1) ∪ commonEnvelope childrenD_357_i1).erase (1, 3) := by + exact required_eq_combination childrenC_357_i1 childrenD_357_i1 (1, 3) required_357_i1 + (by decide +kernel) child_required_sub_357_i1 common_sub_357_i1 required_origin_357_i1 +theorem envelope_origin_357_i1 : ∀ x ∈ envelope_357_i1, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_357_i1 j := by decide +kernel +theorem envelope_exact_357_i1 : envelope_357_i1 = + insert (1, 3) (Finset.univ.biUnion childrenD_357_i1) := by + exact envelope_eq_combination childrenD_357_i1 (1, 3) envelope_357_i1 + pivot_mem_357_i1 child_envelope_sub_357_i1 envelope_origin_357_i1 +def checked_357_i1 : CheckedCard where + required := required_357_i1 + envelope := envelope_357_i1 + height := height_357_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_357_i1 +def height_357_i0 : ℕ := 4 +def childrenH_357_i0 : Fin 2 → ℕ := ![height_5, height_357_i1] +theorem height_exact_357_i0 : height_357_i0 = 1 + Finset.univ.sup childrenH_357_i0 := by decide +kernel +theorem required_origin_357_i0 : ∀ x ∈ required_357_i0, + (∃ j, x ∈ childrenC_357_i0 j) ∨ ∀ j, x ∈ childrenD_357_i0 j := by decide +kernel +theorem required_exact_357_i0 : required_357_i0 = + ((Finset.univ.biUnion childrenC_357_i0) ∪ commonEnvelope childrenD_357_i0).erase (4, 3) := by + exact required_eq_combination childrenC_357_i0 childrenD_357_i0 (4, 3) required_357_i0 + (by decide +kernel) child_required_sub_357_i0 common_sub_357_i0 required_origin_357_i0 +theorem envelope_origin_357_i0 : ∀ x ∈ envelope_357_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_357_i0 j := by decide +kernel +theorem envelope_exact_357_i0 : envelope_357_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_357_i0) := by + exact envelope_eq_combination childrenD_357_i0 (4, 3) envelope_357_i0 + pivot_mem_357_i0 child_envelope_sub_357_i0 envelope_origin_357_i0 +def checked_357_i0 : CheckedCard where + required := required_357_i0 + envelope := envelope_357_i0 + height := height_357_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_357_i0 +def height_357 : ℕ := 5 +def childrenH_357 : Fin 2 → ℕ := ![height_5, height_357_i0] +theorem height_exact_357 : height_357 = 1 + Finset.univ.sup childrenH_357 := by decide +kernel +theorem required_origin_357 : ∀ x ∈ required_357, + (∃ j, x ∈ childrenC_357 j) ∨ ∀ j, x ∈ childrenD_357 j := by decide +kernel +theorem required_exact_357 : required_357 = + ((Finset.univ.biUnion childrenC_357) ∪ commonEnvelope childrenD_357).erase (2, 3) := by + exact required_eq_combination childrenC_357 childrenD_357 (2, 3) required_357 + (by decide +kernel) child_required_sub_357 common_sub_357 required_origin_357 +theorem envelope_origin_357 : ∀ x ∈ envelope_357, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_357 j := by decide +kernel +theorem envelope_exact_357 : envelope_357 = + insert (2, 3) (Finset.univ.biUnion childrenD_357) := by + exact envelope_eq_combination childrenD_357 (2, 3) envelope_357 + pivot_mem_357 child_envelope_sub_357 envelope_origin_357 +def checked_357 : CheckedCard where + required := required_357 + envelope := envelope_357 + height := height_357 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_357 +def height_359_i0 : ℕ := 4 +def childrenH_359_i0 : Fin 2 → ℕ := ![height_5, height_9] +theorem height_exact_359_i0 : height_359_i0 = 1 + Finset.univ.sup childrenH_359_i0 := by decide +kernel +theorem required_origin_359_i0 : ∀ x ∈ required_359_i0, + (∃ j, x ∈ childrenC_359_i0 j) ∨ ∀ j, x ∈ childrenD_359_i0 j := by decide +kernel +theorem required_exact_359_i0 : required_359_i0 = + ((Finset.univ.biUnion childrenC_359_i0) ∪ commonEnvelope childrenD_359_i0).erase (1, 6) := by + exact required_eq_combination childrenC_359_i0 childrenD_359_i0 (1, 6) required_359_i0 + (by decide +kernel) child_required_sub_359_i0 common_sub_359_i0 required_origin_359_i0 +theorem envelope_origin_359_i0 : ∀ x ∈ envelope_359_i0, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_359_i0 j := by decide +kernel +theorem envelope_exact_359_i0 : envelope_359_i0 = + insert (1, 6) (Finset.univ.biUnion childrenD_359_i0) := by + exact envelope_eq_combination childrenD_359_i0 (1, 6) envelope_359_i0 + pivot_mem_359_i0 child_envelope_sub_359_i0 envelope_origin_359_i0 +def checked_359_i0 : CheckedCard where + required := required_359_i0 + envelope := envelope_359_i0 + height := height_359_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_359_i0 +def height_359 : ℕ := 5 +def childrenH_359 : Fin 4 → ℕ := ![height_10, height_52, height_52, height_359_i0] +theorem height_exact_359 : height_359 = 1 + Finset.univ.sup childrenH_359 := by decide +kernel +theorem required_origin_359 : ∀ x ∈ required_359, + (∃ j, x ∈ childrenC_359 j) ∨ ∀ j, x ∈ childrenD_359 j := by decide +kernel +theorem required_exact_359 : required_359 = + ((Finset.univ.biUnion childrenC_359) ∪ commonEnvelope childrenD_359).erase (1, 4) := by + exact required_eq_combination childrenC_359 childrenD_359 (1, 4) required_359 + (by decide +kernel) child_required_sub_359 common_sub_359 required_origin_359 +theorem envelope_origin_359 : ∀ x ∈ envelope_359, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_359 j := by decide +kernel +theorem envelope_exact_359 : envelope_359 = + insert (1, 4) (Finset.univ.biUnion childrenD_359) := by + exact envelope_eq_combination childrenD_359 (1, 4) envelope_359 + pivot_mem_359 child_envelope_sub_359 envelope_origin_359 +def checked_359 : CheckedCard where + required := required_359 + envelope := envelope_359 + height := height_359 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_359 +def height_362_i0 : ℕ := 4 +def childrenH_362_i0 : Fin 2 → ℕ := ![height_2, height_53] +theorem height_exact_362_i0 : height_362_i0 = 1 + Finset.univ.sup childrenH_362_i0 := by decide +kernel +theorem required_origin_362_i0 : ∀ x ∈ required_362_i0, + (∃ j, x ∈ childrenC_362_i0 j) ∨ ∀ j, x ∈ childrenD_362_i0 j := by decide +kernel +theorem required_exact_362_i0 : required_362_i0 = + ((Finset.univ.biUnion childrenC_362_i0) ∪ commonEnvelope childrenD_362_i0).erase (1, 4) := by + exact required_eq_combination childrenC_362_i0 childrenD_362_i0 (1, 4) required_362_i0 + (by decide +kernel) child_required_sub_362_i0 common_sub_362_i0 required_origin_362_i0 +theorem envelope_origin_362_i0 : ∀ x ∈ envelope_362_i0, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_362_i0 j := by decide +kernel +theorem envelope_exact_362_i0 : envelope_362_i0 = + insert (1, 4) (Finset.univ.biUnion childrenD_362_i0) := by + exact envelope_eq_combination childrenD_362_i0 (1, 4) envelope_362_i0 + pivot_mem_362_i0 child_envelope_sub_362_i0 envelope_origin_362_i0 +def checked_362_i0 : CheckedCard where + required := required_362_i0 + envelope := envelope_362_i0 + height := height_362_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_362_i0 +def height_362 : ℕ := 5 +def childrenH_362 : Fin 2 → ℕ := ![height_2, height_362_i0] +theorem height_exact_362 : height_362 = 1 + Finset.univ.sup childrenH_362 := by decide +kernel +theorem required_origin_362 : ∀ x ∈ required_362, + (∃ j, x ∈ childrenC_362 j) ∨ ∀ j, x ∈ childrenD_362 j := by decide +kernel +theorem required_exact_362 : required_362 = + ((Finset.univ.biUnion childrenC_362) ∪ commonEnvelope childrenD_362).erase (1, 3) := by + exact required_eq_combination childrenC_362 childrenD_362 (1, 3) required_362 + (by decide +kernel) child_required_sub_362 common_sub_362 required_origin_362 +theorem envelope_origin_362 : ∀ x ∈ envelope_362, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_362 j := by decide +kernel +theorem envelope_exact_362 : envelope_362 = + insert (1, 3) (Finset.univ.biUnion childrenD_362) := by + exact envelope_eq_combination childrenD_362 (1, 3) envelope_362 + pivot_mem_362 child_envelope_sub_362 envelope_origin_362 +def checked_362 : CheckedCard where + required := required_362 + envelope := envelope_362 + height := height_362 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_362 +def height_366 : ℕ := 5 +def childrenH_366 : Fin 2 → ℕ := ![height_6, height_365] +theorem height_exact_366 : height_366 = 1 + Finset.univ.sup childrenH_366 := by decide +kernel +theorem required_origin_366 : ∀ x ∈ required_366, + (∃ j, x ∈ childrenC_366 j) ∨ ∀ j, x ∈ childrenD_366 j := by decide +kernel +theorem required_exact_366 : required_366 = + ((Finset.univ.biUnion childrenC_366) ∪ commonEnvelope childrenD_366).erase (1, 1) := by + exact required_eq_combination childrenC_366 childrenD_366 (1, 1) required_366 + (by decide +kernel) child_required_sub_366 common_sub_366 required_origin_366 +theorem envelope_origin_366 : ∀ x ∈ envelope_366, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_366 j := by decide +kernel +theorem envelope_exact_366 : envelope_366 = + insert (1, 1) (Finset.univ.biUnion childrenD_366) := by + exact envelope_eq_combination childrenD_366 (1, 1) envelope_366 + pivot_mem_366 child_envelope_sub_366 envelope_origin_366 +def checked_366 : CheckedCard where + required := required_366 + envelope := envelope_366 + height := height_366 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_366 +def height_370_i0 : ℕ := 4 +def childrenH_370_i0 : Fin 2 → ℕ := ![height_16, height_210] +theorem height_exact_370_i0 : height_370_i0 = 1 + Finset.univ.sup childrenH_370_i0 := by decide +kernel +theorem required_origin_370_i0 : ∀ x ∈ required_370_i0, + (∃ j, x ∈ childrenC_370_i0 j) ∨ ∀ j, x ∈ childrenD_370_i0 j := by decide +kernel +theorem required_exact_370_i0 : required_370_i0 = + ((Finset.univ.biUnion childrenC_370_i0) ∪ commonEnvelope childrenD_370_i0).erase (1, 2) := by + exact required_eq_combination childrenC_370_i0 childrenD_370_i0 (1, 2) required_370_i0 + (by decide +kernel) child_required_sub_370_i0 common_sub_370_i0 required_origin_370_i0 +theorem envelope_origin_370_i0 : ∀ x ∈ envelope_370_i0, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_370_i0 j := by decide +kernel +theorem envelope_exact_370_i0 : envelope_370_i0 = + insert (1, 2) (Finset.univ.biUnion childrenD_370_i0) := by + exact envelope_eq_combination childrenD_370_i0 (1, 2) envelope_370_i0 + pivot_mem_370_i0 child_envelope_sub_370_i0 envelope_origin_370_i0 +def checked_370_i0 : CheckedCard where + required := required_370_i0 + envelope := envelope_370_i0 + height := height_370_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_370_i0 +def height_370 : ℕ := 5 +def childrenH_370 : Fin 2 → ℕ := ![height_6, height_370_i0] +theorem height_exact_370 : height_370 = 1 + Finset.univ.sup childrenH_370 := by decide +kernel +theorem required_origin_370 : ∀ x ∈ required_370, + (∃ j, x ∈ childrenC_370 j) ∨ ∀ j, x ∈ childrenD_370 j := by decide +kernel +theorem required_exact_370 : required_370 = + ((Finset.univ.biUnion childrenC_370) ∪ commonEnvelope childrenD_370).erase (4, 1) := by + exact required_eq_combination childrenC_370 childrenD_370 (4, 1) required_370 + (by decide +kernel) child_required_sub_370 common_sub_370 required_origin_370 +theorem envelope_origin_370 : ∀ x ∈ envelope_370, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_370 j := by decide +kernel +theorem envelope_exact_370 : envelope_370 = + insert (4, 1) (Finset.univ.biUnion childrenD_370) := by + exact envelope_eq_combination childrenD_370 (4, 1) envelope_370 + pivot_mem_370 child_envelope_sub_370 envelope_origin_370 +def checked_370 : CheckedCard where + required := required_370 + envelope := envelope_370 + height := height_370 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_370 +def height_377 : ℕ := 5 +def childrenH_377 : Fin 3 → ℕ := ![height_7, height_9, height_376] +theorem height_exact_377 : height_377 = 1 + Finset.univ.sup childrenH_377 := by decide +kernel +theorem required_origin_377 : ∀ x ∈ required_377, + (∃ j, x ∈ childrenC_377 j) ∨ ∀ j, x ∈ childrenD_377 j := by decide +kernel +theorem required_exact_377 : required_377 = + ((Finset.univ.biUnion childrenC_377) ∪ commonEnvelope childrenD_377).erase (1, 4) := by + exact required_eq_combination childrenC_377 childrenD_377 (1, 4) required_377 + (by decide +kernel) child_required_sub_377 common_sub_377 required_origin_377 +theorem envelope_origin_377 : ∀ x ∈ envelope_377, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_377 j := by decide +kernel +theorem envelope_exact_377 : envelope_377 = + insert (1, 4) (Finset.univ.biUnion childrenD_377) := by + exact envelope_eq_combination childrenD_377 (1, 4) envelope_377 + pivot_mem_377 child_envelope_sub_377 envelope_origin_377 +def checked_377 : CheckedCard where + required := required_377 + envelope := envelope_377 + height := height_377 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_377 +def height_382 : ℕ := 5 +def childrenH_382 : Fin 2 → ℕ := ![height_22, height_381] +theorem height_exact_382 : height_382 = 1 + Finset.univ.sup childrenH_382 := by decide +kernel +theorem required_origin_382 : ∀ x ∈ required_382, + (∃ j, x ∈ childrenC_382 j) ∨ ∀ j, x ∈ childrenD_382 j := by decide +kernel +theorem required_exact_382 : required_382 = + ((Finset.univ.biUnion childrenC_382) ∪ commonEnvelope childrenD_382).erase (1, 4) := by + exact required_eq_combination childrenC_382 childrenD_382 (1, 4) required_382 + (by decide +kernel) child_required_sub_382 common_sub_382 required_origin_382 +theorem envelope_origin_382 : ∀ x ∈ envelope_382, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_382 j := by decide +kernel +theorem envelope_exact_382 : envelope_382 = + insert (1, 4) (Finset.univ.biUnion childrenD_382) := by + exact envelope_eq_combination childrenD_382 (1, 4) envelope_382 + pivot_mem_382 child_envelope_sub_382 envelope_origin_382 +def checked_382 : CheckedCard where + required := required_382 + envelope := envelope_382 + height := height_382 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_382 +def height_383_i0 : ℕ := 4 +def childrenH_383_i0 : Fin 2 → ℕ := ![height_5, height_219] +theorem height_exact_383_i0 : height_383_i0 = 1 + Finset.univ.sup childrenH_383_i0 := by decide +kernel +theorem required_origin_383_i0 : ∀ x ∈ required_383_i0, + (∃ j, x ∈ childrenC_383_i0 j) ∨ ∀ j, x ∈ childrenD_383_i0 j := by decide +kernel +theorem required_exact_383_i0 : required_383_i0 = + ((Finset.univ.biUnion childrenC_383_i0) ∪ commonEnvelope childrenD_383_i0).erase (3, 3) := by + exact required_eq_combination childrenC_383_i0 childrenD_383_i0 (3, 3) required_383_i0 + (by decide +kernel) child_required_sub_383_i0 common_sub_383_i0 required_origin_383_i0 +theorem envelope_origin_383_i0 : ∀ x ∈ envelope_383_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_383_i0 j := by decide +kernel +theorem envelope_exact_383_i0 : envelope_383_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_383_i0) := by + exact envelope_eq_combination childrenD_383_i0 (3, 3) envelope_383_i0 + pivot_mem_383_i0 child_envelope_sub_383_i0 envelope_origin_383_i0 +def checked_383_i0 : CheckedCard where + required := required_383_i0 + envelope := envelope_383_i0 + height := height_383_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_383_i0 +def height_383 : ℕ := 5 +def childrenH_383 : Fin 2 → ℕ := ![height_5, height_383_i0] +theorem height_exact_383 : height_383 = 1 + Finset.univ.sup childrenH_383 := by decide +kernel +theorem required_origin_383 : ∀ x ∈ required_383, + (∃ j, x ∈ childrenC_383 j) ∨ ∀ j, x ∈ childrenD_383 j := by decide +kernel +theorem required_exact_383 : required_383 = + ((Finset.univ.biUnion childrenC_383) ∪ commonEnvelope childrenD_383).erase (3, 1) := by + exact required_eq_combination childrenC_383 childrenD_383 (3, 1) required_383 + (by decide +kernel) child_required_sub_383 common_sub_383 required_origin_383 +theorem envelope_origin_383 : ∀ x ∈ envelope_383, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_383 j := by decide +kernel +theorem envelope_exact_383 : envelope_383 = + insert (3, 1) (Finset.univ.biUnion childrenD_383) := by + exact envelope_eq_combination childrenD_383 (3, 1) envelope_383 + pivot_mem_383 child_envelope_sub_383 envelope_origin_383 +def checked_383 : CheckedCard where + required := required_383 + envelope := envelope_383 + height := height_383 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_383 +def height_386_i1 : ℕ := 3 +def childrenH_386_i1 : Fin 2 → ℕ := ![height_5, height_11] +theorem height_exact_386_i1 : height_386_i1 = 1 + Finset.univ.sup childrenH_386_i1 := by decide +kernel +theorem required_origin_386_i1 : ∀ x ∈ required_386_i1, + (∃ j, x ∈ childrenC_386_i1 j) ∨ ∀ j, x ∈ childrenD_386_i1 j := by decide +kernel +theorem required_exact_386_i1 : required_386_i1 = + ((Finset.univ.biUnion childrenC_386_i1) ∪ commonEnvelope childrenD_386_i1).erase (3, 4) := by + exact required_eq_combination childrenC_386_i1 childrenD_386_i1 (3, 4) required_386_i1 + (by decide +kernel) child_required_sub_386_i1 common_sub_386_i1 required_origin_386_i1 +theorem envelope_origin_386_i1 : ∀ x ∈ envelope_386_i1, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_386_i1 j := by decide +kernel +theorem envelope_exact_386_i1 : envelope_386_i1 = + insert (3, 4) (Finset.univ.biUnion childrenD_386_i1) := by + exact envelope_eq_combination childrenD_386_i1 (3, 4) envelope_386_i1 + pivot_mem_386_i1 child_envelope_sub_386_i1 envelope_origin_386_i1 +def checked_386_i1 : CheckedCard where + required := required_386_i1 + envelope := envelope_386_i1 + height := height_386_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_386_i1 +def height_386_i0 : ℕ := 4 +def childrenH_386_i0 : Fin 2 → ℕ := ![height_5, height_386_i1] +theorem height_exact_386_i0 : height_386_i0 = 1 + Finset.univ.sup childrenH_386_i0 := by decide +kernel +theorem required_origin_386_i0 : ∀ x ∈ required_386_i0, + (∃ j, x ∈ childrenC_386_i0 j) ∨ ∀ j, x ∈ childrenD_386_i0 j := by decide +kernel +theorem required_exact_386_i0 : required_386_i0 = + ((Finset.univ.biUnion childrenC_386_i0) ∪ commonEnvelope childrenD_386_i0).erase (3, 3) := by + exact required_eq_combination childrenC_386_i0 childrenD_386_i0 (3, 3) required_386_i0 + (by decide +kernel) child_required_sub_386_i0 common_sub_386_i0 required_origin_386_i0 +theorem envelope_origin_386_i0 : ∀ x ∈ envelope_386_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_386_i0 j := by decide +kernel +theorem envelope_exact_386_i0 : envelope_386_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_386_i0) := by + exact envelope_eq_combination childrenD_386_i0 (3, 3) envelope_386_i0 + pivot_mem_386_i0 child_envelope_sub_386_i0 envelope_origin_386_i0 +def checked_386_i0 : CheckedCard where + required := required_386_i0 + envelope := envelope_386_i0 + height := height_386_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_386_i0 +def height_386 : ℕ := 5 +def childrenH_386 : Fin 2 → ℕ := ![height_5, height_386_i0] +theorem height_exact_386 : height_386 = 1 + Finset.univ.sup childrenH_386 := by decide +kernel +theorem required_origin_386 : ∀ x ∈ required_386, + (∃ j, x ∈ childrenC_386 j) ∨ ∀ j, x ∈ childrenD_386 j := by decide +kernel +theorem required_exact_386 : required_386 = + ((Finset.univ.biUnion childrenC_386) ∪ commonEnvelope childrenD_386).erase (3, 1) := by + exact required_eq_combination childrenC_386 childrenD_386 (3, 1) required_386 + (by decide +kernel) child_required_sub_386 common_sub_386 required_origin_386 +theorem envelope_origin_386 : ∀ x ∈ envelope_386, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_386 j := by decide +kernel +theorem envelope_exact_386 : envelope_386 = + insert (3, 1) (Finset.univ.biUnion childrenD_386) := by + exact envelope_eq_combination childrenD_386 (3, 1) envelope_386 + pivot_mem_386 child_envelope_sub_386 envelope_origin_386 +def checked_386 : CheckedCard where + required := required_386 + envelope := envelope_386 + height := height_386 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_386 +def height_389_i0 : ℕ := 3 +def childrenH_389_i0 : Fin 2 → ℕ := ![height_5, height_23] +theorem height_exact_389_i0 : height_389_i0 = 1 + Finset.univ.sup childrenH_389_i0 := by decide +kernel +theorem required_origin_389_i0 : ∀ x ∈ required_389_i0, + (∃ j, x ∈ childrenC_389_i0 j) ∨ ∀ j, x ∈ childrenD_389_i0 j := by decide +kernel +theorem required_exact_389_i0 : required_389_i0 = + ((Finset.univ.biUnion childrenC_389_i0) ∪ commonEnvelope childrenD_389_i0).erase (1, 3) := by + exact required_eq_combination childrenC_389_i0 childrenD_389_i0 (1, 3) required_389_i0 + (by decide +kernel) child_required_sub_389_i0 common_sub_389_i0 required_origin_389_i0 +theorem envelope_origin_389_i0 : ∀ x ∈ envelope_389_i0, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_389_i0 j := by decide +kernel +theorem envelope_exact_389_i0 : envelope_389_i0 = + insert (1, 3) (Finset.univ.biUnion childrenD_389_i0) := by + exact envelope_eq_combination childrenD_389_i0 (1, 3) envelope_389_i0 + pivot_mem_389_i0 child_envelope_sub_389_i0 envelope_origin_389_i0 +def checked_389_i0 : CheckedCard where + required := required_389_i0 + envelope := envelope_389_i0 + height := height_389_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_389_i0 +def height_389 : ℕ := 5 +def childrenH_389 : Fin 4 → ℕ := ![height_6, height_21, height_27, height_389_i0] +theorem height_exact_389 : height_389 = 1 + Finset.univ.sup childrenH_389 := by decide +kernel +theorem required_origin_389 : ∀ x ∈ required_389, + (∃ j, x ∈ childrenC_389 j) ∨ ∀ j, x ∈ childrenD_389 j := by decide +kernel +theorem required_exact_389 : required_389 = + ((Finset.univ.biUnion childrenC_389) ∪ commonEnvelope childrenD_389).erase (0, 4) := by + exact required_eq_combination childrenC_389 childrenD_389 (0, 4) required_389 + (by decide +kernel) child_required_sub_389 common_sub_389 required_origin_389 +theorem envelope_origin_389 : ∀ x ∈ envelope_389, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_389 j := by decide +kernel +theorem envelope_exact_389 : envelope_389 = + insert (0, 4) (Finset.univ.biUnion childrenD_389) := by + exact envelope_eq_combination childrenD_389 (0, 4) envelope_389 + pivot_mem_389 child_envelope_sub_389 envelope_origin_389 +def checked_389 : CheckedCard where + required := required_389 + envelope := envelope_389 + height := height_389 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_389 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part05.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part05.lean new file mode 100644 index 0000000..744a769 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part05.lean @@ -0,0 +1,961 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_391_i1 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_391_i1 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_391_i1 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_0), (placed21 4 (2, 4) required_36)] +def childrenD_391_i1 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_0), (placed21 4 (2, 4) envelope_36)] +theorem common_sub_391_i1 : commonEnvelope childrenD_391_i1 ⊆ insert (3, 1) required_391_i1 := by decide +kernel +theorem child_required_sub_391_i1 : ∀ j, childrenC_391_i1 j ⊆ insert (3, 1) required_391_i1 := by decide +kernel +theorem child_envelope_sub_391_i1 : ∀ j, childrenD_391_i1 j ⊆ envelope_391_i1 := by decide +kernel +theorem pivot_mem_391_i1 : (3, 1) ∈ envelope_391_i1 := by decide +kernel +theorem children_work_391_i1 : ∀ j, Template HasSnaky 2 (childrenC_391_i1 j) (childrenD_391_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_36 4 (2, 4)).mono (by decide +kernel) +theorem row_works_391_i1 : Template HasSnaky 3 required_391_i1 envelope_391_i1 := by + refine compose HasSnaky 2 childrenC_391_i1 childrenD_391_i1 children_work_391_i1 (3, 1) + required_391_i1 envelope_391_i1 pivot_mem_391_i1 child_required_sub_391_i1 child_envelope_sub_391_i1 ?_ + intro b hb + exact common_sub_391_i1 (mem_commonEnvelope childrenD_391_i1 b hb) +def required_391_i0 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_391_i0 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_391_i0 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), required_391_i1] +def childrenD_391_i0 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), envelope_391_i1] +theorem common_sub_391_i0 : commonEnvelope childrenD_391_i0 ⊆ insert (2, 1) required_391_i0 := by decide +kernel +theorem child_required_sub_391_i0 : ∀ j, childrenC_391_i0 j ⊆ insert (2, 1) required_391_i0 := by decide +kernel +theorem child_envelope_sub_391_i0 : ∀ j, childrenD_391_i0 j ⊆ envelope_391_i0 := by decide +kernel +theorem pivot_mem_391_i0 : (2, 1) ∈ envelope_391_i0 := by decide +kernel +theorem children_work_391_i0 : ∀ j, Template HasSnaky 3 (childrenC_391_i0 j) (childrenD_391_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact row_works_391_i1.mono (by decide +kernel) +theorem row_works_391_i0 : Template HasSnaky 4 required_391_i0 envelope_391_i0 := by + refine compose HasSnaky 3 childrenC_391_i0 childrenD_391_i0 children_work_391_i0 (2, 1) + required_391_i0 envelope_391_i0 pivot_mem_391_i0 child_required_sub_391_i0 child_envelope_sub_391_i0 ?_ + intro b hb + exact common_sub_391_i0 (mem_commonEnvelope childrenD_391_i0 b hb) +def required_391 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_391 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_391 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), required_391_i0] +def childrenD_391 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), envelope_391_i0] +theorem common_sub_391 : commonEnvelope childrenD_391 ⊆ insert (2, 4) required_391 := by decide +kernel +theorem child_required_sub_391 : ∀ j, childrenC_391 j ⊆ insert (2, 4) required_391 := by decide +kernel +theorem child_envelope_sub_391 : ∀ j, childrenD_391 j ⊆ envelope_391 := by decide +kernel +theorem pivot_mem_391 : (2, 4) ∈ envelope_391 := by decide +kernel +theorem children_work_391 : ∀ j, Template HasSnaky 4 (childrenC_391 j) (childrenD_391 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact row_works_391_i0.mono (by decide +kernel) +theorem row_works_391 : Template HasSnaky 5 required_391 envelope_391 := by + refine compose HasSnaky 4 childrenC_391 childrenD_391 children_work_391 (2, 4) + required_391 envelope_391 pivot_mem_391 child_required_sub_391 child_envelope_sub_391 ?_ + intro b hb + exact common_sub_391 (mem_commonEnvelope childrenD_391 b hb) +def required_413_i0 : Finset Cell := ⟨(([(1, 1), (1, 3), (1, 4), (2, 1), (2, 2), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_413_i0 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 4), (3, 5), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_413_i0 : Fin 2 → Finset Cell := ![(placed21 7 (2, 4) required_5), (placed21 1 (0, 1) required_45)] +def childrenD_413_i0 : Fin 2 → Finset Cell := ![(placed21 7 (2, 4) envelope_5), (placed21 1 (0, 1) envelope_45)] +theorem common_sub_413_i0 : commonEnvelope childrenD_413_i0 ⊆ insert (2, 3) required_413_i0 := by decide +kernel +theorem child_required_sub_413_i0 : ∀ j, childrenC_413_i0 j ⊆ insert (2, 3) required_413_i0 := by decide +kernel +theorem child_envelope_sub_413_i0 : ∀ j, childrenD_413_i0 j ⊆ envelope_413_i0 := by decide +kernel +theorem pivot_mem_413_i0 : (2, 3) ∈ envelope_413_i0 := by decide +kernel +theorem children_work_413_i0 : ∀ j, Template HasSnaky 3 (childrenC_413_i0 j) (childrenD_413_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_45 1 (0, 1)).mono (by decide +kernel) +theorem row_works_413_i0 : Template HasSnaky 4 required_413_i0 envelope_413_i0 := by + refine compose HasSnaky 3 childrenC_413_i0 childrenD_413_i0 children_work_413_i0 (2, 3) + required_413_i0 envelope_413_i0 pivot_mem_413_i0 child_required_sub_413_i0 child_envelope_sub_413_i0 ?_ + intro b hb + exact common_sub_413_i0 (mem_commonEnvelope childrenD_413_i0 b hb) +def required_413 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_413 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_413 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), required_413_i0] +def childrenD_413 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), envelope_413_i0] +theorem common_sub_413 : commonEnvelope childrenD_413 ⊆ insert (2, 4) required_413 := by decide +kernel +theorem child_required_sub_413 : ∀ j, childrenC_413 j ⊆ insert (2, 4) required_413 := by decide +kernel +theorem child_envelope_sub_413 : ∀ j, childrenD_413 j ⊆ envelope_413 := by decide +kernel +theorem pivot_mem_413 : (2, 4) ∈ envelope_413 := by decide +kernel +theorem children_work_413 : ∀ j, Template HasSnaky 4 (childrenC_413 j) (childrenD_413 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact row_works_413_i0.mono (by decide +kernel) +theorem row_works_413 : Template HasSnaky 5 required_413 envelope_413 := by + refine compose HasSnaky 4 childrenC_413 childrenD_413 children_work_413 (2, 4) + required_413 envelope_413 pivot_mem_413 child_required_sub_413 child_envelope_sub_413 ?_ + intro b hb + exact common_sub_413 (mem_commonEnvelope childrenD_413 b hb) +def required_416_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_416_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_416_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_5), (placed21 4 (0, 5) required_239)] +def childrenD_416_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_5), (placed21 4 (0, 5) envelope_239)] +theorem common_sub_416_i0 : commonEnvelope childrenD_416_i0 ⊆ insert (3, 1) required_416_i0 := by decide +kernel +theorem child_required_sub_416_i0 : ∀ j, childrenC_416_i0 j ⊆ insert (3, 1) required_416_i0 := by decide +kernel +theorem child_envelope_sub_416_i0 : ∀ j, childrenD_416_i0 j ⊆ envelope_416_i0 := by decide +kernel +theorem pivot_mem_416_i0 : (3, 1) ∈ envelope_416_i0 := by decide +kernel +theorem children_work_416_i0 : ∀ j, Template HasSnaky 3 (childrenC_416_i0 j) (childrenD_416_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_239 4 (0, 5)).mono (by decide +kernel) +theorem row_works_416_i0 : Template HasSnaky 4 required_416_i0 envelope_416_i0 := by + refine compose HasSnaky 3 childrenC_416_i0 childrenD_416_i0 children_work_416_i0 (3, 1) + required_416_i0 envelope_416_i0 pivot_mem_416_i0 child_required_sub_416_i0 child_envelope_sub_416_i0 ?_ + intro b hb + exact common_sub_416_i0 (mem_commonEnvelope childrenD_416_i0 b hb) +def required_416 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_416 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_416 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), required_416_i0] +def childrenD_416 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), envelope_416_i0] +theorem common_sub_416 : commonEnvelope childrenD_416 ⊆ insert (3, 3) required_416 := by decide +kernel +theorem child_required_sub_416 : ∀ j, childrenC_416 j ⊆ insert (3, 3) required_416 := by decide +kernel +theorem child_envelope_sub_416 : ∀ j, childrenD_416 j ⊆ envelope_416 := by decide +kernel +theorem pivot_mem_416 : (3, 3) ∈ envelope_416 := by decide +kernel +theorem children_work_416 : ∀ j, Template HasSnaky 4 (childrenC_416 j) (childrenD_416 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact row_works_416_i0.mono (by decide +kernel) +theorem row_works_416 : Template HasSnaky 5 required_416 envelope_416 := by + refine compose HasSnaky 4 childrenC_416 childrenD_416 children_work_416 (3, 3) + required_416 envelope_416 pivot_mem_416 child_required_sub_416 child_envelope_sub_416 ?_ + intro b hb + exact common_sub_416 (mem_commonEnvelope childrenD_416 b hb) +def required_425_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_425_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_425_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_2), (placed21 0 (3, 0) required_44)] +def childrenD_425_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_2), (placed21 0 (3, 0) envelope_44)] +theorem common_sub_425_i0 : commonEnvelope childrenD_425_i0 ⊆ insert (3, 2) required_425_i0 := by decide +kernel +theorem child_required_sub_425_i0 : ∀ j, childrenC_425_i0 j ⊆ insert (3, 2) required_425_i0 := by decide +kernel +theorem child_envelope_sub_425_i0 : ∀ j, childrenD_425_i0 j ⊆ envelope_425_i0 := by decide +kernel +theorem pivot_mem_425_i0 : (3, 2) ∈ envelope_425_i0 := by decide +kernel +theorem children_work_425_i0 : ∀ j, Template HasSnaky 3 (childrenC_425_i0 j) (childrenD_425_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_44 0 (3, 0)).mono (by decide +kernel) +theorem row_works_425_i0 : Template HasSnaky 4 required_425_i0 envelope_425_i0 := by + refine compose HasSnaky 3 childrenC_425_i0 childrenD_425_i0 children_work_425_i0 (3, 2) + required_425_i0 envelope_425_i0 pivot_mem_425_i0 child_required_sub_425_i0 child_envelope_sub_425_i0 ?_ + intro b hb + exact common_sub_425_i0 (mem_commonEnvelope childrenD_425_i0 b hb) +def required_425 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (3, 1), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_425 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_425 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_2), required_425_i0] +def childrenD_425 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_2), envelope_425_i0] +theorem common_sub_425 : commonEnvelope childrenD_425 ⊆ insert (4, 3) required_425 := by decide +kernel +theorem child_required_sub_425 : ∀ j, childrenC_425 j ⊆ insert (4, 3) required_425 := by decide +kernel +theorem child_envelope_sub_425 : ∀ j, childrenD_425 j ⊆ envelope_425 := by decide +kernel +theorem pivot_mem_425 : (4, 3) ∈ envelope_425 := by decide +kernel +theorem children_work_425 : ∀ j, Template HasSnaky 4 (childrenC_425 j) (childrenD_425 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 6 (4, 3)).mono (by decide +kernel) + · exact row_works_425_i0.mono (by decide +kernel) +theorem row_works_425 : Template HasSnaky 5 required_425 envelope_425 := by + refine compose HasSnaky 4 childrenC_425 childrenD_425 children_work_425 (4, 3) + required_425 envelope_425 pivot_mem_425 child_required_sub_425 child_envelope_sub_425 ?_ + intro b hb + exact common_sub_425 (mem_commonEnvelope childrenD_425 b hb) +def required_426_i0 : Finset Cell := ⟨(([(1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_426_i0 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_426_i0 : Fin 2 → Finset Cell := ![(placed21 6 (5, 3) required_0), (placed21 2 (4, 1) required_221)] +def childrenD_426_i0 : Fin 2 → Finset Cell := ![(placed21 6 (5, 3) envelope_0), (placed21 2 (4, 1) envelope_221)] +theorem common_sub_426_i0 : commonEnvelope childrenD_426_i0 ⊆ insert (3, 3) required_426_i0 := by decide +kernel +theorem child_required_sub_426_i0 : ∀ j, childrenC_426_i0 j ⊆ insert (3, 3) required_426_i0 := by decide +kernel +theorem child_envelope_sub_426_i0 : ∀ j, childrenD_426_i0 j ⊆ envelope_426_i0 := by decide +kernel +theorem pivot_mem_426_i0 : (3, 3) ∈ envelope_426_i0 := by decide +kernel +theorem children_work_426_i0 : ∀ j, Template HasSnaky 3 (childrenC_426_i0 j) (childrenD_426_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_221 2 (4, 1)).mono (by decide +kernel) +theorem row_works_426_i0 : Template HasSnaky 4 required_426_i0 envelope_426_i0 := by + refine compose HasSnaky 3 childrenC_426_i0 childrenD_426_i0 children_work_426_i0 (3, 3) + required_426_i0 envelope_426_i0 pivot_mem_426_i0 child_required_sub_426_i0 child_envelope_sub_426_i0 ?_ + intro b hb + exact common_sub_426_i0 (mem_commonEnvelope childrenD_426_i0 b hb) +def required_426 : Finset Cell := ⟨(([(1, 2), (2, 1), (2, 2), (2, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_426 : Finset Cell := ⟨(([(0, 4), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_426 : Fin 2 → Finset Cell := ![(placed21 2 (2, 0) required_11), required_426_i0] +def childrenD_426 : Fin 2 → Finset Cell := ![(placed21 2 (2, 0) envelope_11), envelope_426_i0] +theorem common_sub_426 : commonEnvelope childrenD_426 ⊆ insert (2, 4) required_426 := by decide +kernel +theorem child_required_sub_426 : ∀ j, childrenC_426 j ⊆ insert (2, 4) required_426 := by decide +kernel +theorem child_envelope_sub_426 : ∀ j, childrenD_426 j ⊆ envelope_426 := by decide +kernel +theorem pivot_mem_426 : (2, 4) ∈ envelope_426 := by decide +kernel +theorem children_work_426 : ∀ j, Template HasSnaky 4 (childrenC_426 j) (childrenD_426 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 2 (2, 0)).mono (by decide +kernel) + · exact row_works_426_i0.mono (by decide +kernel) +theorem row_works_426 : Template HasSnaky 5 required_426 envelope_426 := by + refine compose HasSnaky 4 childrenC_426 childrenD_426 children_work_426 (2, 4) + required_426 envelope_426 pivot_mem_426 child_required_sub_426 child_envelope_sub_426 ?_ + intro b hb + exact common_sub_426 (mem_commonEnvelope childrenD_426 b hb) +def required_433 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (1, 5), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_433 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_433 : Fin 2 → Finset Cell := ![required_86, (placed21 5 (4, 1) required_432)] +def childrenD_433 : Fin 2 → Finset Cell := ![envelope_86, (placed21 5 (4, 1) envelope_432)] +theorem common_sub_433 : commonEnvelope childrenD_433 ⊆ insert (3, 4) required_433 := by decide +kernel +theorem child_required_sub_433 : ∀ j, childrenC_433 j ⊆ insert (3, 4) required_433 := by decide +kernel +theorem child_envelope_sub_433 : ∀ j, childrenD_433 j ⊆ envelope_433 := by decide +kernel +theorem pivot_mem_433 : (3, 4) ∈ envelope_433 := by decide +kernel +theorem children_work_433 : ∀ j, Template HasSnaky 4 (childrenC_433 j) (childrenD_433 j) := by + intro j + fin_cases j + · exact row_works_86.mono (by decide +kernel) + · exact (placed21_template row_works_432 5 (4, 1)).mono (by decide +kernel) +theorem row_works_433 : Template HasSnaky 5 required_433 envelope_433 := by + refine compose HasSnaky 4 childrenC_433 childrenD_433 children_work_433 (3, 4) + required_433 envelope_433 pivot_mem_433 child_required_sub_433 child_envelope_sub_433 ?_ + intro b hb + exact common_sub_433 (mem_commonEnvelope childrenD_433 b hb) +def required_445_i0 : Finset Cell := ⟨(([(1, 2), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_445_i0 : Finset Cell := ⟨(([(1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_445_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 0) required_20), (placed21 2 (3, 0) required_29), (placed21 0 (1, 0) required_221)] +def childrenD_445_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 0) envelope_20), (placed21 2 (3, 0) envelope_29), (placed21 0 (1, 0) envelope_221)] +theorem common_sub_445_i0 : commonEnvelope childrenD_445_i0 ⊆ insert (3, 3) required_445_i0 := by decide +kernel +theorem child_required_sub_445_i0 : ∀ j, childrenC_445_i0 j ⊆ insert (3, 3) required_445_i0 := by decide +kernel +theorem child_envelope_sub_445_i0 : ∀ j, childrenD_445_i0 j ⊆ envelope_445_i0 := by decide +kernel +theorem pivot_mem_445_i0 : (3, 3) ∈ envelope_445_i0 := by decide +kernel +theorem children_work_445_i0 : ∀ j, Template HasSnaky 3 (childrenC_445_i0 j) (childrenD_445_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_20 0 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_29 2 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_221 0 (1, 0)).mono (by decide +kernel) +theorem row_works_445_i0 : Template HasSnaky 4 required_445_i0 envelope_445_i0 := by + refine compose HasSnaky 3 childrenC_445_i0 childrenD_445_i0 children_work_445_i0 (3, 3) + required_445_i0 envelope_445_i0 pivot_mem_445_i0 child_required_sub_445_i0 child_envelope_sub_445_i0 ?_ + intro b hb + exact common_sub_445_i0 (mem_commonEnvelope childrenD_445_i0 b hb) +def required_445 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_445 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 3), (4, 4), (4, 5), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_445 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), required_445_i0] +def childrenD_445 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), envelope_445_i0] +theorem common_sub_445 : commonEnvelope childrenD_445 ⊆ insert (3, 0) required_445 := by decide +kernel +theorem child_required_sub_445 : ∀ j, childrenC_445 j ⊆ insert (3, 0) required_445 := by decide +kernel +theorem child_envelope_sub_445 : ∀ j, childrenD_445 j ⊆ envelope_445 := by decide +kernel +theorem pivot_mem_445 : (3, 0) ∈ envelope_445 := by decide +kernel +theorem children_work_445 : ∀ j, Template HasSnaky 4 (childrenC_445 j) (childrenD_445 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact row_works_445_i0.mono (by decide +kernel) +theorem row_works_445 : Template HasSnaky 5 required_445 envelope_445 := by + refine compose HasSnaky 4 childrenC_445 childrenD_445 children_work_445 (3, 0) + required_445 envelope_445 pivot_mem_445 child_required_sub_445 child_envelope_sub_445 ?_ + intro b hb + exact common_sub_445 (mem_commonEnvelope childrenD_445 b hb) +def required_451_i0 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_451_i0 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_451_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_0), required_402] +def childrenD_451_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_0), envelope_402] +theorem common_sub_451_i0 : commonEnvelope childrenD_451_i0 ⊆ insert (2, 3) required_451_i0 := by decide +kernel +theorem child_required_sub_451_i0 : ∀ j, childrenC_451_i0 j ⊆ insert (2, 3) required_451_i0 := by decide +kernel +theorem child_envelope_sub_451_i0 : ∀ j, childrenD_451_i0 j ⊆ envelope_451_i0 := by decide +kernel +theorem pivot_mem_451_i0 : (2, 3) ∈ envelope_451_i0 := by decide +kernel +theorem children_work_451_i0 : ∀ j, Template HasSnaky 3 (childrenC_451_i0 j) (childrenD_451_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact row_works_402.mono (by decide +kernel) +theorem row_works_451_i0 : Template HasSnaky 4 required_451_i0 envelope_451_i0 := by + refine compose HasSnaky 3 childrenC_451_i0 childrenD_451_i0 children_work_451_i0 (2, 3) + required_451_i0 envelope_451_i0 pivot_mem_451_i0 child_required_sub_451_i0 child_envelope_sub_451_i0 ?_ + intro b hb + exact common_sub_451_i0 (mem_commonEnvelope childrenD_451_i0 b hb) +def required_451 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_451 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_451 : Fin 2 → Finset Cell := ![(placed21 2 (1, 0) required_11), required_451_i0] +def childrenD_451 : Fin 2 → Finset Cell := ![(placed21 2 (1, 0) envelope_11), envelope_451_i0] +theorem common_sub_451 : commonEnvelope childrenD_451 ⊆ insert (1, 4) required_451 := by decide +kernel +theorem child_required_sub_451 : ∀ j, childrenC_451 j ⊆ insert (1, 4) required_451 := by decide +kernel +theorem child_envelope_sub_451 : ∀ j, childrenD_451 j ⊆ envelope_451 := by decide +kernel +theorem pivot_mem_451 : (1, 4) ∈ envelope_451 := by decide +kernel +theorem children_work_451 : ∀ j, Template HasSnaky 4 (childrenC_451 j) (childrenD_451 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 2 (1, 0)).mono (by decide +kernel) + · exact row_works_451_i0.mono (by decide +kernel) +theorem row_works_451 : Template HasSnaky 5 required_451 envelope_451 := by + refine compose HasSnaky 4 childrenC_451 childrenD_451 children_work_451 (1, 4) + required_451 envelope_451 pivot_mem_451 child_required_sub_451 child_envelope_sub_451 ?_ + intro b hb + exact common_sub_451 (mem_commonEnvelope childrenD_451 b hb) +def required_464_i1 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_464_i1 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_464_i1 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) required_0), (placed21 0 (1, 0) required_11)] +def childrenD_464_i1 : Fin 2 → Finset Cell := ![(placed21 5 (1, 0) envelope_0), (placed21 0 (1, 0) envelope_11)] +theorem common_sub_464_i1 : commonEnvelope childrenD_464_i1 ⊆ insert (1, 1) required_464_i1 := by decide +kernel +theorem child_required_sub_464_i1 : ∀ j, childrenC_464_i1 j ⊆ insert (1, 1) required_464_i1 := by decide +kernel +theorem child_envelope_sub_464_i1 : ∀ j, childrenD_464_i1 j ⊆ envelope_464_i1 := by decide +kernel +theorem pivot_mem_464_i1 : (1, 1) ∈ envelope_464_i1 := by decide +kernel +theorem children_work_464_i1 : ∀ j, Template HasSnaky 2 (childrenC_464_i1 j) (childrenD_464_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 5 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_11 0 (1, 0)).mono (by decide +kernel) +theorem row_works_464_i1 : Template HasSnaky 3 required_464_i1 envelope_464_i1 := by + refine compose HasSnaky 2 childrenC_464_i1 childrenD_464_i1 children_work_464_i1 (1, 1) + required_464_i1 envelope_464_i1 pivot_mem_464_i1 child_required_sub_464_i1 child_envelope_sub_464_i1 ?_ + intro b hb + exact common_sub_464_i1 (mem_commonEnvelope childrenD_464_i1 b hb) +def required_464_i0 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_464_i0 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_464_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_0), required_464_i1] +def childrenD_464_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_0), envelope_464_i1] +theorem common_sub_464_i0 : commonEnvelope childrenD_464_i0 ⊆ insert (2, 2) required_464_i0 := by decide +kernel +theorem child_required_sub_464_i0 : ∀ j, childrenC_464_i0 j ⊆ insert (2, 2) required_464_i0 := by decide +kernel +theorem child_envelope_sub_464_i0 : ∀ j, childrenD_464_i0 j ⊆ envelope_464_i0 := by decide +kernel +theorem pivot_mem_464_i0 : (2, 2) ∈ envelope_464_i0 := by decide +kernel +theorem children_work_464_i0 : ∀ j, Template HasSnaky 3 (childrenC_464_i0 j) (childrenD_464_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 2)).mono (by decide +kernel) + · exact row_works_464_i1.mono (by decide +kernel) +theorem row_works_464_i0 : Template HasSnaky 4 required_464_i0 envelope_464_i0 := by + refine compose HasSnaky 3 childrenC_464_i0 childrenD_464_i0 children_work_464_i0 (2, 2) + required_464_i0 envelope_464_i0 pivot_mem_464_i0 child_required_sub_464_i0 child_envelope_sub_464_i0 ?_ + intro b hb + exact common_sub_464_i0 (mem_commonEnvelope childrenD_464_i0 b hb) +def required_464_i2 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_464_i2 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 1), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_464_i2 : Fin 2 → Finset Cell := ![(placed21 2 (1, 2) required_29), (placed21 3 (0, 5) required_38)] +def childrenD_464_i2 : Fin 2 → Finset Cell := ![(placed21 2 (1, 2) envelope_29), (placed21 3 (0, 5) envelope_38)] +theorem common_sub_464_i2 : commonEnvelope childrenD_464_i2 ⊆ insert (1, 5) required_464_i2 := by decide +kernel +theorem child_required_sub_464_i2 : ∀ j, childrenC_464_i2 j ⊆ insert (1, 5) required_464_i2 := by decide +kernel +theorem child_envelope_sub_464_i2 : ∀ j, childrenD_464_i2 j ⊆ envelope_464_i2 := by decide +kernel +theorem pivot_mem_464_i2 : (1, 5) ∈ envelope_464_i2 := by decide +kernel +theorem children_work_464_i2 : ∀ j, Template HasSnaky 3 (childrenC_464_i2 j) (childrenD_464_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_29 2 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_38 3 (0, 5)).mono (by decide +kernel) +theorem row_works_464_i2 : Template HasSnaky 4 required_464_i2 envelope_464_i2 := by + refine compose HasSnaky 3 childrenC_464_i2 childrenD_464_i2 children_work_464_i2 (1, 5) + required_464_i2 envelope_464_i2 pivot_mem_464_i2 child_required_sub_464_i2 child_envelope_sub_464_i2 ?_ + intro b hb + exact common_sub_464_i2 (mem_commonEnvelope childrenD_464_i2 b hb) +def required_464 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 3), (1, 4), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_464 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_464 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) required_15), required_464_i0, required_464_i2] +def childrenD_464 : Fin 3 → Finset Cell := ![(placed21 2 (1, 1) envelope_15), envelope_464_i0, envelope_464_i2] +theorem common_sub_464 : commonEnvelope childrenD_464 ⊆ insert (1, 2) required_464 := by decide +kernel +theorem child_required_sub_464 : ∀ j, childrenC_464 j ⊆ insert (1, 2) required_464 := by decide +kernel +theorem child_envelope_sub_464 : ∀ j, childrenD_464 j ⊆ envelope_464 := by decide +kernel +theorem pivot_mem_464 : (1, 2) ∈ envelope_464 := by decide +kernel +theorem children_work_464 : ∀ j, Template HasSnaky 4 (childrenC_464 j) (childrenD_464 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 2 (1, 1)).mono (by decide +kernel) + · exact row_works_464_i0.mono (by decide +kernel) + · exact row_works_464_i2.mono (by decide +kernel) +theorem row_works_464 : Template HasSnaky 5 required_464 envelope_464 := by + refine compose HasSnaky 4 childrenC_464 childrenD_464 children_work_464 (1, 2) + required_464 envelope_464 pivot_mem_464 child_required_sub_464 child_envelope_sub_464 ?_ + intro b hb + exact common_sub_464 (mem_commonEnvelope childrenD_464 b hb) +def required_492_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_492_i1 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_492_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_0), (placed21 5 (4, 1) required_32)] +def childrenD_492_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_0), (placed21 5 (4, 1) envelope_32)] +theorem common_sub_492_i1 : commonEnvelope childrenD_492_i1 ⊆ insert (2, 3) required_492_i1 := by decide +kernel +theorem child_required_sub_492_i1 : ∀ j, childrenC_492_i1 j ⊆ insert (2, 3) required_492_i1 := by decide +kernel +theorem child_envelope_sub_492_i1 : ∀ j, childrenD_492_i1 j ⊆ envelope_492_i1 := by decide +kernel +theorem pivot_mem_492_i1 : (2, 3) ∈ envelope_492_i1 := by decide +kernel +theorem children_work_492_i1 : ∀ j, Template HasSnaky 2 (childrenC_492_i1 j) (childrenD_492_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_32 5 (4, 1)).mono (by decide +kernel) +theorem row_works_492_i1 : Template HasSnaky 3 required_492_i1 envelope_492_i1 := by + refine compose HasSnaky 2 childrenC_492_i1 childrenD_492_i1 children_work_492_i1 (2, 3) + required_492_i1 envelope_492_i1 pivot_mem_492_i1 child_required_sub_492_i1 child_envelope_sub_492_i1 ?_ + intro b hb + exact common_sub_492_i1 (mem_commonEnvelope childrenD_492_i1 b hb) +def required_492_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 2), (1, 4), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_492_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_492_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), required_492_i1] +def childrenD_492_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), envelope_492_i1] +theorem common_sub_492_i0 : commonEnvelope childrenD_492_i0 ⊆ insert (1, 3) required_492_i0 := by decide +kernel +theorem child_required_sub_492_i0 : ∀ j, childrenC_492_i0 j ⊆ insert (1, 3) required_492_i0 := by decide +kernel +theorem child_envelope_sub_492_i0 : ∀ j, childrenD_492_i0 j ⊆ envelope_492_i0 := by decide +kernel +theorem pivot_mem_492_i0 : (1, 3) ∈ envelope_492_i0 := by decide +kernel +theorem children_work_492_i0 : ∀ j, Template HasSnaky 3 (childrenC_492_i0 j) (childrenD_492_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact row_works_492_i1.mono (by decide +kernel) +theorem row_works_492_i0 : Template HasSnaky 4 required_492_i0 envelope_492_i0 := by + refine compose HasSnaky 3 childrenC_492_i0 childrenD_492_i0 children_work_492_i0 (1, 3) + required_492_i0 envelope_492_i0 pivot_mem_492_i0 child_required_sub_492_i0 child_envelope_sub_492_i0 ?_ + intro b hb + exact common_sub_492_i0 (mem_commonEnvelope childrenD_492_i0 b hb) +def required_492 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_492 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_492 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) required_78), required_492_i0] +def childrenD_492 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) envelope_78), envelope_492_i0] +theorem common_sub_492 : commonEnvelope childrenD_492 ⊆ insert (1, 2) required_492 := by decide +kernel +theorem child_required_sub_492 : ∀ j, childrenC_492 j ⊆ insert (1, 2) required_492 := by decide +kernel +theorem child_envelope_sub_492 : ∀ j, childrenD_492 j ⊆ envelope_492 := by decide +kernel +theorem pivot_mem_492 : (1, 2) ∈ envelope_492 := by decide +kernel +theorem children_work_492 : ∀ j, Template HasSnaky 4 (childrenC_492 j) (childrenD_492 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_78 7 (4, 4)).mono (by decide +kernel) + · exact row_works_492_i0.mono (by decide +kernel) +theorem row_works_492 : Template HasSnaky 5 required_492 envelope_492 := by + refine compose HasSnaky 4 childrenC_492 childrenD_492 children_work_492 (1, 2) + required_492 envelope_492 pivot_mem_492 child_required_sub_492 child_envelope_sub_492 ?_ + intro b hb + exact common_sub_492 (mem_commonEnvelope childrenD_492 b hb) +def height_391_i1 : ℕ := 3 +def childrenH_391_i1 : Fin 2 → ℕ := ![height_0, height_36] +theorem height_exact_391_i1 : height_391_i1 = 1 + Finset.univ.sup childrenH_391_i1 := by decide +kernel +theorem required_origin_391_i1 : ∀ x ∈ required_391_i1, + (∃ j, x ∈ childrenC_391_i1 j) ∨ ∀ j, x ∈ childrenD_391_i1 j := by decide +kernel +theorem required_exact_391_i1 : required_391_i1 = + ((Finset.univ.biUnion childrenC_391_i1) ∪ commonEnvelope childrenD_391_i1).erase (3, 1) := by + exact required_eq_combination childrenC_391_i1 childrenD_391_i1 (3, 1) required_391_i1 + (by decide +kernel) child_required_sub_391_i1 common_sub_391_i1 required_origin_391_i1 +theorem envelope_origin_391_i1 : ∀ x ∈ envelope_391_i1, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_391_i1 j := by decide +kernel +theorem envelope_exact_391_i1 : envelope_391_i1 = + insert (3, 1) (Finset.univ.biUnion childrenD_391_i1) := by + exact envelope_eq_combination childrenD_391_i1 (3, 1) envelope_391_i1 + pivot_mem_391_i1 child_envelope_sub_391_i1 envelope_origin_391_i1 +def checked_391_i1 : CheckedCard where + required := required_391_i1 + envelope := envelope_391_i1 + height := height_391_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_391_i1 +def height_391_i0 : ℕ := 4 +def childrenH_391_i0 : Fin 2 → ℕ := ![height_5, height_391_i1] +theorem height_exact_391_i0 : height_391_i0 = 1 + Finset.univ.sup childrenH_391_i0 := by decide +kernel +theorem required_origin_391_i0 : ∀ x ∈ required_391_i0, + (∃ j, x ∈ childrenC_391_i0 j) ∨ ∀ j, x ∈ childrenD_391_i0 j := by decide +kernel +theorem required_exact_391_i0 : required_391_i0 = + ((Finset.univ.biUnion childrenC_391_i0) ∪ commonEnvelope childrenD_391_i0).erase (2, 1) := by + exact required_eq_combination childrenC_391_i0 childrenD_391_i0 (2, 1) required_391_i0 + (by decide +kernel) child_required_sub_391_i0 common_sub_391_i0 required_origin_391_i0 +theorem envelope_origin_391_i0 : ∀ x ∈ envelope_391_i0, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_391_i0 j := by decide +kernel +theorem envelope_exact_391_i0 : envelope_391_i0 = + insert (2, 1) (Finset.univ.biUnion childrenD_391_i0) := by + exact envelope_eq_combination childrenD_391_i0 (2, 1) envelope_391_i0 + pivot_mem_391_i0 child_envelope_sub_391_i0 envelope_origin_391_i0 +def checked_391_i0 : CheckedCard where + required := required_391_i0 + envelope := envelope_391_i0 + height := height_391_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_391_i0 +def height_391 : ℕ := 5 +def childrenH_391 : Fin 2 → ℕ := ![height_5, height_391_i0] +theorem height_exact_391 : height_391 = 1 + Finset.univ.sup childrenH_391 := by decide +kernel +theorem required_origin_391 : ∀ x ∈ required_391, + (∃ j, x ∈ childrenC_391 j) ∨ ∀ j, x ∈ childrenD_391 j := by decide +kernel +theorem required_exact_391 : required_391 = + ((Finset.univ.biUnion childrenC_391) ∪ commonEnvelope childrenD_391).erase (2, 4) := by + exact required_eq_combination childrenC_391 childrenD_391 (2, 4) required_391 + (by decide +kernel) child_required_sub_391 common_sub_391 required_origin_391 +theorem envelope_origin_391 : ∀ x ∈ envelope_391, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_391 j := by decide +kernel +theorem envelope_exact_391 : envelope_391 = + insert (2, 4) (Finset.univ.biUnion childrenD_391) := by + exact envelope_eq_combination childrenD_391 (2, 4) envelope_391 + pivot_mem_391 child_envelope_sub_391 envelope_origin_391 +def checked_391 : CheckedCard where + required := required_391 + envelope := envelope_391 + height := height_391 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_391 +def height_413_i0 : ℕ := 4 +def childrenH_413_i0 : Fin 2 → ℕ := ![height_5, height_45] +theorem height_exact_413_i0 : height_413_i0 = 1 + Finset.univ.sup childrenH_413_i0 := by decide +kernel +theorem required_origin_413_i0 : ∀ x ∈ required_413_i0, + (∃ j, x ∈ childrenC_413_i0 j) ∨ ∀ j, x ∈ childrenD_413_i0 j := by decide +kernel +theorem required_exact_413_i0 : required_413_i0 = + ((Finset.univ.biUnion childrenC_413_i0) ∪ commonEnvelope childrenD_413_i0).erase (2, 3) := by + exact required_eq_combination childrenC_413_i0 childrenD_413_i0 (2, 3) required_413_i0 + (by decide +kernel) child_required_sub_413_i0 common_sub_413_i0 required_origin_413_i0 +theorem envelope_origin_413_i0 : ∀ x ∈ envelope_413_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_413_i0 j := by decide +kernel +theorem envelope_exact_413_i0 : envelope_413_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_413_i0) := by + exact envelope_eq_combination childrenD_413_i0 (2, 3) envelope_413_i0 + pivot_mem_413_i0 child_envelope_sub_413_i0 envelope_origin_413_i0 +def checked_413_i0 : CheckedCard where + required := required_413_i0 + envelope := envelope_413_i0 + height := height_413_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_413_i0 +def height_413 : ℕ := 5 +def childrenH_413 : Fin 2 → ℕ := ![height_5, height_413_i0] +theorem height_exact_413 : height_413 = 1 + Finset.univ.sup childrenH_413 := by decide +kernel +theorem required_origin_413 : ∀ x ∈ required_413, + (∃ j, x ∈ childrenC_413 j) ∨ ∀ j, x ∈ childrenD_413 j := by decide +kernel +theorem required_exact_413 : required_413 = + ((Finset.univ.biUnion childrenC_413) ∪ commonEnvelope childrenD_413).erase (2, 4) := by + exact required_eq_combination childrenC_413 childrenD_413 (2, 4) required_413 + (by decide +kernel) child_required_sub_413 common_sub_413 required_origin_413 +theorem envelope_origin_413 : ∀ x ∈ envelope_413, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_413 j := by decide +kernel +theorem envelope_exact_413 : envelope_413 = + insert (2, 4) (Finset.univ.biUnion childrenD_413) := by + exact envelope_eq_combination childrenD_413 (2, 4) envelope_413 + pivot_mem_413 child_envelope_sub_413 envelope_origin_413 +def checked_413 : CheckedCard where + required := required_413 + envelope := envelope_413 + height := height_413 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_413 +def height_416_i0 : ℕ := 4 +def childrenH_416_i0 : Fin 2 → ℕ := ![height_5, height_239] +theorem height_exact_416_i0 : height_416_i0 = 1 + Finset.univ.sup childrenH_416_i0 := by decide +kernel +theorem required_origin_416_i0 : ∀ x ∈ required_416_i0, + (∃ j, x ∈ childrenC_416_i0 j) ∨ ∀ j, x ∈ childrenD_416_i0 j := by decide +kernel +theorem required_exact_416_i0 : required_416_i0 = + ((Finset.univ.biUnion childrenC_416_i0) ∪ commonEnvelope childrenD_416_i0).erase (3, 1) := by + exact required_eq_combination childrenC_416_i0 childrenD_416_i0 (3, 1) required_416_i0 + (by decide +kernel) child_required_sub_416_i0 common_sub_416_i0 required_origin_416_i0 +theorem envelope_origin_416_i0 : ∀ x ∈ envelope_416_i0, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_416_i0 j := by decide +kernel +theorem envelope_exact_416_i0 : envelope_416_i0 = + insert (3, 1) (Finset.univ.biUnion childrenD_416_i0) := by + exact envelope_eq_combination childrenD_416_i0 (3, 1) envelope_416_i0 + pivot_mem_416_i0 child_envelope_sub_416_i0 envelope_origin_416_i0 +def checked_416_i0 : CheckedCard where + required := required_416_i0 + envelope := envelope_416_i0 + height := height_416_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_416_i0 +def height_416 : ℕ := 5 +def childrenH_416 : Fin 2 → ℕ := ![height_5, height_416_i0] +theorem height_exact_416 : height_416 = 1 + Finset.univ.sup childrenH_416 := by decide +kernel +theorem required_origin_416 : ∀ x ∈ required_416, + (∃ j, x ∈ childrenC_416 j) ∨ ∀ j, x ∈ childrenD_416 j := by decide +kernel +theorem required_exact_416 : required_416 = + ((Finset.univ.biUnion childrenC_416) ∪ commonEnvelope childrenD_416).erase (3, 3) := by + exact required_eq_combination childrenC_416 childrenD_416 (3, 3) required_416 + (by decide +kernel) child_required_sub_416 common_sub_416 required_origin_416 +theorem envelope_origin_416 : ∀ x ∈ envelope_416, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_416 j := by decide +kernel +theorem envelope_exact_416 : envelope_416 = + insert (3, 3) (Finset.univ.biUnion childrenD_416) := by + exact envelope_eq_combination childrenD_416 (3, 3) envelope_416 + pivot_mem_416 child_envelope_sub_416 envelope_origin_416 +def checked_416 : CheckedCard where + required := required_416 + envelope := envelope_416 + height := height_416 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_416 +def height_425_i0 : ℕ := 4 +def childrenH_425_i0 : Fin 2 → ℕ := ![height_2, height_44] +theorem height_exact_425_i0 : height_425_i0 = 1 + Finset.univ.sup childrenH_425_i0 := by decide +kernel +theorem required_origin_425_i0 : ∀ x ∈ required_425_i0, + (∃ j, x ∈ childrenC_425_i0 j) ∨ ∀ j, x ∈ childrenD_425_i0 j := by decide +kernel +theorem required_exact_425_i0 : required_425_i0 = + ((Finset.univ.biUnion childrenC_425_i0) ∪ commonEnvelope childrenD_425_i0).erase (3, 2) := by + exact required_eq_combination childrenC_425_i0 childrenD_425_i0 (3, 2) required_425_i0 + (by decide +kernel) child_required_sub_425_i0 common_sub_425_i0 required_origin_425_i0 +theorem envelope_origin_425_i0 : ∀ x ∈ envelope_425_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_425_i0 j := by decide +kernel +theorem envelope_exact_425_i0 : envelope_425_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_425_i0) := by + exact envelope_eq_combination childrenD_425_i0 (3, 2) envelope_425_i0 + pivot_mem_425_i0 child_envelope_sub_425_i0 envelope_origin_425_i0 +def checked_425_i0 : CheckedCard where + required := required_425_i0 + envelope := envelope_425_i0 + height := height_425_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_425_i0 +def height_425 : ℕ := 5 +def childrenH_425 : Fin 2 → ℕ := ![height_2, height_425_i0] +theorem height_exact_425 : height_425 = 1 + Finset.univ.sup childrenH_425 := by decide +kernel +theorem required_origin_425 : ∀ x ∈ required_425, + (∃ j, x ∈ childrenC_425 j) ∨ ∀ j, x ∈ childrenD_425 j := by decide +kernel +theorem required_exact_425 : required_425 = + ((Finset.univ.biUnion childrenC_425) ∪ commonEnvelope childrenD_425).erase (4, 3) := by + exact required_eq_combination childrenC_425 childrenD_425 (4, 3) required_425 + (by decide +kernel) child_required_sub_425 common_sub_425 required_origin_425 +theorem envelope_origin_425 : ∀ x ∈ envelope_425, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_425 j := by decide +kernel +theorem envelope_exact_425 : envelope_425 = + insert (4, 3) (Finset.univ.biUnion childrenD_425) := by + exact envelope_eq_combination childrenD_425 (4, 3) envelope_425 + pivot_mem_425 child_envelope_sub_425 envelope_origin_425 +def checked_425 : CheckedCard where + required := required_425 + envelope := envelope_425 + height := height_425 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_425 +def height_426_i0 : ℕ := 4 +def childrenH_426_i0 : Fin 2 → ℕ := ![height_0, height_221] +theorem height_exact_426_i0 : height_426_i0 = 1 + Finset.univ.sup childrenH_426_i0 := by decide +kernel +theorem required_origin_426_i0 : ∀ x ∈ required_426_i0, + (∃ j, x ∈ childrenC_426_i0 j) ∨ ∀ j, x ∈ childrenD_426_i0 j := by decide +kernel +theorem required_exact_426_i0 : required_426_i0 = + ((Finset.univ.biUnion childrenC_426_i0) ∪ commonEnvelope childrenD_426_i0).erase (3, 3) := by + exact required_eq_combination childrenC_426_i0 childrenD_426_i0 (3, 3) required_426_i0 + (by decide +kernel) child_required_sub_426_i0 common_sub_426_i0 required_origin_426_i0 +theorem envelope_origin_426_i0 : ∀ x ∈ envelope_426_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_426_i0 j := by decide +kernel +theorem envelope_exact_426_i0 : envelope_426_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_426_i0) := by + exact envelope_eq_combination childrenD_426_i0 (3, 3) envelope_426_i0 + pivot_mem_426_i0 child_envelope_sub_426_i0 envelope_origin_426_i0 +def checked_426_i0 : CheckedCard where + required := required_426_i0 + envelope := envelope_426_i0 + height := height_426_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_426_i0 +def height_426 : ℕ := 5 +def childrenH_426 : Fin 2 → ℕ := ![height_11, height_426_i0] +theorem height_exact_426 : height_426 = 1 + Finset.univ.sup childrenH_426 := by decide +kernel +theorem required_origin_426 : ∀ x ∈ required_426, + (∃ j, x ∈ childrenC_426 j) ∨ ∀ j, x ∈ childrenD_426 j := by decide +kernel +theorem required_exact_426 : required_426 = + ((Finset.univ.biUnion childrenC_426) ∪ commonEnvelope childrenD_426).erase (2, 4) := by + exact required_eq_combination childrenC_426 childrenD_426 (2, 4) required_426 + (by decide +kernel) child_required_sub_426 common_sub_426 required_origin_426 +theorem envelope_origin_426 : ∀ x ∈ envelope_426, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_426 j := by decide +kernel +theorem envelope_exact_426 : envelope_426 = + insert (2, 4) (Finset.univ.biUnion childrenD_426) := by + exact envelope_eq_combination childrenD_426 (2, 4) envelope_426 + pivot_mem_426 child_envelope_sub_426 envelope_origin_426 +def checked_426 : CheckedCard where + required := required_426 + envelope := envelope_426 + height := height_426 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_426 +def height_433 : ℕ := 5 +def childrenH_433 : Fin 2 → ℕ := ![height_86, height_432] +theorem height_exact_433 : height_433 = 1 + Finset.univ.sup childrenH_433 := by decide +kernel +theorem required_origin_433 : ∀ x ∈ required_433, + (∃ j, x ∈ childrenC_433 j) ∨ ∀ j, x ∈ childrenD_433 j := by decide +kernel +theorem required_exact_433 : required_433 = + ((Finset.univ.biUnion childrenC_433) ∪ commonEnvelope childrenD_433).erase (3, 4) := by + exact required_eq_combination childrenC_433 childrenD_433 (3, 4) required_433 + (by decide +kernel) child_required_sub_433 common_sub_433 required_origin_433 +theorem envelope_origin_433 : ∀ x ∈ envelope_433, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_433 j := by decide +kernel +theorem envelope_exact_433 : envelope_433 = + insert (3, 4) (Finset.univ.biUnion childrenD_433) := by + exact envelope_eq_combination childrenD_433 (3, 4) envelope_433 + pivot_mem_433 child_envelope_sub_433 envelope_origin_433 +def checked_433 : CheckedCard where + required := required_433 + envelope := envelope_433 + height := height_433 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_433 +def height_445_i0 : ℕ := 4 +def childrenH_445_i0 : Fin 3 → ℕ := ![height_20, height_29, height_221] +theorem height_exact_445_i0 : height_445_i0 = 1 + Finset.univ.sup childrenH_445_i0 := by decide +kernel +theorem required_origin_445_i0 : ∀ x ∈ required_445_i0, + (∃ j, x ∈ childrenC_445_i0 j) ∨ ∀ j, x ∈ childrenD_445_i0 j := by decide +kernel +theorem required_exact_445_i0 : required_445_i0 = + ((Finset.univ.biUnion childrenC_445_i0) ∪ commonEnvelope childrenD_445_i0).erase (3, 3) := by + exact required_eq_combination childrenC_445_i0 childrenD_445_i0 (3, 3) required_445_i0 + (by decide +kernel) child_required_sub_445_i0 common_sub_445_i0 required_origin_445_i0 +theorem envelope_origin_445_i0 : ∀ x ∈ envelope_445_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_445_i0 j := by decide +kernel +theorem envelope_exact_445_i0 : envelope_445_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_445_i0) := by + exact envelope_eq_combination childrenD_445_i0 (3, 3) envelope_445_i0 + pivot_mem_445_i0 child_envelope_sub_445_i0 envelope_origin_445_i0 +def checked_445_i0 : CheckedCard where + required := required_445_i0 + envelope := envelope_445_i0 + height := height_445_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_445_i0 +def height_445 : ℕ := 5 +def childrenH_445 : Fin 2 → ℕ := ![height_5, height_445_i0] +theorem height_exact_445 : height_445 = 1 + Finset.univ.sup childrenH_445 := by decide +kernel +theorem required_origin_445 : ∀ x ∈ required_445, + (∃ j, x ∈ childrenC_445 j) ∨ ∀ j, x ∈ childrenD_445 j := by decide +kernel +theorem required_exact_445 : required_445 = + ((Finset.univ.biUnion childrenC_445) ∪ commonEnvelope childrenD_445).erase (3, 0) := by + exact required_eq_combination childrenC_445 childrenD_445 (3, 0) required_445 + (by decide +kernel) child_required_sub_445 common_sub_445 required_origin_445 +theorem envelope_origin_445 : ∀ x ∈ envelope_445, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_445 j := by decide +kernel +theorem envelope_exact_445 : envelope_445 = + insert (3, 0) (Finset.univ.biUnion childrenD_445) := by + exact envelope_eq_combination childrenD_445 (3, 0) envelope_445 + pivot_mem_445 child_envelope_sub_445 envelope_origin_445 +def checked_445 : CheckedCard where + required := required_445 + envelope := envelope_445 + height := height_445 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_445 +def height_451_i0 : ℕ := 4 +def childrenH_451_i0 : Fin 2 → ℕ := ![height_0, height_402] +theorem height_exact_451_i0 : height_451_i0 = 1 + Finset.univ.sup childrenH_451_i0 := by decide +kernel +theorem required_origin_451_i0 : ∀ x ∈ required_451_i0, + (∃ j, x ∈ childrenC_451_i0 j) ∨ ∀ j, x ∈ childrenD_451_i0 j := by decide +kernel +theorem required_exact_451_i0 : required_451_i0 = + ((Finset.univ.biUnion childrenC_451_i0) ∪ commonEnvelope childrenD_451_i0).erase (2, 3) := by + exact required_eq_combination childrenC_451_i0 childrenD_451_i0 (2, 3) required_451_i0 + (by decide +kernel) child_required_sub_451_i0 common_sub_451_i0 required_origin_451_i0 +theorem envelope_origin_451_i0 : ∀ x ∈ envelope_451_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_451_i0 j := by decide +kernel +theorem envelope_exact_451_i0 : envelope_451_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_451_i0) := by + exact envelope_eq_combination childrenD_451_i0 (2, 3) envelope_451_i0 + pivot_mem_451_i0 child_envelope_sub_451_i0 envelope_origin_451_i0 +def checked_451_i0 : CheckedCard where + required := required_451_i0 + envelope := envelope_451_i0 + height := height_451_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_451_i0 +def height_451 : ℕ := 5 +def childrenH_451 : Fin 2 → ℕ := ![height_11, height_451_i0] +theorem height_exact_451 : height_451 = 1 + Finset.univ.sup childrenH_451 := by decide +kernel +theorem required_origin_451 : ∀ x ∈ required_451, + (∃ j, x ∈ childrenC_451 j) ∨ ∀ j, x ∈ childrenD_451 j := by decide +kernel +theorem required_exact_451 : required_451 = + ((Finset.univ.biUnion childrenC_451) ∪ commonEnvelope childrenD_451).erase (1, 4) := by + exact required_eq_combination childrenC_451 childrenD_451 (1, 4) required_451 + (by decide +kernel) child_required_sub_451 common_sub_451 required_origin_451 +theorem envelope_origin_451 : ∀ x ∈ envelope_451, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_451 j := by decide +kernel +theorem envelope_exact_451 : envelope_451 = + insert (1, 4) (Finset.univ.biUnion childrenD_451) := by + exact envelope_eq_combination childrenD_451 (1, 4) envelope_451 + pivot_mem_451 child_envelope_sub_451 envelope_origin_451 +def checked_451 : CheckedCard where + required := required_451 + envelope := envelope_451 + height := height_451 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_451 +def height_464_i1 : ℕ := 3 +def childrenH_464_i1 : Fin 2 → ℕ := ![height_0, height_11] +theorem height_exact_464_i1 : height_464_i1 = 1 + Finset.univ.sup childrenH_464_i1 := by decide +kernel +theorem required_origin_464_i1 : ∀ x ∈ required_464_i1, + (∃ j, x ∈ childrenC_464_i1 j) ∨ ∀ j, x ∈ childrenD_464_i1 j := by decide +kernel +theorem required_exact_464_i1 : required_464_i1 = + ((Finset.univ.biUnion childrenC_464_i1) ∪ commonEnvelope childrenD_464_i1).erase (1, 1) := by + exact required_eq_combination childrenC_464_i1 childrenD_464_i1 (1, 1) required_464_i1 + (by decide +kernel) child_required_sub_464_i1 common_sub_464_i1 required_origin_464_i1 +theorem envelope_origin_464_i1 : ∀ x ∈ envelope_464_i1, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_464_i1 j := by decide +kernel +theorem envelope_exact_464_i1 : envelope_464_i1 = + insert (1, 1) (Finset.univ.biUnion childrenD_464_i1) := by + exact envelope_eq_combination childrenD_464_i1 (1, 1) envelope_464_i1 + pivot_mem_464_i1 child_envelope_sub_464_i1 envelope_origin_464_i1 +def checked_464_i1 : CheckedCard where + required := required_464_i1 + envelope := envelope_464_i1 + height := height_464_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_464_i1 +def height_464_i0 : ℕ := 4 +def childrenH_464_i0 : Fin 2 → ℕ := ![height_0, height_464_i1] +theorem height_exact_464_i0 : height_464_i0 = 1 + Finset.univ.sup childrenH_464_i0 := by decide +kernel +theorem required_origin_464_i0 : ∀ x ∈ required_464_i0, + (∃ j, x ∈ childrenC_464_i0 j) ∨ ∀ j, x ∈ childrenD_464_i0 j := by decide +kernel +theorem required_exact_464_i0 : required_464_i0 = + ((Finset.univ.biUnion childrenC_464_i0) ∪ commonEnvelope childrenD_464_i0).erase (2, 2) := by + exact required_eq_combination childrenC_464_i0 childrenD_464_i0 (2, 2) required_464_i0 + (by decide +kernel) child_required_sub_464_i0 common_sub_464_i0 required_origin_464_i0 +theorem envelope_origin_464_i0 : ∀ x ∈ envelope_464_i0, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_464_i0 j := by decide +kernel +theorem envelope_exact_464_i0 : envelope_464_i0 = + insert (2, 2) (Finset.univ.biUnion childrenD_464_i0) := by + exact envelope_eq_combination childrenD_464_i0 (2, 2) envelope_464_i0 + pivot_mem_464_i0 child_envelope_sub_464_i0 envelope_origin_464_i0 +def checked_464_i0 : CheckedCard where + required := required_464_i0 + envelope := envelope_464_i0 + height := height_464_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_464_i0 +def height_464_i2 : ℕ := 4 +def childrenH_464_i2 : Fin 2 → ℕ := ![height_29, height_38] +theorem height_exact_464_i2 : height_464_i2 = 1 + Finset.univ.sup childrenH_464_i2 := by decide +kernel +theorem required_origin_464_i2 : ∀ x ∈ required_464_i2, + (∃ j, x ∈ childrenC_464_i2 j) ∨ ∀ j, x ∈ childrenD_464_i2 j := by decide +kernel +theorem required_exact_464_i2 : required_464_i2 = + ((Finset.univ.biUnion childrenC_464_i2) ∪ commonEnvelope childrenD_464_i2).erase (1, 5) := by + exact required_eq_combination childrenC_464_i2 childrenD_464_i2 (1, 5) required_464_i2 + (by decide +kernel) child_required_sub_464_i2 common_sub_464_i2 required_origin_464_i2 +theorem envelope_origin_464_i2 : ∀ x ∈ envelope_464_i2, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_464_i2 j := by decide +kernel +theorem envelope_exact_464_i2 : envelope_464_i2 = + insert (1, 5) (Finset.univ.biUnion childrenD_464_i2) := by + exact envelope_eq_combination childrenD_464_i2 (1, 5) envelope_464_i2 + pivot_mem_464_i2 child_envelope_sub_464_i2 envelope_origin_464_i2 +def checked_464_i2 : CheckedCard where + required := required_464_i2 + envelope := envelope_464_i2 + height := height_464_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_464_i2 +def height_464 : ℕ := 5 +def childrenH_464 : Fin 3 → ℕ := ![height_15, height_464_i0, height_464_i2] +theorem height_exact_464 : height_464 = 1 + Finset.univ.sup childrenH_464 := by decide +kernel +theorem required_origin_464 : ∀ x ∈ required_464, + (∃ j, x ∈ childrenC_464 j) ∨ ∀ j, x ∈ childrenD_464 j := by decide +kernel +theorem required_exact_464 : required_464 = + ((Finset.univ.biUnion childrenC_464) ∪ commonEnvelope childrenD_464).erase (1, 2) := by + exact required_eq_combination childrenC_464 childrenD_464 (1, 2) required_464 + (by decide +kernel) child_required_sub_464 common_sub_464 required_origin_464 +theorem envelope_origin_464 : ∀ x ∈ envelope_464, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_464 j := by decide +kernel +theorem envelope_exact_464 : envelope_464 = + insert (1, 2) (Finset.univ.biUnion childrenD_464) := by + exact envelope_eq_combination childrenD_464 (1, 2) envelope_464 + pivot_mem_464 child_envelope_sub_464 envelope_origin_464 +def checked_464 : CheckedCard where + required := required_464 + envelope := envelope_464 + height := height_464 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_464 +def height_492_i1 : ℕ := 3 +def childrenH_492_i1 : Fin 2 → ℕ := ![height_0, height_32] +theorem height_exact_492_i1 : height_492_i1 = 1 + Finset.univ.sup childrenH_492_i1 := by decide +kernel +theorem required_origin_492_i1 : ∀ x ∈ required_492_i1, + (∃ j, x ∈ childrenC_492_i1 j) ∨ ∀ j, x ∈ childrenD_492_i1 j := by decide +kernel +theorem required_exact_492_i1 : required_492_i1 = + ((Finset.univ.biUnion childrenC_492_i1) ∪ commonEnvelope childrenD_492_i1).erase (2, 3) := by + exact required_eq_combination childrenC_492_i1 childrenD_492_i1 (2, 3) required_492_i1 + (by decide +kernel) child_required_sub_492_i1 common_sub_492_i1 required_origin_492_i1 +theorem envelope_origin_492_i1 : ∀ x ∈ envelope_492_i1, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_492_i1 j := by decide +kernel +theorem envelope_exact_492_i1 : envelope_492_i1 = + insert (2, 3) (Finset.univ.biUnion childrenD_492_i1) := by + exact envelope_eq_combination childrenD_492_i1 (2, 3) envelope_492_i1 + pivot_mem_492_i1 child_envelope_sub_492_i1 envelope_origin_492_i1 +def checked_492_i1 : CheckedCard where + required := required_492_i1 + envelope := envelope_492_i1 + height := height_492_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_492_i1 +def height_492_i0 : ℕ := 4 +def childrenH_492_i0 : Fin 2 → ℕ := ![height_0, height_492_i1] +theorem height_exact_492_i0 : height_492_i0 = 1 + Finset.univ.sup childrenH_492_i0 := by decide +kernel +theorem required_origin_492_i0 : ∀ x ∈ required_492_i0, + (∃ j, x ∈ childrenC_492_i0 j) ∨ ∀ j, x ∈ childrenD_492_i0 j := by decide +kernel +theorem required_exact_492_i0 : required_492_i0 = + ((Finset.univ.biUnion childrenC_492_i0) ∪ commonEnvelope childrenD_492_i0).erase (1, 3) := by + exact required_eq_combination childrenC_492_i0 childrenD_492_i0 (1, 3) required_492_i0 + (by decide +kernel) child_required_sub_492_i0 common_sub_492_i0 required_origin_492_i0 +theorem envelope_origin_492_i0 : ∀ x ∈ envelope_492_i0, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_492_i0 j := by decide +kernel +theorem envelope_exact_492_i0 : envelope_492_i0 = + insert (1, 3) (Finset.univ.biUnion childrenD_492_i0) := by + exact envelope_eq_combination childrenD_492_i0 (1, 3) envelope_492_i0 + pivot_mem_492_i0 child_envelope_sub_492_i0 envelope_origin_492_i0 +def checked_492_i0 : CheckedCard where + required := required_492_i0 + envelope := envelope_492_i0 + height := height_492_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_492_i0 +def height_492 : ℕ := 5 +def childrenH_492 : Fin 2 → ℕ := ![height_78, height_492_i0] +theorem height_exact_492 : height_492 = 1 + Finset.univ.sup childrenH_492 := by decide +kernel +theorem required_origin_492 : ∀ x ∈ required_492, + (∃ j, x ∈ childrenC_492 j) ∨ ∀ j, x ∈ childrenD_492 j := by decide +kernel +theorem required_exact_492 : required_492 = + ((Finset.univ.biUnion childrenC_492) ∪ commonEnvelope childrenD_492).erase (1, 2) := by + exact required_eq_combination childrenC_492 childrenD_492 (1, 2) required_492 + (by decide +kernel) child_required_sub_492 common_sub_492 required_origin_492 +theorem envelope_origin_492 : ∀ x ∈ envelope_492, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_492 j := by decide +kernel +theorem envelope_exact_492 : envelope_492 = + insert (1, 2) (Finset.univ.biUnion childrenD_492) := by + exact envelope_eq_combination childrenD_492 (1, 2) envelope_492 + pivot_mem_492 child_envelope_sub_492 envelope_origin_492 +def checked_492 : CheckedCard where + required := required_492 + envelope := envelope_492 + height := height_492 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_492 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part06.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part06.lean new file mode 100644 index 0000000..d878f7c --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part06.lean @@ -0,0 +1,974 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_495_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 5), (2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_495_i0 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3), (1, 5), (1, 6), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_495_i0 : Fin 2 → Finset Cell := ![(placed21 5 (2, 2) required_5), (placed21 4 (0, 5) required_221)] +def childrenD_495_i0 : Fin 2 → Finset Cell := ![(placed21 5 (2, 2) envelope_5), (placed21 4 (0, 5) envelope_221)] +theorem common_sub_495_i0 : commonEnvelope childrenD_495_i0 ⊆ insert (2, 2) required_495_i0 := by decide +kernel +theorem child_required_sub_495_i0 : ∀ j, childrenC_495_i0 j ⊆ insert (2, 2) required_495_i0 := by decide +kernel +theorem child_envelope_sub_495_i0 : ∀ j, childrenD_495_i0 j ⊆ envelope_495_i0 := by decide +kernel +theorem pivot_mem_495_i0 : (2, 2) ∈ envelope_495_i0 := by decide +kernel +theorem children_work_495_i0 : ∀ j, Template HasSnaky 3 (childrenC_495_i0 j) (childrenD_495_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_221 4 (0, 5)).mono (by decide +kernel) +theorem row_works_495_i0 : Template HasSnaky 4 required_495_i0 envelope_495_i0 := by + refine compose HasSnaky 3 childrenC_495_i0 childrenD_495_i0 children_work_495_i0 (2, 2) + required_495_i0 envelope_495_i0 pivot_mem_495_i0 child_required_sub_495_i0 child_envelope_sub_495_i0 ?_ + intro b hb + exact common_sub_495_i0 (mem_commonEnvelope childrenD_495_i0 b hb) +def required_495 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 5), (2, 3), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_495 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 6), (3, 7), (3, 8), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_495 : Fin 4 → Finset Cell := ![(placed21 0 (1, 2) required_10), (placed21 2 (2, 2) required_52), (placed21 6 (2, 6) required_52), required_495_i0] +def childrenD_495 : Fin 4 → Finset Cell := ![(placed21 0 (1, 2) envelope_10), (placed21 2 (2, 2) envelope_52), (placed21 6 (2, 6) envelope_52), envelope_495_i0] +theorem common_sub_495 : commonEnvelope childrenD_495 ⊆ insert (2, 4) required_495 := by decide +kernel +theorem child_required_sub_495 : ∀ j, childrenC_495 j ⊆ insert (2, 4) required_495 := by decide +kernel +theorem child_envelope_sub_495 : ∀ j, childrenD_495 j ⊆ envelope_495 := by decide +kernel +theorem pivot_mem_495 : (2, 4) ∈ envelope_495 := by decide +kernel +theorem children_work_495 : ∀ j, Template HasSnaky 4 (childrenC_495 j) (childrenD_495 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (2, 6)).mono (by decide +kernel) + · exact row_works_495_i0.mono (by decide +kernel) +theorem row_works_495 : Template HasSnaky 5 required_495 envelope_495 := by + refine compose HasSnaky 4 childrenC_495 childrenD_495 children_work_495 (2, 4) + required_495 envelope_495 pivot_mem_495 child_required_sub_495 child_envelope_sub_495 ?_ + intro b hb + exact common_sub_495 (mem_commonEnvelope childrenD_495 b hb) +def required_497 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 4), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_497 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (2, 1), (3, 1), (3, 2), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_497 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_5), required_496] +def childrenD_497 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_5), envelope_496] +theorem common_sub_497 : commonEnvelope childrenD_497 ⊆ insert (0, 3) required_497 := by decide +kernel +theorem child_required_sub_497 : ∀ j, childrenC_497 j ⊆ insert (0, 3) required_497 := by decide +kernel +theorem child_envelope_sub_497 : ∀ j, childrenD_497 j ⊆ envelope_497 := by decide +kernel +theorem pivot_mem_497 : (0, 3) ∈ envelope_497 := by decide +kernel +theorem children_work_497 : ∀ j, Template HasSnaky 4 (childrenC_497 j) (childrenD_497 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (0, 1)).mono (by decide +kernel) + · exact row_works_496.mono (by decide +kernel) +theorem row_works_497 : Template HasSnaky 5 required_497 envelope_497 := by + refine compose HasSnaky 4 childrenC_497 childrenD_497 children_work_497 (0, 3) + required_497 envelope_497 pivot_mem_497 child_required_sub_497 child_envelope_sub_497 ?_ + intro b hb + exact common_sub_497 (mem_commonEnvelope childrenD_497 b hb) +def required_501 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 4), (3, 1), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_501 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_501 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) required_2), required_500] +def childrenD_501 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) envelope_2), envelope_500] +theorem common_sub_501 : commonEnvelope childrenD_501 ⊆ insert (1, 3) required_501 := by decide +kernel +theorem child_required_sub_501 : ∀ j, childrenC_501 j ⊆ insert (1, 3) required_501 := by decide +kernel +theorem child_envelope_sub_501 : ∀ j, childrenD_501 j ⊆ envelope_501 := by decide +kernel +theorem pivot_mem_501 : (1, 3) ∈ envelope_501 := by decide +kernel +theorem children_work_501 : ∀ j, Template HasSnaky 4 (childrenC_501 j) (childrenD_501 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 2 (4, 3)).mono (by decide +kernel) + · exact row_works_500.mono (by decide +kernel) +theorem row_works_501 : Template HasSnaky 5 required_501 envelope_501 := by + refine compose HasSnaky 4 childrenC_501 childrenD_501 children_work_501 (1, 3) + required_501 envelope_501 pivot_mem_501 child_required_sub_501 child_envelope_sub_501 ?_ + intro b hb + exact common_sub_501 (mem_commonEnvelope childrenD_501 b hb) +def required_502_i0 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_502_i0 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_502_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) required_11), (placed21 4 (2, 6) required_53)] +def childrenD_502_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) envelope_11), (placed21 4 (2, 6) envelope_53)] +theorem common_sub_502_i0 : commonEnvelope childrenD_502_i0 ⊆ insert (2, 4) required_502_i0 := by decide +kernel +theorem child_required_sub_502_i0 : ∀ j, childrenC_502_i0 j ⊆ insert (2, 4) required_502_i0 := by decide +kernel +theorem child_envelope_sub_502_i0 : ∀ j, childrenD_502_i0 j ⊆ envelope_502_i0 := by decide +kernel +theorem pivot_mem_502_i0 : (2, 4) ∈ envelope_502_i0 := by decide +kernel +theorem children_work_502_i0 : ∀ j, Template HasSnaky 3 (childrenC_502_i0 j) (childrenD_502_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_53 4 (2, 6)).mono (by decide +kernel) +theorem row_works_502_i0 : Template HasSnaky 4 required_502_i0 envelope_502_i0 := by + refine compose HasSnaky 3 childrenC_502_i0 childrenD_502_i0 children_work_502_i0 (2, 4) + required_502_i0 envelope_502_i0 pivot_mem_502_i0 child_required_sub_502_i0 child_envelope_sub_502_i0 ?_ + intro b hb + exact common_sub_502_i0 (mem_commonEnvelope childrenD_502_i0 b hb) +def required_502 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 2), (3, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_502 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_502 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) required_7), (placed21 4 (1, 5) required_69), required_502_i0] +def childrenD_502 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) envelope_7), (placed21 4 (1, 5) envelope_69), envelope_502_i0] +theorem common_sub_502 : commonEnvelope childrenD_502 ⊆ insert (4, 3) required_502 := by decide +kernel +theorem child_required_sub_502 : ∀ j, childrenC_502 j ⊆ insert (4, 3) required_502 := by decide +kernel +theorem child_envelope_sub_502 : ∀ j, childrenD_502 j ⊆ envelope_502 := by decide +kernel +theorem pivot_mem_502 : (4, 3) ∈ envelope_502 := by decide +kernel +theorem children_work_502 : ∀ j, Template HasSnaky 4 (childrenC_502 j) (childrenD_502 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_69 4 (1, 5)).mono (by decide +kernel) + · exact row_works_502_i0.mono (by decide +kernel) +theorem row_works_502 : Template HasSnaky 5 required_502 envelope_502 := by + refine compose HasSnaky 4 childrenC_502 childrenD_502 children_work_502 (4, 3) + required_502 envelope_502 pivot_mem_502 child_required_sub_502 child_envelope_sub_502 ?_ + intro b hb + exact common_sub_502 (mem_commonEnvelope childrenD_502 b hb) +def required_505_i0 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (4, 1), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_505_i0 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_505_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) required_5), (placed21 0 (1, 0) required_350)] +def childrenD_505_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) envelope_5), (placed21 0 (1, 0) envelope_350)] +theorem common_sub_505_i0 : commonEnvelope childrenD_505_i0 ⊆ insert (4, 2) required_505_i0 := by decide +kernel +theorem child_required_sub_505_i0 : ∀ j, childrenC_505_i0 j ⊆ insert (4, 2) required_505_i0 := by decide +kernel +theorem child_envelope_sub_505_i0 : ∀ j, childrenD_505_i0 j ⊆ envelope_505_i0 := by decide +kernel +theorem pivot_mem_505_i0 : (4, 2) ∈ envelope_505_i0 := by decide +kernel +theorem children_work_505_i0 : ∀ j, Template HasSnaky 3 (childrenC_505_i0 j) (childrenD_505_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_350 0 (1, 0)).mono (by decide +kernel) +theorem row_works_505_i0 : Template HasSnaky 4 required_505_i0 envelope_505_i0 := by + refine compose HasSnaky 3 childrenC_505_i0 childrenD_505_i0 children_work_505_i0 (4, 2) + required_505_i0 envelope_505_i0 pivot_mem_505_i0 child_required_sub_505_i0 child_envelope_sub_505_i0 ?_ + intro b hb + exact common_sub_505_i0 (mem_commonEnvelope childrenD_505_i0 b hb) +def required_505_i2 : Finset Cell := ⟨(([(3, 1), (4, 1), (4, 2), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_505_i2 : Finset Cell := ⟨(([(3, 0), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_505_i2 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) required_5), (placed21 0 (4, 1) required_6)] +def childrenD_505_i2 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) envelope_5), (placed21 0 (4, 1) envelope_6)] +theorem common_sub_505_i2 : commonEnvelope childrenD_505_i2 ⊆ insert (4, 3) required_505_i2 := by decide +kernel +theorem child_required_sub_505_i2 : ∀ j, childrenC_505_i2 j ⊆ insert (4, 3) required_505_i2 := by decide +kernel +theorem child_envelope_sub_505_i2 : ∀ j, childrenD_505_i2 j ⊆ envelope_505_i2 := by decide +kernel +theorem pivot_mem_505_i2 : (4, 3) ∈ envelope_505_i2 := by decide +kernel +theorem children_work_505_i2 : ∀ j, Template HasSnaky 2 (childrenC_505_i2 j) (childrenD_505_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_6 0 (4, 1)).mono (by decide +kernel) +theorem row_works_505_i2 : Template HasSnaky 3 required_505_i2 envelope_505_i2 := by + refine compose HasSnaky 2 childrenC_505_i2 childrenD_505_i2 children_work_505_i2 (4, 3) + required_505_i2 envelope_505_i2 pivot_mem_505_i2 child_required_sub_505_i2 child_envelope_sub_505_i2 ?_ + intro b hb + exact common_sub_505_i2 (mem_commonEnvelope childrenD_505_i2 b hb) +def required_505_i1 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (4, 1), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_505_i1 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 0), (3, 1), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 2), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_505_i1 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) required_5), required_505_i2] +def childrenD_505_i1 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) envelope_5), envelope_505_i2] +theorem common_sub_505_i1 : commonEnvelope childrenD_505_i1 ⊆ insert (4, 2) required_505_i1 := by decide +kernel +theorem child_required_sub_505_i1 : ∀ j, childrenC_505_i1 j ⊆ insert (4, 2) required_505_i1 := by decide +kernel +theorem child_envelope_sub_505_i1 : ∀ j, childrenD_505_i1 j ⊆ envelope_505_i1 := by decide +kernel +theorem pivot_mem_505_i1 : (4, 2) ∈ envelope_505_i1 := by decide +kernel +theorem children_work_505_i1 : ∀ j, Template HasSnaky 3 (childrenC_505_i1 j) (childrenD_505_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 1)).mono (by decide +kernel) + · exact row_works_505_i2.mono (by decide +kernel) +theorem row_works_505_i1 : Template HasSnaky 4 required_505_i1 envelope_505_i1 := by + refine compose HasSnaky 3 childrenC_505_i1 childrenD_505_i1 children_work_505_i1 (4, 2) + required_505_i1 envelope_505_i1 pivot_mem_505_i1 child_required_sub_505_i1 child_envelope_sub_505_i1 ?_ + intro b hb + exact common_sub_505_i1 (mem_commonEnvelope childrenD_505_i1 b hb) +def required_505 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_505 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 0), (3, 1), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_505 : Fin 3 → Finset Cell := ![(placed21 3 (0, 1) required_6), required_505_i0, required_505_i1] +def childrenD_505 : Fin 3 → Finset Cell := ![(placed21 3 (0, 1) envelope_6), envelope_505_i0, envelope_505_i1] +theorem common_sub_505 : commonEnvelope childrenD_505 ⊆ insert (4, 1) required_505 := by decide +kernel +theorem child_required_sub_505 : ∀ j, childrenC_505 j ⊆ insert (4, 1) required_505 := by decide +kernel +theorem child_envelope_sub_505 : ∀ j, childrenD_505 j ⊆ envelope_505 := by decide +kernel +theorem pivot_mem_505 : (4, 1) ∈ envelope_505 := by decide +kernel +theorem children_work_505 : ∀ j, Template HasSnaky 4 (childrenC_505 j) (childrenD_505 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 1)).mono (by decide +kernel) + · exact row_works_505_i0.mono (by decide +kernel) + · exact row_works_505_i1.mono (by decide +kernel) +theorem row_works_505 : Template HasSnaky 5 required_505 envelope_505 := by + refine compose HasSnaky 4 childrenC_505 childrenD_505 children_work_505 (4, 1) + required_505 envelope_505 pivot_mem_505 child_required_sub_505 child_envelope_sub_505 ?_ + intro b hb + exact common_sub_505 (mem_commonEnvelope childrenD_505 b hb) +def required_506_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_506_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_506_i0 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) required_7), (placed21 3 (0, 5) required_32)] +def childrenD_506_i0 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) envelope_7), (placed21 3 (0, 5) envelope_32)] +theorem common_sub_506_i0 : commonEnvelope childrenD_506_i0 ⊆ insert (1, 2) required_506_i0 := by decide +kernel +theorem child_required_sub_506_i0 : ∀ j, childrenC_506_i0 j ⊆ insert (1, 2) required_506_i0 := by decide +kernel +theorem child_envelope_sub_506_i0 : ∀ j, childrenD_506_i0 j ⊆ envelope_506_i0 := by decide +kernel +theorem pivot_mem_506_i0 : (1, 2) ∈ envelope_506_i0 := by decide +kernel +theorem children_work_506_i0 : ∀ j, Template HasSnaky 3 (childrenC_506_i0 j) (childrenD_506_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_32 3 (0, 5)).mono (by decide +kernel) +theorem row_works_506_i0 : Template HasSnaky 4 required_506_i0 envelope_506_i0 := by + refine compose HasSnaky 3 childrenC_506_i0 childrenD_506_i0 children_work_506_i0 (1, 2) + required_506_i0 envelope_506_i0 pivot_mem_506_i0 child_required_sub_506_i0 child_envelope_sub_506_i0 ?_ + intro b hb + exact common_sub_506_i0 (mem_commonEnvelope childrenD_506_i0 b hb) +def required_506 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_506 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_506 : Fin 3 → Finset Cell := ![(placed21 4 (1, 6) required_44), (placed21 0 (0, 1) required_67), required_506_i0] +def childrenD_506 : Fin 3 → Finset Cell := ![(placed21 4 (1, 6) envelope_44), (placed21 0 (0, 1) envelope_67), envelope_506_i0] +theorem common_sub_506 : commonEnvelope childrenD_506 ⊆ insert (1, 5) required_506 := by decide +kernel +theorem child_required_sub_506 : ∀ j, childrenC_506 j ⊆ insert (1, 5) required_506 := by decide +kernel +theorem child_envelope_sub_506 : ∀ j, childrenD_506 j ⊆ envelope_506 := by decide +kernel +theorem pivot_mem_506 : (1, 5) ∈ envelope_506 := by decide +kernel +theorem children_work_506 : ∀ j, Template HasSnaky 4 (childrenC_506 j) (childrenD_506 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_67 0 (0, 1)).mono (by decide +kernel) + · exact row_works_506_i0.mono (by decide +kernel) +theorem row_works_506 : Template HasSnaky 5 required_506 envelope_506 := by + refine compose HasSnaky 4 childrenC_506 childrenD_506 children_work_506 (1, 5) + required_506 envelope_506 pivot_mem_506 child_required_sub_506 child_envelope_sub_506 ?_ + intro b hb + exact common_sub_506 (mem_commonEnvelope childrenD_506 b hb) +def required_515_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (2, 1), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_515_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (2, 1), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_515_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 1) required_0), required_78] +def childrenD_515_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 1) envelope_0), envelope_78] +theorem common_sub_515_i0 : commonEnvelope childrenD_515_i0 ⊆ insert (3, 1) required_515_i0 := by decide +kernel +theorem child_required_sub_515_i0 : ∀ j, childrenC_515_i0 j ⊆ insert (3, 1) required_515_i0 := by decide +kernel +theorem child_envelope_sub_515_i0 : ∀ j, childrenD_515_i0 j ⊆ envelope_515_i0 := by decide +kernel +theorem pivot_mem_515_i0 : (3, 1) ∈ envelope_515_i0 := by decide +kernel +theorem children_work_515_i0 : ∀ j, Template HasSnaky 3 (childrenC_515_i0 j) (childrenD_515_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 1)).mono (by decide +kernel) + · exact row_works_78.mono (by decide +kernel) +theorem row_works_515_i0 : Template HasSnaky 4 required_515_i0 envelope_515_i0 := by + refine compose HasSnaky 3 childrenC_515_i0 childrenD_515_i0 children_work_515_i0 (3, 1) + required_515_i0 envelope_515_i0 pivot_mem_515_i0 child_required_sub_515_i0 child_envelope_sub_515_i0 ?_ + intro b hb + exact common_sub_515_i0 (mem_commonEnvelope childrenD_515_i0 b hb) +def required_515 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_515 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 0), (1, 1), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_515 : Fin 2 → Finset Cell := ![(placed21 7 (2, 4) required_2), required_515_i0] +def childrenD_515 : Fin 2 → Finset Cell := ![(placed21 7 (2, 4) envelope_2), envelope_515_i0] +theorem common_sub_515 : commonEnvelope childrenD_515 ⊆ insert (2, 1) required_515 := by decide +kernel +theorem child_required_sub_515 : ∀ j, childrenC_515 j ⊆ insert (2, 1) required_515 := by decide +kernel +theorem child_envelope_sub_515 : ∀ j, childrenD_515 j ⊆ envelope_515 := by decide +kernel +theorem pivot_mem_515 : (2, 1) ∈ envelope_515 := by decide +kernel +theorem children_work_515 : ∀ j, Template HasSnaky 4 (childrenC_515 j) (childrenD_515 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 7 (2, 4)).mono (by decide +kernel) + · exact row_works_515_i0.mono (by decide +kernel) +theorem row_works_515 : Template HasSnaky 5 required_515 envelope_515 := by + refine compose HasSnaky 4 childrenC_515 childrenD_515 children_work_515 (2, 1) + required_515 envelope_515 pivot_mem_515 child_required_sub_515 child_envelope_sub_515 ?_ + intro b hb + exact common_sub_515 (mem_commonEnvelope childrenD_515 b hb) +def required_592_i0 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 4), (1, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_592_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_592_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_1), (placed21 4 (1, 6) required_158)] +def childrenD_592_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_1), (placed21 4 (1, 6) envelope_158)] +theorem common_sub_592_i0 : commonEnvelope childrenD_592_i0 ⊆ insert (1, 5) required_592_i0 := by decide +kernel +theorem child_required_sub_592_i0 : ∀ j, childrenC_592_i0 j ⊆ insert (1, 5) required_592_i0 := by decide +kernel +theorem child_envelope_sub_592_i0 : ∀ j, childrenD_592_i0 j ⊆ envelope_592_i0 := by decide +kernel +theorem pivot_mem_592_i0 : (1, 5) ∈ envelope_592_i0 := by decide +kernel +theorem children_work_592_i0 : ∀ j, Template HasSnaky 3 (childrenC_592_i0 j) (childrenD_592_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_158 4 (1, 6)).mono (by decide +kernel) +theorem row_works_592_i0 : Template HasSnaky 4 required_592_i0 envelope_592_i0 := by + refine compose HasSnaky 3 childrenC_592_i0 childrenD_592_i0 children_work_592_i0 (1, 5) + required_592_i0 envelope_592_i0 pivot_mem_592_i0 child_required_sub_592_i0 child_envelope_sub_592_i0 ?_ + intro b hb + exact common_sub_592_i0 (mem_commonEnvelope childrenD_592_i0 b hb) +def required_592 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 4), (1, 1), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_592 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_592 : Fin 4 → Finset Cell := ![(placed21 4 (0, 5) required_22), (placed21 6 (1, 4) required_36), required_150, required_592_i0] +def childrenD_592 : Fin 4 → Finset Cell := ![(placed21 4 (0, 5) envelope_22), (placed21 6 (1, 4) envelope_36), envelope_150, envelope_592_i0] +theorem common_sub_592 : commonEnvelope childrenD_592 ⊆ insert (1, 4) required_592 := by decide +kernel +theorem child_required_sub_592 : ∀ j, childrenC_592 j ⊆ insert (1, 4) required_592 := by decide +kernel +theorem child_envelope_sub_592 : ∀ j, childrenD_592 j ⊆ envelope_592 := by decide +kernel +theorem pivot_mem_592 : (1, 4) ∈ envelope_592 := by decide +kernel +theorem children_work_592 : ∀ j, Template HasSnaky 4 (childrenC_592 j) (childrenD_592 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 4 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_36 6 (1, 4)).mono (by decide +kernel) + · exact row_works_150.mono (by decide +kernel) + · exact row_works_592_i0.mono (by decide +kernel) +theorem row_works_592 : Template HasSnaky 5 required_592 envelope_592 := by + refine compose HasSnaky 4 childrenC_592 childrenD_592 children_work_592 (1, 4) + required_592 envelope_592 pivot_mem_592 child_required_sub_592 child_envelope_sub_592 ?_ + intro b hb + exact common_sub_592 (mem_commonEnvelope childrenD_592 b hb) +def required_612_i1 : Finset Cell := ⟨(([(1, 1), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_612_i1 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_612_i1 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) required_6), (placed21 2 (1, 1) required_6)] +def childrenD_612_i1 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) envelope_6), (placed21 2 (1, 1) envelope_6)] +theorem common_sub_612_i1 : commonEnvelope childrenD_612_i1 ⊆ insert (1, 2) required_612_i1 := by decide +kernel +theorem child_required_sub_612_i1 : ∀ j, childrenC_612_i1 j ⊆ insert (1, 2) required_612_i1 := by decide +kernel +theorem child_envelope_sub_612_i1 : ∀ j, childrenD_612_i1 j ⊆ envelope_612_i1 := by decide +kernel +theorem pivot_mem_612_i1 : (1, 2) ∈ envelope_612_i1 := by decide +kernel +theorem children_work_612_i1 : ∀ j, Template HasSnaky 2 (childrenC_612_i1 j) (childrenD_612_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_6 2 (1, 1)).mono (by decide +kernel) +theorem row_works_612_i1 : Template HasSnaky 3 required_612_i1 envelope_612_i1 := by + refine compose HasSnaky 2 childrenC_612_i1 childrenD_612_i1 children_work_612_i1 (1, 2) + required_612_i1 envelope_612_i1 pivot_mem_612_i1 child_required_sub_612_i1 child_envelope_sub_612_i1 ?_ + intro b hb + exact common_sub_612_i1 (mem_commonEnvelope childrenD_612_i1 b hb) +def required_612_i2 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_612_i2 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_612_i2 : Fin 2 → Finset Cell := ![(placed21 7 (1, 6) required_0), (placed21 1 (0, 1) required_3)] +def childrenD_612_i2 : Fin 2 → Finset Cell := ![(placed21 7 (1, 6) envelope_0), (placed21 1 (0, 1) envelope_3)] +theorem common_sub_612_i2 : commonEnvelope childrenD_612_i2 ⊆ insert (0, 2) required_612_i2 := by decide +kernel +theorem child_required_sub_612_i2 : ∀ j, childrenC_612_i2 j ⊆ insert (0, 2) required_612_i2 := by decide +kernel +theorem child_envelope_sub_612_i2 : ∀ j, childrenD_612_i2 j ⊆ envelope_612_i2 := by decide +kernel +theorem pivot_mem_612_i2 : (0, 2) ∈ envelope_612_i2 := by decide +kernel +theorem children_work_612_i2 : ∀ j, Template HasSnaky 1 (childrenC_612_i2 j) (childrenD_612_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_3 1 (0, 1)).mono (by decide +kernel) +theorem row_works_612_i2 : Template HasSnaky 2 required_612_i2 envelope_612_i2 := by + refine compose HasSnaky 1 childrenC_612_i2 childrenD_612_i2 children_work_612_i2 (0, 2) + required_612_i2 envelope_612_i2 pivot_mem_612_i2 child_required_sub_612_i2 child_envelope_sub_612_i2 ?_ + intro b hb + exact common_sub_612_i2 (mem_commonEnvelope childrenD_612_i2 b hb) +def required_612_i3 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_612_i3 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_612_i3 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_4), (placed21 0 (1, 1) required_6)] +def childrenD_612_i3 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_4), (placed21 0 (1, 1) envelope_6)] +theorem common_sub_612_i3 : commonEnvelope childrenD_612_i3 ⊆ insert (1, 2) required_612_i3 := by decide +kernel +theorem child_required_sub_612_i3 : ∀ j, childrenC_612_i3 j ⊆ insert (1, 2) required_612_i3 := by decide +kernel +theorem child_envelope_sub_612_i3 : ∀ j, childrenD_612_i3 j ⊆ envelope_612_i3 := by decide +kernel +theorem pivot_mem_612_i3 : (1, 2) ∈ envelope_612_i3 := by decide +kernel +theorem children_work_612_i3 : ∀ j, Template HasSnaky 2 (childrenC_612_i3 j) (childrenD_612_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_6 0 (1, 1)).mono (by decide +kernel) +theorem row_works_612_i3 : Template HasSnaky 3 required_612_i3 envelope_612_i3 := by + refine compose HasSnaky 2 childrenC_612_i3 childrenD_612_i3 children_work_612_i3 (1, 2) + required_612_i3 envelope_612_i3 pivot_mem_612_i3 child_required_sub_612_i3 child_envelope_sub_612_i3 ?_ + intro b hb + exact common_sub_612_i3 (mem_commonEnvelope childrenD_612_i3 b hb) +def required_612_i0 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_612_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_612_i0 : Fin 3 → Finset Cell := ![required_612_i1, required_612_i2, required_612_i3] +def childrenD_612_i0 : Fin 3 → Finset Cell := ![envelope_612_i1, envelope_612_i2, envelope_612_i3] +theorem common_sub_612_i0 : commonEnvelope childrenD_612_i0 ⊆ insert (1, 5) required_612_i0 := by decide +kernel +theorem child_required_sub_612_i0 : ∀ j, childrenC_612_i0 j ⊆ insert (1, 5) required_612_i0 := by decide +kernel +theorem child_envelope_sub_612_i0 : ∀ j, childrenD_612_i0 j ⊆ envelope_612_i0 := by decide +kernel +theorem pivot_mem_612_i0 : (1, 5) ∈ envelope_612_i0 := by decide +kernel +theorem children_work_612_i0 : ∀ j, Template HasSnaky 3 (childrenC_612_i0 j) (childrenD_612_i0 j) := by + intro j + fin_cases j + · exact row_works_612_i1.mono (by decide +kernel) + · exact row_works_612_i2.mono (by decide +kernel) + · exact row_works_612_i3.mono (by decide +kernel) +theorem row_works_612_i0 : Template HasSnaky 4 required_612_i0 envelope_612_i0 := by + refine compose HasSnaky 3 childrenC_612_i0 childrenD_612_i0 children_work_612_i0 (1, 5) + required_612_i0 envelope_612_i0 pivot_mem_612_i0 child_required_sub_612_i0 child_envelope_sub_612_i0 ?_ + intro b hb + exact common_sub_612_i0 (mem_commonEnvelope childrenD_612_i0 b hb) +def required_612 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_612 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_612 : Fin 4 → Finset Cell := ![(placed21 6 (1, 4) required_36), required_50, required_54, required_612_i0] +def childrenD_612 : Fin 4 → Finset Cell := ![(placed21 6 (1, 4) envelope_36), envelope_50, envelope_54, envelope_612_i0] +theorem common_sub_612 : commonEnvelope childrenD_612 ⊆ insert (1, 4) required_612 := by decide +kernel +theorem child_required_sub_612 : ∀ j, childrenC_612 j ⊆ insert (1, 4) required_612 := by decide +kernel +theorem child_envelope_sub_612 : ∀ j, childrenD_612 j ⊆ envelope_612 := by decide +kernel +theorem pivot_mem_612 : (1, 4) ∈ envelope_612 := by decide +kernel +theorem children_work_612 : ∀ j, Template HasSnaky 4 (childrenC_612 j) (childrenD_612 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_36 6 (1, 4)).mono (by decide +kernel) + · exact row_works_50.mono (by decide +kernel) + · exact row_works_54.mono (by decide +kernel) + · exact row_works_612_i0.mono (by decide +kernel) +theorem row_works_612 : Template HasSnaky 5 required_612 envelope_612 := by + refine compose HasSnaky 4 childrenC_612 childrenD_612 children_work_612 (1, 4) + required_612 envelope_612 pivot_mem_612 child_required_sub_612 child_envelope_sub_612 ?_ + intro b hb + exact common_sub_612 (mem_commonEnvelope childrenD_612 b hb) +def required_672_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 4), (2, 2), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_672_i0 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (3, 1), (4, 1), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_672_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) required_22), (placed21 1 (0, 1) required_22)] +def childrenD_672_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) envelope_22), (placed21 1 (0, 1) envelope_22)] +theorem common_sub_672_i0 : commonEnvelope childrenD_672_i0 ⊆ insert (2, 1) required_672_i0 := by decide +kernel +theorem child_required_sub_672_i0 : ∀ j, childrenC_672_i0 j ⊆ insert (2, 1) required_672_i0 := by decide +kernel +theorem child_envelope_sub_672_i0 : ∀ j, childrenD_672_i0 j ⊆ envelope_672_i0 := by decide +kernel +theorem pivot_mem_672_i0 : (2, 1) ∈ envelope_672_i0 := by decide +kernel +theorem children_work_672_i0 : ∀ j, Template HasSnaky 2 (childrenC_672_i0 j) (childrenD_672_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_22 1 (0, 1)).mono (by decide +kernel) +theorem row_works_672_i0 : Template HasSnaky 3 required_672_i0 envelope_672_i0 := by + refine compose HasSnaky 2 childrenC_672_i0 childrenD_672_i0 children_work_672_i0 (2, 1) + required_672_i0 envelope_672_i0 pivot_mem_672_i0 child_required_sub_672_i0 child_envelope_sub_672_i0 ?_ + intro b hb + exact common_sub_672_i0 (mem_commonEnvelope childrenD_672_i0 b hb) +def required_672 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 4), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_672 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (4, 1), (4, 2), (4, 3), (5, 1), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_672 : Fin 3 → Finset Cell := ![(placed21 3 (0, 2) required_34), (placed21 1 (0, 1) required_305), required_672_i0] +def childrenD_672 : Fin 3 → Finset Cell := ![(placed21 3 (0, 2) envelope_34), (placed21 1 (0, 1) envelope_305), envelope_672_i0] +theorem common_sub_672 : commonEnvelope childrenD_672 ⊆ insert (2, 2) required_672 := by decide +kernel +theorem child_required_sub_672 : ∀ j, childrenC_672 j ⊆ insert (2, 2) required_672 := by decide +kernel +theorem child_envelope_sub_672 : ∀ j, childrenD_672 j ⊆ envelope_672 := by decide +kernel +theorem pivot_mem_672 : (2, 2) ∈ envelope_672 := by decide +kernel +theorem children_work_672 : ∀ j, Template HasSnaky 4 (childrenC_672 j) (childrenD_672 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_34 3 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_305 1 (0, 1)).mono (by decide +kernel) + · exact row_works_672_i0.mono (by decide +kernel) +theorem row_works_672 : Template HasSnaky 5 required_672 envelope_672 := by + refine compose HasSnaky 4 childrenC_672 childrenD_672 children_work_672 (2, 2) + required_672 envelope_672 pivot_mem_672 child_required_sub_672 child_envelope_sub_672 ?_ + intro b hb + exact common_sub_672 (mem_commonEnvelope childrenD_672 b hb) +def height_495_i0 : ℕ := 4 +def childrenH_495_i0 : Fin 2 → ℕ := ![height_5, height_221] +theorem height_exact_495_i0 : height_495_i0 = 1 + Finset.univ.sup childrenH_495_i0 := by decide +kernel +theorem required_origin_495_i0 : ∀ x ∈ required_495_i0, + (∃ j, x ∈ childrenC_495_i0 j) ∨ ∀ j, x ∈ childrenD_495_i0 j := by decide +kernel +theorem required_exact_495_i0 : required_495_i0 = + ((Finset.univ.biUnion childrenC_495_i0) ∪ commonEnvelope childrenD_495_i0).erase (2, 2) := by + exact required_eq_combination childrenC_495_i0 childrenD_495_i0 (2, 2) required_495_i0 + (by decide +kernel) child_required_sub_495_i0 common_sub_495_i0 required_origin_495_i0 +theorem envelope_origin_495_i0 : ∀ x ∈ envelope_495_i0, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_495_i0 j := by decide +kernel +theorem envelope_exact_495_i0 : envelope_495_i0 = + insert (2, 2) (Finset.univ.biUnion childrenD_495_i0) := by + exact envelope_eq_combination childrenD_495_i0 (2, 2) envelope_495_i0 + pivot_mem_495_i0 child_envelope_sub_495_i0 envelope_origin_495_i0 +def checked_495_i0 : CheckedCard where + required := required_495_i0 + envelope := envelope_495_i0 + height := height_495_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_495_i0 +def height_495 : ℕ := 5 +def childrenH_495 : Fin 4 → ℕ := ![height_10, height_52, height_52, height_495_i0] +theorem height_exact_495 : height_495 = 1 + Finset.univ.sup childrenH_495 := by decide +kernel +theorem required_origin_495 : ∀ x ∈ required_495, + (∃ j, x ∈ childrenC_495 j) ∨ ∀ j, x ∈ childrenD_495 j := by decide +kernel +theorem required_exact_495 : required_495 = + ((Finset.univ.biUnion childrenC_495) ∪ commonEnvelope childrenD_495).erase (2, 4) := by + exact required_eq_combination childrenC_495 childrenD_495 (2, 4) required_495 + (by decide +kernel) child_required_sub_495 common_sub_495 required_origin_495 +theorem envelope_origin_495 : ∀ x ∈ envelope_495, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_495 j := by decide +kernel +theorem envelope_exact_495 : envelope_495 = + insert (2, 4) (Finset.univ.biUnion childrenD_495) := by + exact envelope_eq_combination childrenD_495 (2, 4) envelope_495 + pivot_mem_495 child_envelope_sub_495 envelope_origin_495 +def checked_495 : CheckedCard where + required := required_495 + envelope := envelope_495 + height := height_495 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_495 +def height_497 : ℕ := 5 +def childrenH_497 : Fin 2 → ℕ := ![height_5, height_496] +theorem height_exact_497 : height_497 = 1 + Finset.univ.sup childrenH_497 := by decide +kernel +theorem required_origin_497 : ∀ x ∈ required_497, + (∃ j, x ∈ childrenC_497 j) ∨ ∀ j, x ∈ childrenD_497 j := by decide +kernel +theorem required_exact_497 : required_497 = + ((Finset.univ.biUnion childrenC_497) ∪ commonEnvelope childrenD_497).erase (0, 3) := by + exact required_eq_combination childrenC_497 childrenD_497 (0, 3) required_497 + (by decide +kernel) child_required_sub_497 common_sub_497 required_origin_497 +theorem envelope_origin_497 : ∀ x ∈ envelope_497, + x = (0, 3) ∨ ∃ j, x ∈ childrenD_497 j := by decide +kernel +theorem envelope_exact_497 : envelope_497 = + insert (0, 3) (Finset.univ.biUnion childrenD_497) := by + exact envelope_eq_combination childrenD_497 (0, 3) envelope_497 + pivot_mem_497 child_envelope_sub_497 envelope_origin_497 +def checked_497 : CheckedCard where + required := required_497 + envelope := envelope_497 + height := height_497 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_497 +def height_501 : ℕ := 5 +def childrenH_501 : Fin 2 → ℕ := ![height_2, height_500] +theorem height_exact_501 : height_501 = 1 + Finset.univ.sup childrenH_501 := by decide +kernel +theorem required_origin_501 : ∀ x ∈ required_501, + (∃ j, x ∈ childrenC_501 j) ∨ ∀ j, x ∈ childrenD_501 j := by decide +kernel +theorem required_exact_501 : required_501 = + ((Finset.univ.biUnion childrenC_501) ∪ commonEnvelope childrenD_501).erase (1, 3) := by + exact required_eq_combination childrenC_501 childrenD_501 (1, 3) required_501 + (by decide +kernel) child_required_sub_501 common_sub_501 required_origin_501 +theorem envelope_origin_501 : ∀ x ∈ envelope_501, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_501 j := by decide +kernel +theorem envelope_exact_501 : envelope_501 = + insert (1, 3) (Finset.univ.biUnion childrenD_501) := by + exact envelope_eq_combination childrenD_501 (1, 3) envelope_501 + pivot_mem_501 child_envelope_sub_501 envelope_origin_501 +def checked_501 : CheckedCard where + required := required_501 + envelope := envelope_501 + height := height_501 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_501 +def height_502_i0 : ℕ := 4 +def childrenH_502_i0 : Fin 2 → ℕ := ![height_11, height_53] +theorem height_exact_502_i0 : height_502_i0 = 1 + Finset.univ.sup childrenH_502_i0 := by decide +kernel +theorem required_origin_502_i0 : ∀ x ∈ required_502_i0, + (∃ j, x ∈ childrenC_502_i0 j) ∨ ∀ j, x ∈ childrenD_502_i0 j := by decide +kernel +theorem required_exact_502_i0 : required_502_i0 = + ((Finset.univ.biUnion childrenC_502_i0) ∪ commonEnvelope childrenD_502_i0).erase (2, 4) := by + exact required_eq_combination childrenC_502_i0 childrenD_502_i0 (2, 4) required_502_i0 + (by decide +kernel) child_required_sub_502_i0 common_sub_502_i0 required_origin_502_i0 +theorem envelope_origin_502_i0 : ∀ x ∈ envelope_502_i0, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_502_i0 j := by decide +kernel +theorem envelope_exact_502_i0 : envelope_502_i0 = + insert (2, 4) (Finset.univ.biUnion childrenD_502_i0) := by + exact envelope_eq_combination childrenD_502_i0 (2, 4) envelope_502_i0 + pivot_mem_502_i0 child_envelope_sub_502_i0 envelope_origin_502_i0 +def checked_502_i0 : CheckedCard where + required := required_502_i0 + envelope := envelope_502_i0 + height := height_502_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_502_i0 +def height_502 : ℕ := 5 +def childrenH_502 : Fin 3 → ℕ := ![height_7, height_69, height_502_i0] +theorem height_exact_502 : height_502 = 1 + Finset.univ.sup childrenH_502 := by decide +kernel +theorem required_origin_502 : ∀ x ∈ required_502, + (∃ j, x ∈ childrenC_502 j) ∨ ∀ j, x ∈ childrenD_502 j := by decide +kernel +theorem required_exact_502 : required_502 = + ((Finset.univ.biUnion childrenC_502) ∪ commonEnvelope childrenD_502).erase (4, 3) := by + exact required_eq_combination childrenC_502 childrenD_502 (4, 3) required_502 + (by decide +kernel) child_required_sub_502 common_sub_502 required_origin_502 +theorem envelope_origin_502 : ∀ x ∈ envelope_502, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_502 j := by decide +kernel +theorem envelope_exact_502 : envelope_502 = + insert (4, 3) (Finset.univ.biUnion childrenD_502) := by + exact envelope_eq_combination childrenD_502 (4, 3) envelope_502 + pivot_mem_502 child_envelope_sub_502 envelope_origin_502 +def checked_502 : CheckedCard where + required := required_502 + envelope := envelope_502 + height := height_502 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_502 +def height_505_i0 : ℕ := 4 +def childrenH_505_i0 : Fin 2 → ℕ := ![height_5, height_350] +theorem height_exact_505_i0 : height_505_i0 = 1 + Finset.univ.sup childrenH_505_i0 := by decide +kernel +theorem required_origin_505_i0 : ∀ x ∈ required_505_i0, + (∃ j, x ∈ childrenC_505_i0 j) ∨ ∀ j, x ∈ childrenD_505_i0 j := by decide +kernel +theorem required_exact_505_i0 : required_505_i0 = + ((Finset.univ.biUnion childrenC_505_i0) ∪ commonEnvelope childrenD_505_i0).erase (4, 2) := by + exact required_eq_combination childrenC_505_i0 childrenD_505_i0 (4, 2) required_505_i0 + (by decide +kernel) child_required_sub_505_i0 common_sub_505_i0 required_origin_505_i0 +theorem envelope_origin_505_i0 : ∀ x ∈ envelope_505_i0, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_505_i0 j := by decide +kernel +theorem envelope_exact_505_i0 : envelope_505_i0 = + insert (4, 2) (Finset.univ.biUnion childrenD_505_i0) := by + exact envelope_eq_combination childrenD_505_i0 (4, 2) envelope_505_i0 + pivot_mem_505_i0 child_envelope_sub_505_i0 envelope_origin_505_i0 +def checked_505_i0 : CheckedCard where + required := required_505_i0 + envelope := envelope_505_i0 + height := height_505_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_505_i0 +def height_505_i2 : ℕ := 3 +def childrenH_505_i2 : Fin 2 → ℕ := ![height_5, height_6] +theorem height_exact_505_i2 : height_505_i2 = 1 + Finset.univ.sup childrenH_505_i2 := by decide +kernel +theorem required_origin_505_i2 : ∀ x ∈ required_505_i2, + (∃ j, x ∈ childrenC_505_i2 j) ∨ ∀ j, x ∈ childrenD_505_i2 j := by decide +kernel +theorem required_exact_505_i2 : required_505_i2 = + ((Finset.univ.biUnion childrenC_505_i2) ∪ commonEnvelope childrenD_505_i2).erase (4, 3) := by + exact required_eq_combination childrenC_505_i2 childrenD_505_i2 (4, 3) required_505_i2 + (by decide +kernel) child_required_sub_505_i2 common_sub_505_i2 required_origin_505_i2 +theorem envelope_origin_505_i2 : ∀ x ∈ envelope_505_i2, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_505_i2 j := by decide +kernel +theorem envelope_exact_505_i2 : envelope_505_i2 = + insert (4, 3) (Finset.univ.biUnion childrenD_505_i2) := by + exact envelope_eq_combination childrenD_505_i2 (4, 3) envelope_505_i2 + pivot_mem_505_i2 child_envelope_sub_505_i2 envelope_origin_505_i2 +def checked_505_i2 : CheckedCard where + required := required_505_i2 + envelope := envelope_505_i2 + height := height_505_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_505_i2 +def height_505_i1 : ℕ := 4 +def childrenH_505_i1 : Fin 2 → ℕ := ![height_5, height_505_i2] +theorem height_exact_505_i1 : height_505_i1 = 1 + Finset.univ.sup childrenH_505_i1 := by decide +kernel +theorem required_origin_505_i1 : ∀ x ∈ required_505_i1, + (∃ j, x ∈ childrenC_505_i1 j) ∨ ∀ j, x ∈ childrenD_505_i1 j := by decide +kernel +theorem required_exact_505_i1 : required_505_i1 = + ((Finset.univ.biUnion childrenC_505_i1) ∪ commonEnvelope childrenD_505_i1).erase (4, 2) := by + exact required_eq_combination childrenC_505_i1 childrenD_505_i1 (4, 2) required_505_i1 + (by decide +kernel) child_required_sub_505_i1 common_sub_505_i1 required_origin_505_i1 +theorem envelope_origin_505_i1 : ∀ x ∈ envelope_505_i1, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_505_i1 j := by decide +kernel +theorem envelope_exact_505_i1 : envelope_505_i1 = + insert (4, 2) (Finset.univ.biUnion childrenD_505_i1) := by + exact envelope_eq_combination childrenD_505_i1 (4, 2) envelope_505_i1 + pivot_mem_505_i1 child_envelope_sub_505_i1 envelope_origin_505_i1 +def checked_505_i1 : CheckedCard where + required := required_505_i1 + envelope := envelope_505_i1 + height := height_505_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_505_i1 +def height_505 : ℕ := 5 +def childrenH_505 : Fin 3 → ℕ := ![height_6, height_505_i0, height_505_i1] +theorem height_exact_505 : height_505 = 1 + Finset.univ.sup childrenH_505 := by decide +kernel +theorem required_origin_505 : ∀ x ∈ required_505, + (∃ j, x ∈ childrenC_505 j) ∨ ∀ j, x ∈ childrenD_505 j := by decide +kernel +theorem required_exact_505 : required_505 = + ((Finset.univ.biUnion childrenC_505) ∪ commonEnvelope childrenD_505).erase (4, 1) := by + exact required_eq_combination childrenC_505 childrenD_505 (4, 1) required_505 + (by decide +kernel) child_required_sub_505 common_sub_505 required_origin_505 +theorem envelope_origin_505 : ∀ x ∈ envelope_505, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_505 j := by decide +kernel +theorem envelope_exact_505 : envelope_505 = + insert (4, 1) (Finset.univ.biUnion childrenD_505) := by + exact envelope_eq_combination childrenD_505 (4, 1) envelope_505 + pivot_mem_505 child_envelope_sub_505 envelope_origin_505 +def checked_505 : CheckedCard where + required := required_505 + envelope := envelope_505 + height := height_505 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_505 +def height_506_i0 : ℕ := 4 +def childrenH_506_i0 : Fin 2 → ℕ := ![height_7, height_32] +theorem height_exact_506_i0 : height_506_i0 = 1 + Finset.univ.sup childrenH_506_i0 := by decide +kernel +theorem required_origin_506_i0 : ∀ x ∈ required_506_i0, + (∃ j, x ∈ childrenC_506_i0 j) ∨ ∀ j, x ∈ childrenD_506_i0 j := by decide +kernel +theorem required_exact_506_i0 : required_506_i0 = + ((Finset.univ.biUnion childrenC_506_i0) ∪ commonEnvelope childrenD_506_i0).erase (1, 2) := by + exact required_eq_combination childrenC_506_i0 childrenD_506_i0 (1, 2) required_506_i0 + (by decide +kernel) child_required_sub_506_i0 common_sub_506_i0 required_origin_506_i0 +theorem envelope_origin_506_i0 : ∀ x ∈ envelope_506_i0, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_506_i0 j := by decide +kernel +theorem envelope_exact_506_i0 : envelope_506_i0 = + insert (1, 2) (Finset.univ.biUnion childrenD_506_i0) := by + exact envelope_eq_combination childrenD_506_i0 (1, 2) envelope_506_i0 + pivot_mem_506_i0 child_envelope_sub_506_i0 envelope_origin_506_i0 +def checked_506_i0 : CheckedCard where + required := required_506_i0 + envelope := envelope_506_i0 + height := height_506_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_506_i0 +def height_506 : ℕ := 5 +def childrenH_506 : Fin 3 → ℕ := ![height_44, height_67, height_506_i0] +theorem height_exact_506 : height_506 = 1 + Finset.univ.sup childrenH_506 := by decide +kernel +theorem required_origin_506 : ∀ x ∈ required_506, + (∃ j, x ∈ childrenC_506 j) ∨ ∀ j, x ∈ childrenD_506 j := by decide +kernel +theorem required_exact_506 : required_506 = + ((Finset.univ.biUnion childrenC_506) ∪ commonEnvelope childrenD_506).erase (1, 5) := by + exact required_eq_combination childrenC_506 childrenD_506 (1, 5) required_506 + (by decide +kernel) child_required_sub_506 common_sub_506 required_origin_506 +theorem envelope_origin_506 : ∀ x ∈ envelope_506, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_506 j := by decide +kernel +theorem envelope_exact_506 : envelope_506 = + insert (1, 5) (Finset.univ.biUnion childrenD_506) := by + exact envelope_eq_combination childrenD_506 (1, 5) envelope_506 + pivot_mem_506 child_envelope_sub_506 envelope_origin_506 +def checked_506 : CheckedCard where + required := required_506 + envelope := envelope_506 + height := height_506 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_506 +def height_515_i0 : ℕ := 4 +def childrenH_515_i0 : Fin 2 → ℕ := ![height_0, height_78] +theorem height_exact_515_i0 : height_515_i0 = 1 + Finset.univ.sup childrenH_515_i0 := by decide +kernel +theorem required_origin_515_i0 : ∀ x ∈ required_515_i0, + (∃ j, x ∈ childrenC_515_i0 j) ∨ ∀ j, x ∈ childrenD_515_i0 j := by decide +kernel +theorem required_exact_515_i0 : required_515_i0 = + ((Finset.univ.biUnion childrenC_515_i0) ∪ commonEnvelope childrenD_515_i0).erase (3, 1) := by + exact required_eq_combination childrenC_515_i0 childrenD_515_i0 (3, 1) required_515_i0 + (by decide +kernel) child_required_sub_515_i0 common_sub_515_i0 required_origin_515_i0 +theorem envelope_origin_515_i0 : ∀ x ∈ envelope_515_i0, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_515_i0 j := by decide +kernel +theorem envelope_exact_515_i0 : envelope_515_i0 = + insert (3, 1) (Finset.univ.biUnion childrenD_515_i0) := by + exact envelope_eq_combination childrenD_515_i0 (3, 1) envelope_515_i0 + pivot_mem_515_i0 child_envelope_sub_515_i0 envelope_origin_515_i0 +def checked_515_i0 : CheckedCard where + required := required_515_i0 + envelope := envelope_515_i0 + height := height_515_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_515_i0 +def height_515 : ℕ := 5 +def childrenH_515 : Fin 2 → ℕ := ![height_2, height_515_i0] +theorem height_exact_515 : height_515 = 1 + Finset.univ.sup childrenH_515 := by decide +kernel +theorem required_origin_515 : ∀ x ∈ required_515, + (∃ j, x ∈ childrenC_515 j) ∨ ∀ j, x ∈ childrenD_515 j := by decide +kernel +theorem required_exact_515 : required_515 = + ((Finset.univ.biUnion childrenC_515) ∪ commonEnvelope childrenD_515).erase (2, 1) := by + exact required_eq_combination childrenC_515 childrenD_515 (2, 1) required_515 + (by decide +kernel) child_required_sub_515 common_sub_515 required_origin_515 +theorem envelope_origin_515 : ∀ x ∈ envelope_515, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_515 j := by decide +kernel +theorem envelope_exact_515 : envelope_515 = + insert (2, 1) (Finset.univ.biUnion childrenD_515) := by + exact envelope_eq_combination childrenD_515 (2, 1) envelope_515 + pivot_mem_515 child_envelope_sub_515 envelope_origin_515 +def checked_515 : CheckedCard where + required := required_515 + envelope := envelope_515 + height := height_515 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_515 +def height_592_i0 : ℕ := 4 +def childrenH_592_i0 : Fin 2 → ℕ := ![height_1, height_158] +theorem height_exact_592_i0 : height_592_i0 = 1 + Finset.univ.sup childrenH_592_i0 := by decide +kernel +theorem required_origin_592_i0 : ∀ x ∈ required_592_i0, + (∃ j, x ∈ childrenC_592_i0 j) ∨ ∀ j, x ∈ childrenD_592_i0 j := by decide +kernel +theorem required_exact_592_i0 : required_592_i0 = + ((Finset.univ.biUnion childrenC_592_i0) ∪ commonEnvelope childrenD_592_i0).erase (1, 5) := by + exact required_eq_combination childrenC_592_i0 childrenD_592_i0 (1, 5) required_592_i0 + (by decide +kernel) child_required_sub_592_i0 common_sub_592_i0 required_origin_592_i0 +theorem envelope_origin_592_i0 : ∀ x ∈ envelope_592_i0, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_592_i0 j := by decide +kernel +theorem envelope_exact_592_i0 : envelope_592_i0 = + insert (1, 5) (Finset.univ.biUnion childrenD_592_i0) := by + exact envelope_eq_combination childrenD_592_i0 (1, 5) envelope_592_i0 + pivot_mem_592_i0 child_envelope_sub_592_i0 envelope_origin_592_i0 +def checked_592_i0 : CheckedCard where + required := required_592_i0 + envelope := envelope_592_i0 + height := height_592_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_592_i0 +def height_592 : ℕ := 5 +def childrenH_592 : Fin 4 → ℕ := ![height_22, height_36, height_150, height_592_i0] +theorem height_exact_592 : height_592 = 1 + Finset.univ.sup childrenH_592 := by decide +kernel +theorem required_origin_592 : ∀ x ∈ required_592, + (∃ j, x ∈ childrenC_592 j) ∨ ∀ j, x ∈ childrenD_592 j := by decide +kernel +theorem required_exact_592 : required_592 = + ((Finset.univ.biUnion childrenC_592) ∪ commonEnvelope childrenD_592).erase (1, 4) := by + exact required_eq_combination childrenC_592 childrenD_592 (1, 4) required_592 + (by decide +kernel) child_required_sub_592 common_sub_592 required_origin_592 +theorem envelope_origin_592 : ∀ x ∈ envelope_592, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_592 j := by decide +kernel +theorem envelope_exact_592 : envelope_592 = + insert (1, 4) (Finset.univ.biUnion childrenD_592) := by + exact envelope_eq_combination childrenD_592 (1, 4) envelope_592 + pivot_mem_592 child_envelope_sub_592 envelope_origin_592 +def checked_592 : CheckedCard where + required := required_592 + envelope := envelope_592 + height := height_592 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_592 +def height_612_i1 : ℕ := 3 +def childrenH_612_i1 : Fin 2 → ℕ := ![height_6, height_6] +theorem height_exact_612_i1 : height_612_i1 = 1 + Finset.univ.sup childrenH_612_i1 := by decide +kernel +theorem required_origin_612_i1 : ∀ x ∈ required_612_i1, + (∃ j, x ∈ childrenC_612_i1 j) ∨ ∀ j, x ∈ childrenD_612_i1 j := by decide +kernel +theorem required_exact_612_i1 : required_612_i1 = + ((Finset.univ.biUnion childrenC_612_i1) ∪ commonEnvelope childrenD_612_i1).erase (1, 2) := by + exact required_eq_combination childrenC_612_i1 childrenD_612_i1 (1, 2) required_612_i1 + (by decide +kernel) child_required_sub_612_i1 common_sub_612_i1 required_origin_612_i1 +theorem envelope_origin_612_i1 : ∀ x ∈ envelope_612_i1, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_612_i1 j := by decide +kernel +theorem envelope_exact_612_i1 : envelope_612_i1 = + insert (1, 2) (Finset.univ.biUnion childrenD_612_i1) := by + exact envelope_eq_combination childrenD_612_i1 (1, 2) envelope_612_i1 + pivot_mem_612_i1 child_envelope_sub_612_i1 envelope_origin_612_i1 +def checked_612_i1 : CheckedCard where + required := required_612_i1 + envelope := envelope_612_i1 + height := height_612_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_612_i1 +def height_612_i2 : ℕ := 2 +def childrenH_612_i2 : Fin 2 → ℕ := ![height_0, height_3] +theorem height_exact_612_i2 : height_612_i2 = 1 + Finset.univ.sup childrenH_612_i2 := by decide +kernel +theorem required_origin_612_i2 : ∀ x ∈ required_612_i2, + (∃ j, x ∈ childrenC_612_i2 j) ∨ ∀ j, x ∈ childrenD_612_i2 j := by decide +kernel +theorem required_exact_612_i2 : required_612_i2 = + ((Finset.univ.biUnion childrenC_612_i2) ∪ commonEnvelope childrenD_612_i2).erase (0, 2) := by + exact required_eq_combination childrenC_612_i2 childrenD_612_i2 (0, 2) required_612_i2 + (by decide +kernel) child_required_sub_612_i2 common_sub_612_i2 required_origin_612_i2 +theorem envelope_origin_612_i2 : ∀ x ∈ envelope_612_i2, + x = (0, 2) ∨ ∃ j, x ∈ childrenD_612_i2 j := by decide +kernel +theorem envelope_exact_612_i2 : envelope_612_i2 = + insert (0, 2) (Finset.univ.biUnion childrenD_612_i2) := by + exact envelope_eq_combination childrenD_612_i2 (0, 2) envelope_612_i2 + pivot_mem_612_i2 child_envelope_sub_612_i2 envelope_origin_612_i2 +def checked_612_i2 : CheckedCard where + required := required_612_i2 + envelope := envelope_612_i2 + height := height_612_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_612_i2 +def height_612_i3 : ℕ := 3 +def childrenH_612_i3 : Fin 2 → ℕ := ![height_4, height_6] +theorem height_exact_612_i3 : height_612_i3 = 1 + Finset.univ.sup childrenH_612_i3 := by decide +kernel +theorem required_origin_612_i3 : ∀ x ∈ required_612_i3, + (∃ j, x ∈ childrenC_612_i3 j) ∨ ∀ j, x ∈ childrenD_612_i3 j := by decide +kernel +theorem required_exact_612_i3 : required_612_i3 = + ((Finset.univ.biUnion childrenC_612_i3) ∪ commonEnvelope childrenD_612_i3).erase (1, 2) := by + exact required_eq_combination childrenC_612_i3 childrenD_612_i3 (1, 2) required_612_i3 + (by decide +kernel) child_required_sub_612_i3 common_sub_612_i3 required_origin_612_i3 +theorem envelope_origin_612_i3 : ∀ x ∈ envelope_612_i3, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_612_i3 j := by decide +kernel +theorem envelope_exact_612_i3 : envelope_612_i3 = + insert (1, 2) (Finset.univ.biUnion childrenD_612_i3) := by + exact envelope_eq_combination childrenD_612_i3 (1, 2) envelope_612_i3 + pivot_mem_612_i3 child_envelope_sub_612_i3 envelope_origin_612_i3 +def checked_612_i3 : CheckedCard where + required := required_612_i3 + envelope := envelope_612_i3 + height := height_612_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_612_i3 +def height_612_i0 : ℕ := 4 +def childrenH_612_i0 : Fin 3 → ℕ := ![height_612_i1, height_612_i2, height_612_i3] +theorem height_exact_612_i0 : height_612_i0 = 1 + Finset.univ.sup childrenH_612_i0 := by decide +kernel +theorem required_origin_612_i0 : ∀ x ∈ required_612_i0, + (∃ j, x ∈ childrenC_612_i0 j) ∨ ∀ j, x ∈ childrenD_612_i0 j := by decide +kernel +theorem required_exact_612_i0 : required_612_i0 = + ((Finset.univ.biUnion childrenC_612_i0) ∪ commonEnvelope childrenD_612_i0).erase (1, 5) := by + exact required_eq_combination childrenC_612_i0 childrenD_612_i0 (1, 5) required_612_i0 + (by decide +kernel) child_required_sub_612_i0 common_sub_612_i0 required_origin_612_i0 +theorem envelope_origin_612_i0 : ∀ x ∈ envelope_612_i0, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_612_i0 j := by decide +kernel +theorem envelope_exact_612_i0 : envelope_612_i0 = + insert (1, 5) (Finset.univ.biUnion childrenD_612_i0) := by + exact envelope_eq_combination childrenD_612_i0 (1, 5) envelope_612_i0 + pivot_mem_612_i0 child_envelope_sub_612_i0 envelope_origin_612_i0 +def checked_612_i0 : CheckedCard where + required := required_612_i0 + envelope := envelope_612_i0 + height := height_612_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_612_i0 +def height_612 : ℕ := 5 +def childrenH_612 : Fin 4 → ℕ := ![height_36, height_50, height_54, height_612_i0] +theorem height_exact_612 : height_612 = 1 + Finset.univ.sup childrenH_612 := by decide +kernel +theorem required_origin_612 : ∀ x ∈ required_612, + (∃ j, x ∈ childrenC_612 j) ∨ ∀ j, x ∈ childrenD_612 j := by decide +kernel +theorem required_exact_612 : required_612 = + ((Finset.univ.biUnion childrenC_612) ∪ commonEnvelope childrenD_612).erase (1, 4) := by + exact required_eq_combination childrenC_612 childrenD_612 (1, 4) required_612 + (by decide +kernel) child_required_sub_612 common_sub_612 required_origin_612 +theorem envelope_origin_612 : ∀ x ∈ envelope_612, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_612 j := by decide +kernel +theorem envelope_exact_612 : envelope_612 = + insert (1, 4) (Finset.univ.biUnion childrenD_612) := by + exact envelope_eq_combination childrenD_612 (1, 4) envelope_612 + pivot_mem_612 child_envelope_sub_612 envelope_origin_612 +def checked_612 : CheckedCard where + required := required_612 + envelope := envelope_612 + height := height_612 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_612 +def height_672_i0 : ℕ := 3 +def childrenH_672_i0 : Fin 2 → ℕ := ![height_22, height_22] +theorem height_exact_672_i0 : height_672_i0 = 1 + Finset.univ.sup childrenH_672_i0 := by decide +kernel +theorem required_origin_672_i0 : ∀ x ∈ required_672_i0, + (∃ j, x ∈ childrenC_672_i0 j) ∨ ∀ j, x ∈ childrenD_672_i0 j := by decide +kernel +theorem required_exact_672_i0 : required_672_i0 = + ((Finset.univ.biUnion childrenC_672_i0) ∪ commonEnvelope childrenD_672_i0).erase (2, 1) := by + exact required_eq_combination childrenC_672_i0 childrenD_672_i0 (2, 1) required_672_i0 + (by decide +kernel) child_required_sub_672_i0 common_sub_672_i0 required_origin_672_i0 +theorem envelope_origin_672_i0 : ∀ x ∈ envelope_672_i0, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_672_i0 j := by decide +kernel +theorem envelope_exact_672_i0 : envelope_672_i0 = + insert (2, 1) (Finset.univ.biUnion childrenD_672_i0) := by + exact envelope_eq_combination childrenD_672_i0 (2, 1) envelope_672_i0 + pivot_mem_672_i0 child_envelope_sub_672_i0 envelope_origin_672_i0 +def checked_672_i0 : CheckedCard where + required := required_672_i0 + envelope := envelope_672_i0 + height := height_672_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_672_i0 +def height_672 : ℕ := 5 +def childrenH_672 : Fin 3 → ℕ := ![height_34, height_305, height_672_i0] +theorem height_exact_672 : height_672 = 1 + Finset.univ.sup childrenH_672 := by decide +kernel +theorem required_origin_672 : ∀ x ∈ required_672, + (∃ j, x ∈ childrenC_672 j) ∨ ∀ j, x ∈ childrenD_672 j := by decide +kernel +theorem required_exact_672 : required_672 = + ((Finset.univ.biUnion childrenC_672) ∪ commonEnvelope childrenD_672).erase (2, 2) := by + exact required_eq_combination childrenC_672 childrenD_672 (2, 2) required_672 + (by decide +kernel) child_required_sub_672 common_sub_672 required_origin_672 +theorem envelope_origin_672 : ∀ x ∈ envelope_672, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_672 j := by decide +kernel +theorem envelope_exact_672 : envelope_672 = + insert (2, 2) (Finset.univ.biUnion childrenD_672) := by + exact envelope_eq_combination childrenD_672 (2, 2) envelope_672 + pivot_mem_672 child_envelope_sub_672 envelope_origin_672 +def checked_672 : CheckedCard where + required := required_672 + envelope := envelope_672 + height := height_672 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_672 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part07.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part07.lean new file mode 100644 index 0000000..c01d3c1 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part07.lean @@ -0,0 +1,95 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_679_i0 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 3), (3, 1), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_679_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 3), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_679_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_0), (placed21 5 (5, 1) required_222)] +def childrenD_679_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_0), (placed21 5 (5, 1) envelope_222)] +theorem common_sub_679_i0 : commonEnvelope childrenD_679_i0 ⊆ insert (3, 3) required_679_i0 := by decide +kernel +theorem child_required_sub_679_i0 : ∀ j, childrenC_679_i0 j ⊆ insert (3, 3) required_679_i0 := by decide +kernel +theorem child_envelope_sub_679_i0 : ∀ j, childrenD_679_i0 j ⊆ envelope_679_i0 := by decide +kernel +theorem pivot_mem_679_i0 : (3, 3) ∈ envelope_679_i0 := by decide +kernel +theorem children_work_679_i0 : ∀ j, Template HasSnaky 3 (childrenC_679_i0 j) (childrenD_679_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 4 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_222 5 (5, 1)).mono (by decide +kernel) +theorem row_works_679_i0 : Template HasSnaky 4 required_679_i0 envelope_679_i0 := by + refine compose HasSnaky 3 childrenC_679_i0 childrenD_679_i0 children_work_679_i0 (3, 3) + required_679_i0 envelope_679_i0 pivot_mem_679_i0 child_required_sub_679_i0 child_envelope_sub_679_i0 ?_ + intro b hb + exact common_sub_679_i0 (mem_commonEnvelope childrenD_679_i0 b hb) +def required_679 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (3, 1), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_679 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_679 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) required_52), required_679_i0] +def childrenD_679 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) envelope_52), envelope_679_i0] +theorem common_sub_679 : commonEnvelope childrenD_679 ⊆ insert (2, 3) required_679 := by decide +kernel +theorem child_required_sub_679 : ∀ j, childrenC_679 j ⊆ insert (2, 3) required_679 := by decide +kernel +theorem child_envelope_sub_679 : ∀ j, childrenD_679 j ⊆ envelope_679 := by decide +kernel +theorem pivot_mem_679 : (2, 3) ∈ envelope_679 := by decide +kernel +theorem children_work_679 : ∀ j, Template HasSnaky 4 (childrenC_679 j) (childrenD_679 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 0 (1, 0)).mono (by decide +kernel) + · exact row_works_679_i0.mono (by decide +kernel) +theorem row_works_679 : Template HasSnaky 5 required_679 envelope_679 := by + refine compose HasSnaky 4 childrenC_679 childrenD_679 children_work_679 (2, 3) + required_679 envelope_679 pivot_mem_679 child_required_sub_679 child_envelope_sub_679 ?_ + intro b hb + exact common_sub_679 (mem_commonEnvelope childrenD_679 b hb) +def height_679_i0 : ℕ := 4 +def childrenH_679_i0 : Fin 2 → ℕ := ![height_0, height_222] +theorem height_exact_679_i0 : height_679_i0 = 1 + Finset.univ.sup childrenH_679_i0 := by decide +kernel +theorem required_origin_679_i0 : ∀ x ∈ required_679_i0, + (∃ j, x ∈ childrenC_679_i0 j) ∨ ∀ j, x ∈ childrenD_679_i0 j := by decide +kernel +theorem required_exact_679_i0 : required_679_i0 = + ((Finset.univ.biUnion childrenC_679_i0) ∪ commonEnvelope childrenD_679_i0).erase (3, 3) := by + exact required_eq_combination childrenC_679_i0 childrenD_679_i0 (3, 3) required_679_i0 + (by decide +kernel) child_required_sub_679_i0 common_sub_679_i0 required_origin_679_i0 +theorem envelope_origin_679_i0 : ∀ x ∈ envelope_679_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_679_i0 j := by decide +kernel +theorem envelope_exact_679_i0 : envelope_679_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_679_i0) := by + exact envelope_eq_combination childrenD_679_i0 (3, 3) envelope_679_i0 + pivot_mem_679_i0 child_envelope_sub_679_i0 envelope_origin_679_i0 +def checked_679_i0 : CheckedCard where + required := required_679_i0 + envelope := envelope_679_i0 + height := height_679_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_679_i0 +def height_679 : ℕ := 5 +def childrenH_679 : Fin 2 → ℕ := ![height_52, height_679_i0] +theorem height_exact_679 : height_679 = 1 + Finset.univ.sup childrenH_679 := by decide +kernel +theorem required_origin_679 : ∀ x ∈ required_679, + (∃ j, x ∈ childrenC_679 j) ∨ ∀ j, x ∈ childrenD_679 j := by decide +kernel +theorem required_exact_679 : required_679 = + ((Finset.univ.biUnion childrenC_679) ∪ commonEnvelope childrenD_679).erase (2, 3) := by + exact required_eq_combination childrenC_679 childrenD_679 (2, 3) required_679 + (by decide +kernel) child_required_sub_679 common_sub_679 required_origin_679 +theorem envelope_origin_679 : ∀ x ∈ envelope_679, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_679 j := by decide +kernel +theorem envelope_exact_679 : envelope_679 = + insert (2, 3) (Finset.univ.biUnion childrenD_679) := by + exact envelope_eq_combination childrenD_679 (2, 3) envelope_679 + pivot_mem_679 child_envelope_sub_679 envelope_origin_679 +def checked_679 : CheckedCard where + required := required_679 + envelope := envelope_679 + height := height_679 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_679 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part01.lean new file mode 100644 index 0000000..fa75c81 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part01.lean @@ -0,0 +1,986 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_85 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_85 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 5), (3, 6), (3, 7), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_85 : Fin 3 → Finset Cell := ![(placed21 6 (2, 6) required_15), (placed21 4 (1, 7) required_65), (placed21 3 (0, 5) required_72)] +def childrenD_85 : Fin 3 → Finset Cell := ![(placed21 6 (2, 6) envelope_15), (placed21 4 (1, 7) envelope_65), (placed21 3 (0, 5) envelope_72)] +theorem common_sub_85 : commonEnvelope childrenD_85 ⊆ insert (2, 5) required_85 := by decide +kernel +theorem child_required_sub_85 : ∀ j, childrenC_85 j ⊆ insert (2, 5) required_85 := by decide +kernel +theorem child_envelope_sub_85 : ∀ j, childrenD_85 j ⊆ envelope_85 := by decide +kernel +theorem pivot_mem_85 : (2, 5) ∈ envelope_85 := by decide +kernel +theorem children_work_85 : ∀ j, Template HasSnaky 5 (childrenC_85 j) (childrenD_85 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_65 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_72 3 (0, 5)).mono (by decide +kernel) +theorem row_works_85 : Template HasSnaky 6 required_85 envelope_85 := by + refine compose HasSnaky 5 childrenC_85 childrenD_85 children_work_85 (2, 5) + required_85 envelope_85 pivot_mem_85 child_required_sub_85 child_envelope_sub_85 ?_ + intro b hb + exact common_sub_85 (mem_commonEnvelope childrenD_85 b hb) +def required_95 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_95 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 7), (2, 8), (2, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_95 : Fin 4 → Finset Cell := ![(placed21 0 (0, 2) required_19), (placed21 4 (0, 7) required_19), (placed21 1 (0, 3) required_49), (placed21 3 (0, 6) required_49)] +def childrenD_95 : Fin 4 → Finset Cell := ![(placed21 0 (0, 2) envelope_19), (placed21 4 (0, 7) envelope_19), (placed21 1 (0, 3) envelope_49), (placed21 3 (0, 6) envelope_49)] +theorem common_sub_95 : commonEnvelope childrenD_95 ⊆ insert (1, 5) required_95 := by decide +kernel +theorem child_required_sub_95 : ∀ j, childrenC_95 j ⊆ insert (1, 5) required_95 := by decide +kernel +theorem child_envelope_sub_95 : ∀ j, childrenD_95 j ⊆ envelope_95 := by decide +kernel +theorem pivot_mem_95 : (1, 5) ∈ envelope_95 := by decide +kernel +theorem children_work_95 : ∀ j, Template HasSnaky 5 (childrenC_95 j) (childrenD_95 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_19 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_49 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_49 3 (0, 6)).mono (by decide +kernel) +theorem row_works_95 : Template HasSnaky 6 required_95 envelope_95 := by + refine compose HasSnaky 5 childrenC_95 childrenD_95 children_work_95 (1, 5) + required_95 envelope_95 pivot_mem_95 child_required_sub_95 child_envelope_sub_95 ?_ + intro b hb + exact common_sub_95 (mem_commonEnvelope childrenD_95 b hb) +def required_110 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_110 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_110 : Fin 4 → Finset Cell := ![(placed21 2 (4, 0) required_12), (placed21 5 (4, 2) required_28), (placed21 0 (0, 1) required_58), (placed21 0 (0, 1) required_100)] +def childrenD_110 : Fin 4 → Finset Cell := ![(placed21 2 (4, 0) envelope_12), (placed21 5 (4, 2) envelope_28), (placed21 0 (0, 1) envelope_58), (placed21 0 (0, 1) envelope_100)] +theorem common_sub_110 : commonEnvelope childrenD_110 ⊆ insert (3, 4) required_110 := by decide +kernel +theorem child_required_sub_110 : ∀ j, childrenC_110 j ⊆ insert (3, 4) required_110 := by decide +kernel +theorem child_envelope_sub_110 : ∀ j, childrenD_110 j ⊆ envelope_110 := by decide +kernel +theorem pivot_mem_110 : (3, 4) ∈ envelope_110 := by decide +kernel +theorem children_work_110 : ∀ j, Template HasSnaky 5 (childrenC_110 j) (childrenD_110 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_28 5 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_58 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_100 0 (0, 1)).mono (by decide +kernel) +theorem row_works_110 : Template HasSnaky 6 required_110 envelope_110 := by + refine compose HasSnaky 5 childrenC_110 childrenD_110 children_work_110 (3, 4) + required_110 envelope_110 pivot_mem_110 child_required_sub_110 child_envelope_sub_110 ?_ + intro b hb + exact common_sub_110 (mem_commonEnvelope childrenD_110 b hb) +def required_115 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_115 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_115 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_5), required_114] +def childrenD_115 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_5), envelope_114] +theorem common_sub_115 : commonEnvelope childrenD_115 ⊆ insert (3, 2) required_115 := by decide +kernel +theorem child_required_sub_115 : ∀ j, childrenC_115 j ⊆ insert (3, 2) required_115 := by decide +kernel +theorem child_envelope_sub_115 : ∀ j, childrenD_115 j ⊆ envelope_115 := by decide +kernel +theorem pivot_mem_115 : (3, 2) ∈ envelope_115 := by decide +kernel +theorem children_work_115 : ∀ j, Template HasSnaky 5 (childrenC_115 j) (childrenD_115 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact row_works_114.mono (by decide +kernel) +theorem row_works_115 : Template HasSnaky 6 required_115 envelope_115 := by + refine compose HasSnaky 5 childrenC_115 childrenD_115 children_work_115 (3, 2) + required_115 envelope_115 pivot_mem_115 child_required_sub_115 child_envelope_sub_115 ?_ + intro b hb + exact common_sub_115 (mem_commonEnvelope childrenD_115 b hb) +def required_119 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_119 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_119 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_5), required_114] +def childrenD_119 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_5), envelope_114] +theorem common_sub_119 : commonEnvelope childrenD_119 ⊆ insert (2, 3) required_119 := by decide +kernel +theorem child_required_sub_119 : ∀ j, childrenC_119 j ⊆ insert (2, 3) required_119 := by decide +kernel +theorem child_envelope_sub_119 : ∀ j, childrenD_119 j ⊆ envelope_119 := by decide +kernel +theorem pivot_mem_119 : (2, 3) ∈ envelope_119 := by decide +kernel +theorem children_work_119 : ∀ j, Template HasSnaky 5 (childrenC_119 j) (childrenD_119 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact row_works_114.mono (by decide +kernel) +theorem row_works_119 : Template HasSnaky 6 required_119 envelope_119 := by + refine compose HasSnaky 5 childrenC_119 childrenD_119 children_work_119 (2, 3) + required_119 envelope_119 pivot_mem_119 child_required_sub_119 child_envelope_sub_119 ?_ + intro b hb + exact common_sub_119 (mem_commonEnvelope childrenD_119 b hb) +def required_134 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_134 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2), (5, 3), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_134 : Fin 3 → Finset Cell := ![(placed21 1 (1, 2) required_16), (placed21 4 (1, 3) required_24), (placed21 2 (5, 0) required_133)] +def childrenD_134 : Fin 3 → Finset Cell := ![(placed21 1 (1, 2) envelope_16), (placed21 4 (1, 3) envelope_24), (placed21 2 (5, 0) envelope_133)] +theorem common_sub_134 : commonEnvelope childrenD_134 ⊆ insert (4, 2) required_134 := by decide +kernel +theorem child_required_sub_134 : ∀ j, childrenC_134 j ⊆ insert (4, 2) required_134 := by decide +kernel +theorem child_envelope_sub_134 : ∀ j, childrenD_134 j ⊆ envelope_134 := by decide +kernel +theorem pivot_mem_134 : (4, 2) ∈ envelope_134 := by decide +kernel +theorem children_work_134 : ∀ j, Template HasSnaky 5 (childrenC_134 j) (childrenD_134 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_16 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_24 4 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_133 2 (5, 0)).mono (by decide +kernel) +theorem row_works_134 : Template HasSnaky 6 required_134 envelope_134 := by + refine compose HasSnaky 5 childrenC_134 childrenD_134 children_work_134 (4, 2) + required_134 envelope_134 pivot_mem_134 child_required_sub_134 child_envelope_sub_134 ?_ + intro b hb + exact common_sub_134 (mem_commonEnvelope childrenD_134 b hb) +def required_135 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_135 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_135 : Fin 3 → Finset Cell := ![(placed21 0 (2, 1) required_7), (placed21 6 (3, 6) required_9), (placed21 1 (0, 1) required_133)] +def childrenD_135 : Fin 3 → Finset Cell := ![(placed21 0 (2, 1) envelope_7), (placed21 6 (3, 6) envelope_9), (placed21 1 (0, 1) envelope_133)] +theorem common_sub_135 : commonEnvelope childrenD_135 ⊆ insert (2, 5) required_135 := by decide +kernel +theorem child_required_sub_135 : ∀ j, childrenC_135 j ⊆ insert (2, 5) required_135 := by decide +kernel +theorem child_envelope_sub_135 : ∀ j, childrenD_135 j ⊆ envelope_135 := by decide +kernel +theorem pivot_mem_135 : (2, 5) ∈ envelope_135 := by decide +kernel +theorem children_work_135 : ∀ j, Template HasSnaky 5 (childrenC_135 j) (childrenD_135 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 6 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_133 1 (0, 1)).mono (by decide +kernel) +theorem row_works_135 : Template HasSnaky 6 required_135 envelope_135 := by + refine compose HasSnaky 5 childrenC_135 childrenD_135 children_work_135 (2, 5) + required_135 envelope_135 pivot_mem_135 child_required_sub_135 child_envelope_sub_135 ?_ + intro b hb + exact common_sub_135 (mem_commonEnvelope childrenD_135 b hb) +def required_136 : Finset Cell := ⟨(([(1, 2), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_136 : Finset Cell := ⟨(([(0, 4), (1, 1), (1, 2), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_136 : Fin 3 → Finset Cell := ![(placed21 2 (2, 1) required_21), (placed21 0 (1, 1) required_37), (placed21 3 (0, 5) required_133)] +def childrenD_136 : Fin 3 → Finset Cell := ![(placed21 2 (2, 1) envelope_21), (placed21 0 (1, 1) envelope_37), (placed21 3 (0, 5) envelope_133)] +theorem common_sub_136 : commonEnvelope childrenD_136 ⊆ insert (2, 4) required_136 := by decide +kernel +theorem child_required_sub_136 : ∀ j, childrenC_136 j ⊆ insert (2, 4) required_136 := by decide +kernel +theorem child_envelope_sub_136 : ∀ j, childrenD_136 j ⊆ envelope_136 := by decide +kernel +theorem pivot_mem_136 : (2, 4) ∈ envelope_136 := by decide +kernel +theorem children_work_136 : ∀ j, Template HasSnaky 5 (childrenC_136 j) (childrenD_136 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 2 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_37 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_133 3 (0, 5)).mono (by decide +kernel) +theorem row_works_136 : Template HasSnaky 6 required_136 envelope_136 := by + refine compose HasSnaky 5 childrenC_136 childrenD_136 children_work_136 (2, 4) + required_136 envelope_136 pivot_mem_136 child_required_sub_136 child_envelope_sub_136 ?_ + intro b hb + exact common_sub_136 (mem_commonEnvelope childrenD_136 b hb) +def required_137 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_137 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2), (5, 3), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_137 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) required_7), (placed21 3 (0, 3) required_9), (placed21 2 (5, 0) required_133)] +def childrenD_137 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) envelope_7), (placed21 3 (0, 3) envelope_9), (placed21 2 (5, 0) envelope_133)] +theorem common_sub_137 : commonEnvelope childrenD_137 ⊆ insert (4, 2) required_137 := by decide +kernel +theorem child_required_sub_137 : ∀ j, childrenC_137 j ⊆ insert (4, 2) required_137 := by decide +kernel +theorem child_envelope_sub_137 : ∀ j, childrenD_137 j ⊆ envelope_137 := by decide +kernel +theorem pivot_mem_137 : (4, 2) ∈ envelope_137 := by decide +kernel +theorem children_work_137 : ∀ j, Template HasSnaky 5 (childrenC_137 j) (childrenD_137 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_133 2 (5, 0)).mono (by decide +kernel) +theorem row_works_137 : Template HasSnaky 6 required_137 envelope_137 := by + refine compose HasSnaky 5 childrenC_137 childrenD_137 children_work_137 (4, 2) + required_137 envelope_137 pivot_mem_137 child_required_sub_137 child_envelope_sub_137 ?_ + intro b hb + exact common_sub_137 (mem_commonEnvelope childrenD_137 b hb) +def required_161 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_161 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (4, 3), (4, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_161 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) required_6), required_142] +def childrenD_161 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) envelope_6), envelope_142] +theorem common_sub_161 : commonEnvelope childrenD_161 ⊆ insert (4, 3) required_161 := by decide +kernel +theorem child_required_sub_161 : ∀ j, childrenC_161 j ⊆ insert (4, 3) required_161 := by decide +kernel +theorem child_envelope_sub_161 : ∀ j, childrenD_161 j ⊆ envelope_161 := by decide +kernel +theorem pivot_mem_161 : (4, 3) ∈ envelope_161 := by decide +kernel +theorem children_work_161 : ∀ j, Template HasSnaky 5 (childrenC_161 j) (childrenD_161 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 1 (0, 3)).mono (by decide +kernel) + · exact row_works_142.mono (by decide +kernel) +theorem row_works_161 : Template HasSnaky 6 required_161 envelope_161 := by + refine compose HasSnaky 5 childrenC_161 childrenD_161 children_work_161 (4, 3) + required_161 envelope_161 pivot_mem_161 child_required_sub_161 child_envelope_sub_161 ?_ + intro b hb + exact common_sub_161 (mem_commonEnvelope childrenD_161 b hb) +def required_162 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_162 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_162 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) required_6), required_142] +def childrenD_162 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) envelope_6), envelope_142] +theorem common_sub_162 : commonEnvelope childrenD_162 ⊆ insert (4, 3) required_162 := by decide +kernel +theorem child_required_sub_162 : ∀ j, childrenC_162 j ⊆ insert (4, 3) required_162 := by decide +kernel +theorem child_envelope_sub_162 : ∀ j, childrenD_162 j ⊆ envelope_162 := by decide +kernel +theorem pivot_mem_162 : (4, 3) ∈ envelope_162 := by decide +kernel +theorem children_work_162 : ∀ j, Template HasSnaky 5 (childrenC_162 j) (childrenD_162 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 3)).mono (by decide +kernel) + · exact row_works_142.mono (by decide +kernel) +theorem row_works_162 : Template HasSnaky 6 required_162 envelope_162 := by + refine compose HasSnaky 5 childrenC_162 childrenD_162 children_work_162 (4, 3) + required_162 envelope_162 pivot_mem_162 child_required_sub_162 child_envelope_sub_162 ?_ + intro b hb + exact common_sub_162 (mem_commonEnvelope childrenD_162 b hb) +def required_166 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_166 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_166 : Fin 4 → Finset Cell := ![(placed21 2 (4, 0) required_14), (placed21 5 (4, 2) required_28), (placed21 0 (0, 1) required_58), (placed21 0 (0, 1) required_100)] +def childrenD_166 : Fin 4 → Finset Cell := ![(placed21 2 (4, 0) envelope_14), (placed21 5 (4, 2) envelope_28), (placed21 0 (0, 1) envelope_58), (placed21 0 (0, 1) envelope_100)] +theorem common_sub_166 : commonEnvelope childrenD_166 ⊆ insert (3, 3) required_166 := by decide +kernel +theorem child_required_sub_166 : ∀ j, childrenC_166 j ⊆ insert (3, 3) required_166 := by decide +kernel +theorem child_envelope_sub_166 : ∀ j, childrenD_166 j ⊆ envelope_166 := by decide +kernel +theorem pivot_mem_166 : (3, 3) ∈ envelope_166 := by decide +kernel +theorem children_work_166 : ∀ j, Template HasSnaky 5 (childrenC_166 j) (childrenD_166 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_28 5 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_58 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_100 0 (0, 1)).mono (by decide +kernel) +theorem row_works_166 : Template HasSnaky 6 required_166 envelope_166 := by + refine compose HasSnaky 5 childrenC_166 childrenD_166 children_work_166 (3, 3) + required_166 envelope_166 pivot_mem_166 child_required_sub_166 child_envelope_sub_166 ?_ + intro b hb + exact common_sub_166 (mem_commonEnvelope childrenD_166 b hb) +def required_167 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 1), (3, 1), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_167 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_167 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), (placed21 3 (0, 5) required_152)] +def childrenD_167 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), (placed21 3 (0, 5) envelope_152)] +theorem common_sub_167 : commonEnvelope childrenD_167 ⊆ insert (3, 2) required_167 := by decide +kernel +theorem child_required_sub_167 : ∀ j, childrenC_167 j ⊆ insert (3, 2) required_167 := by decide +kernel +theorem child_envelope_sub_167 : ∀ j, childrenD_167 j ⊆ envelope_167 := by decide +kernel +theorem pivot_mem_167 : (3, 2) ∈ envelope_167 := by decide +kernel +theorem children_work_167 : ∀ j, Template HasSnaky 5 (childrenC_167 j) (childrenD_167 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_152 3 (0, 5)).mono (by decide +kernel) +theorem row_works_167 : Template HasSnaky 6 required_167 envelope_167 := by + refine compose HasSnaky 5 childrenC_167 childrenD_167 children_work_167 (3, 2) + required_167 envelope_167 pivot_mem_167 child_required_sub_167 child_envelope_sub_167 ?_ + intro b hb + exact common_sub_167 (mem_commonEnvelope childrenD_167 b hb) +def required_172 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_172 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_172 : Fin 2 → Finset Cell := ![required_142, (placed21 6 (5, 6) required_142)] +def childrenD_172 : Fin 2 → Finset Cell := ![envelope_142, (placed21 6 (5, 6) envelope_142)] +theorem common_sub_172 : commonEnvelope childrenD_172 ⊆ insert (4, 3) required_172 := by decide +kernel +theorem child_required_sub_172 : ∀ j, childrenC_172 j ⊆ insert (4, 3) required_172 := by decide +kernel +theorem child_envelope_sub_172 : ∀ j, childrenD_172 j ⊆ envelope_172 := by decide +kernel +theorem pivot_mem_172 : (4, 3) ∈ envelope_172 := by decide +kernel +theorem children_work_172 : ∀ j, Template HasSnaky 5 (childrenC_172 j) (childrenD_172 j) := by + intro j + fin_cases j + · exact row_works_142.mono (by decide +kernel) + · exact (placed21_template row_works_142 6 (5, 6)).mono (by decide +kernel) +theorem row_works_172 : Template HasSnaky 6 required_172 envelope_172 := by + refine compose HasSnaky 5 childrenC_172 childrenD_172 children_work_172 (4, 3) + required_172 envelope_172 pivot_mem_172 child_required_sub_172 child_envelope_sub_172 ?_ + intro b hb + exact common_sub_172 (mem_commonEnvelope childrenD_172 b hb) +def required_173 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_173 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_173 : Fin 2 → Finset Cell := ![required_142, (placed21 2 (5, 0) required_142)] +def childrenD_173 : Fin 2 → Finset Cell := ![envelope_142, (placed21 2 (5, 0) envelope_142)] +theorem common_sub_173 : commonEnvelope childrenD_173 ⊆ insert (4, 3) required_173 := by decide +kernel +theorem child_required_sub_173 : ∀ j, childrenC_173 j ⊆ insert (4, 3) required_173 := by decide +kernel +theorem child_envelope_sub_173 : ∀ j, childrenD_173 j ⊆ envelope_173 := by decide +kernel +theorem pivot_mem_173 : (4, 3) ∈ envelope_173 := by decide +kernel +theorem children_work_173 : ∀ j, Template HasSnaky 5 (childrenC_173 j) (childrenD_173 j) := by + intro j + fin_cases j + · exact row_works_142.mono (by decide +kernel) + · exact (placed21_template row_works_142 2 (5, 0)).mono (by decide +kernel) +theorem row_works_173 : Template HasSnaky 6 required_173 envelope_173 := by + refine compose HasSnaky 5 childrenC_173 childrenD_173 children_work_173 (4, 3) + required_173 envelope_173 pivot_mem_173 child_required_sub_173 child_envelope_sub_173 ?_ + intro b hb + exact common_sub_173 (mem_commonEnvelope childrenD_173 b hb) +def required_180 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_180 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_180 : Fin 3 → Finset Cell := ![(placed21 1 (1, 2) required_16), (placed21 4 (1, 3) required_24), (placed21 2 (5, 0) required_179)] +def childrenD_180 : Fin 3 → Finset Cell := ![(placed21 1 (1, 2) envelope_16), (placed21 4 (1, 3) envelope_24), (placed21 2 (5, 0) envelope_179)] +theorem common_sub_180 : commonEnvelope childrenD_180 ⊆ insert (4, 2) required_180 := by decide +kernel +theorem child_required_sub_180 : ∀ j, childrenC_180 j ⊆ insert (4, 2) required_180 := by decide +kernel +theorem child_envelope_sub_180 : ∀ j, childrenD_180 j ⊆ envelope_180 := by decide +kernel +theorem pivot_mem_180 : (4, 2) ∈ envelope_180 := by decide +kernel +theorem children_work_180 : ∀ j, Template HasSnaky 5 (childrenC_180 j) (childrenD_180 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_16 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_24 4 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_179 2 (5, 0)).mono (by decide +kernel) +theorem row_works_180 : Template HasSnaky 6 required_180 envelope_180 := by + refine compose HasSnaky 5 childrenC_180 childrenD_180 children_work_180 (4, 2) + required_180 envelope_180 pivot_mem_180 child_required_sub_180 child_envelope_sub_180 ?_ + intro b hb + exact common_sub_180 (mem_commonEnvelope childrenD_180 b hb) +def required_181 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_181 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_181 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) required_7), (placed21 3 (0, 3) required_9), (placed21 2 (5, 0) required_179)] +def childrenD_181 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) envelope_7), (placed21 3 (0, 3) envelope_9), (placed21 2 (5, 0) envelope_179)] +theorem common_sub_181 : commonEnvelope childrenD_181 ⊆ insert (4, 2) required_181 := by decide +kernel +theorem child_required_sub_181 : ∀ j, childrenC_181 j ⊆ insert (4, 2) required_181 := by decide +kernel +theorem child_envelope_sub_181 : ∀ j, childrenD_181 j ⊆ envelope_181 := by decide +kernel +theorem pivot_mem_181 : (4, 2) ∈ envelope_181 := by decide +kernel +theorem children_work_181 : ∀ j, Template HasSnaky 5 (childrenC_181 j) (childrenD_181 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_179 2 (5, 0)).mono (by decide +kernel) +theorem row_works_181 : Template HasSnaky 6 required_181 envelope_181 := by + refine compose HasSnaky 5 childrenC_181 childrenD_181 children_work_181 (4, 2) + required_181 envelope_181 pivot_mem_181 child_required_sub_181 child_envelope_sub_181 ?_ + intro b hb + exact common_sub_181 (mem_commonEnvelope childrenD_181 b hb) +def required_182 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_182 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_182 : Fin 3 → Finset Cell := ![(placed21 4 (2, 6) required_7), (placed21 0 (1, 1) required_9), (placed21 1 (0, 1) required_179)] +def childrenD_182 : Fin 3 → Finset Cell := ![(placed21 4 (2, 6) envelope_7), (placed21 0 (1, 1) envelope_9), (placed21 1 (0, 1) envelope_179)] +theorem common_sub_182 : commonEnvelope childrenD_182 ⊆ insert (2, 5) required_182 := by decide +kernel +theorem child_required_sub_182 : ∀ j, childrenC_182 j ⊆ insert (2, 5) required_182 := by decide +kernel +theorem child_envelope_sub_182 : ∀ j, childrenD_182 j ⊆ envelope_182 := by decide +kernel +theorem pivot_mem_182 : (2, 5) ∈ envelope_182 := by decide +kernel +theorem children_work_182 : ∀ j, Template HasSnaky 5 (childrenC_182 j) (childrenD_182 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_9 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_179 1 (0, 1)).mono (by decide +kernel) +theorem row_works_182 : Template HasSnaky 6 required_182 envelope_182 := by + refine compose HasSnaky 5 childrenC_182 childrenD_182 children_work_182 (2, 5) + required_182 envelope_182 pivot_mem_182 child_required_sub_182 child_envelope_sub_182 ?_ + intro b hb + exact common_sub_182 (mem_commonEnvelope childrenD_182 b hb) +def required_184 : Finset Cell := ⟨(([(1, 1), (1, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_184 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_184 : Fin 2 → Finset Cell := ![(placed21 2 (4, 0) required_99), (placed21 6 (5, 5) required_179)] +def childrenD_184 : Fin 2 → Finset Cell := ![(placed21 2 (4, 0) envelope_99), (placed21 6 (5, 5) envelope_179)] +theorem common_sub_184 : commonEnvelope childrenD_184 ⊆ insert (2, 3) required_184 := by decide +kernel +theorem child_required_sub_184 : ∀ j, childrenC_184 j ⊆ insert (2, 3) required_184 := by decide +kernel +theorem child_envelope_sub_184 : ∀ j, childrenD_184 j ⊆ envelope_184 := by decide +kernel +theorem pivot_mem_184 : (2, 3) ∈ envelope_184 := by decide +kernel +theorem children_work_184 : ∀ j, Template HasSnaky 5 (childrenC_184 j) (childrenD_184 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_99 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_179 6 (5, 5)).mono (by decide +kernel) +theorem row_works_184 : Template HasSnaky 6 required_184 envelope_184 := by + refine compose HasSnaky 5 childrenC_184 childrenD_184 children_work_184 (2, 3) + required_184 envelope_184 pivot_mem_184 child_required_sub_184 child_envelope_sub_184 ?_ + intro b hb + exact common_sub_184 (mem_commonEnvelope childrenD_184 b hb) +def required_188 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_188 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_188 : Fin 5 → Finset Cell := ![(placed21 1 (1, 2) required_8), (placed21 5 (3, 2) required_26), (placed21 3 (0, 6) required_133), (placed21 4 (1, 7) required_186), (placed21 0 (2, 0) required_187)] +def childrenD_188 : Fin 5 → Finset Cell := ![(placed21 1 (1, 2) envelope_8), (placed21 5 (3, 2) envelope_26), (placed21 3 (0, 6) envelope_133), (placed21 4 (1, 7) envelope_186), (placed21 0 (2, 0) envelope_187)] +theorem common_sub_188 : commonEnvelope childrenD_188 ⊆ insert (2, 5) required_188 := by decide +kernel +theorem child_required_sub_188 : ∀ j, childrenC_188 j ⊆ insert (2, 5) required_188 := by decide +kernel +theorem child_envelope_sub_188 : ∀ j, childrenD_188 j ⊆ envelope_188 := by decide +kernel +theorem pivot_mem_188 : (2, 5) ∈ envelope_188 := by decide +kernel +theorem children_work_188 : ∀ j, Template HasSnaky 5 (childrenC_188 j) (childrenD_188 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_26 5 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_133 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_186 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_187 0 (2, 0)).mono (by decide +kernel) +theorem row_works_188 : Template HasSnaky 6 required_188 envelope_188 := by + refine compose HasSnaky 5 childrenC_188 childrenD_188 children_work_188 (2, 5) + required_188 envelope_188 pivot_mem_188 child_required_sub_188 child_envelope_sub_188 ?_ + intro b hb + exact common_sub_188 (mem_commonEnvelope childrenD_188 b hb) +def required_189 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_189 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_189 : Fin 5 → Finset Cell := ![(placed21 1 (0, 2) required_8), (placed21 1 (0, 2) required_26), (placed21 4 (0, 6) required_62), (placed21 6 (2, 7) required_186), (placed21 2 (1, 0) required_187)] +def childrenD_189 : Fin 5 → Finset Cell := ![(placed21 1 (0, 2) envelope_8), (placed21 1 (0, 2) envelope_26), (placed21 4 (0, 6) envelope_62), (placed21 6 (2, 7) envelope_186), (placed21 2 (1, 0) envelope_187)] +theorem common_sub_189 : commonEnvelope childrenD_189 ⊆ insert (1, 5) required_189 := by decide +kernel +theorem child_required_sub_189 : ∀ j, childrenC_189 j ⊆ insert (1, 5) required_189 := by decide +kernel +theorem child_envelope_sub_189 : ∀ j, childrenD_189 j ⊆ envelope_189 := by decide +kernel +theorem pivot_mem_189 : (1, 5) ∈ envelope_189 := by decide +kernel +theorem children_work_189 : ∀ j, Template HasSnaky 5 (childrenC_189 j) (childrenD_189 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_26 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_62 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_186 6 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_187 2 (1, 0)).mono (by decide +kernel) +theorem row_works_189 : Template HasSnaky 6 required_189 envelope_189 := by + refine compose HasSnaky 5 childrenC_189 childrenD_189 children_work_189 (1, 5) + required_189 envelope_189 pivot_mem_189 child_required_sub_189 child_envelope_sub_189 ?_ + intro b hb + exact common_sub_189 (mem_commonEnvelope childrenD_189 b hb) +def required_190 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_190 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_190 : Fin 5 → Finset Cell := ![(placed21 1 (1, 2) required_8), (placed21 1 (1, 2) required_26), (placed21 3 (0, 6) required_179), (placed21 6 (3, 7) required_186), (placed21 2 (2, 0) required_187)] +def childrenD_190 : Fin 5 → Finset Cell := ![(placed21 1 (1, 2) envelope_8), (placed21 1 (1, 2) envelope_26), (placed21 3 (0, 6) envelope_179), (placed21 6 (3, 7) envelope_186), (placed21 2 (2, 0) envelope_187)] +theorem common_sub_190 : commonEnvelope childrenD_190 ⊆ insert (2, 5) required_190 := by decide +kernel +theorem child_required_sub_190 : ∀ j, childrenC_190 j ⊆ insert (2, 5) required_190 := by decide +kernel +theorem child_envelope_sub_190 : ∀ j, childrenD_190 j ⊆ envelope_190 := by decide +kernel +theorem pivot_mem_190 : (2, 5) ∈ envelope_190 := by decide +kernel +theorem children_work_190 : ∀ j, Template HasSnaky 5 (childrenC_190 j) (childrenD_190 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_26 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_179 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_186 6 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_187 2 (2, 0)).mono (by decide +kernel) +theorem row_works_190 : Template HasSnaky 6 required_190 envelope_190 := by + refine compose HasSnaky 5 childrenC_190 childrenD_190 children_work_190 (2, 5) + required_190 envelope_190 pivot_mem_190 child_required_sub_190 child_envelope_sub_190 ?_ + intro b hb + exact common_sub_190 (mem_commonEnvelope childrenD_190 b hb) +def required_192 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_192 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_192 : Fin 5 → Finset Cell := ![(placed21 0 (0, 1) required_9), (placed21 6 (2, 6) required_9), required_186, (placed21 0 (1, 0) required_187), (placed21 0 (0, 1) required_191)] +def childrenD_192 : Fin 5 → Finset Cell := ![(placed21 0 (0, 1) envelope_9), (placed21 6 (2, 6) envelope_9), envelope_186, (placed21 0 (1, 0) envelope_187), (placed21 0 (0, 1) envelope_191)] +theorem common_sub_192 : commonEnvelope childrenD_192 ⊆ insert (1, 5) required_192 := by decide +kernel +theorem child_required_sub_192 : ∀ j, childrenC_192 j ⊆ insert (1, 5) required_192 := by decide +kernel +theorem child_envelope_sub_192 : ∀ j, childrenD_192 j ⊆ envelope_192 := by decide +kernel +theorem pivot_mem_192 : (1, 5) ∈ envelope_192 := by decide +kernel +theorem children_work_192 : ∀ j, Template HasSnaky 5 (childrenC_192 j) (childrenD_192 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 6 (2, 6)).mono (by decide +kernel) + · exact row_works_186.mono (by decide +kernel) + · exact (placed21_template row_works_187 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_191 0 (0, 1)).mono (by decide +kernel) +theorem row_works_192 : Template HasSnaky 6 required_192 envelope_192 := by + refine compose HasSnaky 5 childrenC_192 childrenD_192 children_work_192 (1, 5) + required_192 envelope_192 pivot_mem_192 child_required_sub_192 child_envelope_sub_192 ?_ + intro b hb + exact common_sub_192 (mem_commonEnvelope childrenD_192 b hb) +def height_85 : ℕ := 6 +def childrenH_85 : Fin 3 → ℕ := ![height_15, height_65, height_72] +theorem height_exact_85 : height_85 = 1 + Finset.univ.sup childrenH_85 := by decide +kernel +theorem required_origin_85 : ∀ x ∈ required_85, + (∃ j, x ∈ childrenC_85 j) ∨ ∀ j, x ∈ childrenD_85 j := by decide +kernel +theorem required_exact_85 : required_85 = + ((Finset.univ.biUnion childrenC_85) ∪ commonEnvelope childrenD_85).erase (2, 5) := by + exact required_eq_combination childrenC_85 childrenD_85 (2, 5) required_85 + (by decide +kernel) child_required_sub_85 common_sub_85 required_origin_85 +theorem envelope_origin_85 : ∀ x ∈ envelope_85, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_85 j := by decide +kernel +theorem envelope_exact_85 : envelope_85 = + insert (2, 5) (Finset.univ.biUnion childrenD_85) := by + exact envelope_eq_combination childrenD_85 (2, 5) envelope_85 + pivot_mem_85 child_envelope_sub_85 envelope_origin_85 +def checked_85 : CheckedCard where + required := required_85 + envelope := envelope_85 + height := height_85 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_85 +def height_95 : ℕ := 6 +def childrenH_95 : Fin 4 → ℕ := ![height_19, height_19, height_49, height_49] +theorem height_exact_95 : height_95 = 1 + Finset.univ.sup childrenH_95 := by decide +kernel +theorem required_origin_95 : ∀ x ∈ required_95, + (∃ j, x ∈ childrenC_95 j) ∨ ∀ j, x ∈ childrenD_95 j := by decide +kernel +theorem required_exact_95 : required_95 = + ((Finset.univ.biUnion childrenC_95) ∪ commonEnvelope childrenD_95).erase (1, 5) := by + exact required_eq_combination childrenC_95 childrenD_95 (1, 5) required_95 + (by decide +kernel) child_required_sub_95 common_sub_95 required_origin_95 +theorem envelope_origin_95 : ∀ x ∈ envelope_95, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_95 j := by decide +kernel +theorem envelope_exact_95 : envelope_95 = + insert (1, 5) (Finset.univ.biUnion childrenD_95) := by + exact envelope_eq_combination childrenD_95 (1, 5) envelope_95 + pivot_mem_95 child_envelope_sub_95 envelope_origin_95 +def checked_95 : CheckedCard where + required := required_95 + envelope := envelope_95 + height := height_95 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_95 +def height_110 : ℕ := 6 +def childrenH_110 : Fin 4 → ℕ := ![height_12, height_28, height_58, height_100] +theorem height_exact_110 : height_110 = 1 + Finset.univ.sup childrenH_110 := by decide +kernel +theorem required_origin_110 : ∀ x ∈ required_110, + (∃ j, x ∈ childrenC_110 j) ∨ ∀ j, x ∈ childrenD_110 j := by decide +kernel +theorem required_exact_110 : required_110 = + ((Finset.univ.biUnion childrenC_110) ∪ commonEnvelope childrenD_110).erase (3, 4) := by + exact required_eq_combination childrenC_110 childrenD_110 (3, 4) required_110 + (by decide +kernel) child_required_sub_110 common_sub_110 required_origin_110 +theorem envelope_origin_110 : ∀ x ∈ envelope_110, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_110 j := by decide +kernel +theorem envelope_exact_110 : envelope_110 = + insert (3, 4) (Finset.univ.biUnion childrenD_110) := by + exact envelope_eq_combination childrenD_110 (3, 4) envelope_110 + pivot_mem_110 child_envelope_sub_110 envelope_origin_110 +def checked_110 : CheckedCard where + required := required_110 + envelope := envelope_110 + height := height_110 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_110 +def height_115 : ℕ := 6 +def childrenH_115 : Fin 2 → ℕ := ![height_5, height_114] +theorem height_exact_115 : height_115 = 1 + Finset.univ.sup childrenH_115 := by decide +kernel +theorem required_origin_115 : ∀ x ∈ required_115, + (∃ j, x ∈ childrenC_115 j) ∨ ∀ j, x ∈ childrenD_115 j := by decide +kernel +theorem required_exact_115 : required_115 = + ((Finset.univ.biUnion childrenC_115) ∪ commonEnvelope childrenD_115).erase (3, 2) := by + exact required_eq_combination childrenC_115 childrenD_115 (3, 2) required_115 + (by decide +kernel) child_required_sub_115 common_sub_115 required_origin_115 +theorem envelope_origin_115 : ∀ x ∈ envelope_115, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_115 j := by decide +kernel +theorem envelope_exact_115 : envelope_115 = + insert (3, 2) (Finset.univ.biUnion childrenD_115) := by + exact envelope_eq_combination childrenD_115 (3, 2) envelope_115 + pivot_mem_115 child_envelope_sub_115 envelope_origin_115 +def checked_115 : CheckedCard where + required := required_115 + envelope := envelope_115 + height := height_115 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_115 +def height_119 : ℕ := 6 +def childrenH_119 : Fin 2 → ℕ := ![height_5, height_114] +theorem height_exact_119 : height_119 = 1 + Finset.univ.sup childrenH_119 := by decide +kernel +theorem required_origin_119 : ∀ x ∈ required_119, + (∃ j, x ∈ childrenC_119 j) ∨ ∀ j, x ∈ childrenD_119 j := by decide +kernel +theorem required_exact_119 : required_119 = + ((Finset.univ.biUnion childrenC_119) ∪ commonEnvelope childrenD_119).erase (2, 3) := by + exact required_eq_combination childrenC_119 childrenD_119 (2, 3) required_119 + (by decide +kernel) child_required_sub_119 common_sub_119 required_origin_119 +theorem envelope_origin_119 : ∀ x ∈ envelope_119, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_119 j := by decide +kernel +theorem envelope_exact_119 : envelope_119 = + insert (2, 3) (Finset.univ.biUnion childrenD_119) := by + exact envelope_eq_combination childrenD_119 (2, 3) envelope_119 + pivot_mem_119 child_envelope_sub_119 envelope_origin_119 +def checked_119 : CheckedCard where + required := required_119 + envelope := envelope_119 + height := height_119 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_119 +def height_134 : ℕ := 6 +def childrenH_134 : Fin 3 → ℕ := ![height_16, height_24, height_133] +theorem height_exact_134 : height_134 = 1 + Finset.univ.sup childrenH_134 := by decide +kernel +theorem required_origin_134 : ∀ x ∈ required_134, + (∃ j, x ∈ childrenC_134 j) ∨ ∀ j, x ∈ childrenD_134 j := by decide +kernel +theorem required_exact_134 : required_134 = + ((Finset.univ.biUnion childrenC_134) ∪ commonEnvelope childrenD_134).erase (4, 2) := by + exact required_eq_combination childrenC_134 childrenD_134 (4, 2) required_134 + (by decide +kernel) child_required_sub_134 common_sub_134 required_origin_134 +theorem envelope_origin_134 : ∀ x ∈ envelope_134, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_134 j := by decide +kernel +theorem envelope_exact_134 : envelope_134 = + insert (4, 2) (Finset.univ.biUnion childrenD_134) := by + exact envelope_eq_combination childrenD_134 (4, 2) envelope_134 + pivot_mem_134 child_envelope_sub_134 envelope_origin_134 +def checked_134 : CheckedCard where + required := required_134 + envelope := envelope_134 + height := height_134 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_134 +def height_135 : ℕ := 6 +def childrenH_135 : Fin 3 → ℕ := ![height_7, height_9, height_133] +theorem height_exact_135 : height_135 = 1 + Finset.univ.sup childrenH_135 := by decide +kernel +theorem required_origin_135 : ∀ x ∈ required_135, + (∃ j, x ∈ childrenC_135 j) ∨ ∀ j, x ∈ childrenD_135 j := by decide +kernel +theorem required_exact_135 : required_135 = + ((Finset.univ.biUnion childrenC_135) ∪ commonEnvelope childrenD_135).erase (2, 5) := by + exact required_eq_combination childrenC_135 childrenD_135 (2, 5) required_135 + (by decide +kernel) child_required_sub_135 common_sub_135 required_origin_135 +theorem envelope_origin_135 : ∀ x ∈ envelope_135, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_135 j := by decide +kernel +theorem envelope_exact_135 : envelope_135 = + insert (2, 5) (Finset.univ.biUnion childrenD_135) := by + exact envelope_eq_combination childrenD_135 (2, 5) envelope_135 + pivot_mem_135 child_envelope_sub_135 envelope_origin_135 +def checked_135 : CheckedCard where + required := required_135 + envelope := envelope_135 + height := height_135 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_135 +def height_136 : ℕ := 6 +def childrenH_136 : Fin 3 → ℕ := ![height_21, height_37, height_133] +theorem height_exact_136 : height_136 = 1 + Finset.univ.sup childrenH_136 := by decide +kernel +theorem required_origin_136 : ∀ x ∈ required_136, + (∃ j, x ∈ childrenC_136 j) ∨ ∀ j, x ∈ childrenD_136 j := by decide +kernel +theorem required_exact_136 : required_136 = + ((Finset.univ.biUnion childrenC_136) ∪ commonEnvelope childrenD_136).erase (2, 4) := by + exact required_eq_combination childrenC_136 childrenD_136 (2, 4) required_136 + (by decide +kernel) child_required_sub_136 common_sub_136 required_origin_136 +theorem envelope_origin_136 : ∀ x ∈ envelope_136, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_136 j := by decide +kernel +theorem envelope_exact_136 : envelope_136 = + insert (2, 4) (Finset.univ.biUnion childrenD_136) := by + exact envelope_eq_combination childrenD_136 (2, 4) envelope_136 + pivot_mem_136 child_envelope_sub_136 envelope_origin_136 +def checked_136 : CheckedCard where + required := required_136 + envelope := envelope_136 + height := height_136 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_136 +def height_137 : ℕ := 6 +def childrenH_137 : Fin 3 → ℕ := ![height_7, height_9, height_133] +theorem height_exact_137 : height_137 = 1 + Finset.univ.sup childrenH_137 := by decide +kernel +theorem required_origin_137 : ∀ x ∈ required_137, + (∃ j, x ∈ childrenC_137 j) ∨ ∀ j, x ∈ childrenD_137 j := by decide +kernel +theorem required_exact_137 : required_137 = + ((Finset.univ.biUnion childrenC_137) ∪ commonEnvelope childrenD_137).erase (4, 2) := by + exact required_eq_combination childrenC_137 childrenD_137 (4, 2) required_137 + (by decide +kernel) child_required_sub_137 common_sub_137 required_origin_137 +theorem envelope_origin_137 : ∀ x ∈ envelope_137, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_137 j := by decide +kernel +theorem envelope_exact_137 : envelope_137 = + insert (4, 2) (Finset.univ.biUnion childrenD_137) := by + exact envelope_eq_combination childrenD_137 (4, 2) envelope_137 + pivot_mem_137 child_envelope_sub_137 envelope_origin_137 +def checked_137 : CheckedCard where + required := required_137 + envelope := envelope_137 + height := height_137 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_137 +def height_161 : ℕ := 6 +def childrenH_161 : Fin 2 → ℕ := ![height_6, height_142] +theorem height_exact_161 : height_161 = 1 + Finset.univ.sup childrenH_161 := by decide +kernel +theorem required_origin_161 : ∀ x ∈ required_161, + (∃ j, x ∈ childrenC_161 j) ∨ ∀ j, x ∈ childrenD_161 j := by decide +kernel +theorem required_exact_161 : required_161 = + ((Finset.univ.biUnion childrenC_161) ∪ commonEnvelope childrenD_161).erase (4, 3) := by + exact required_eq_combination childrenC_161 childrenD_161 (4, 3) required_161 + (by decide +kernel) child_required_sub_161 common_sub_161 required_origin_161 +theorem envelope_origin_161 : ∀ x ∈ envelope_161, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_161 j := by decide +kernel +theorem envelope_exact_161 : envelope_161 = + insert (4, 3) (Finset.univ.biUnion childrenD_161) := by + exact envelope_eq_combination childrenD_161 (4, 3) envelope_161 + pivot_mem_161 child_envelope_sub_161 envelope_origin_161 +def checked_161 : CheckedCard where + required := required_161 + envelope := envelope_161 + height := height_161 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_161 +def height_162 : ℕ := 6 +def childrenH_162 : Fin 2 → ℕ := ![height_6, height_142] +theorem height_exact_162 : height_162 = 1 + Finset.univ.sup childrenH_162 := by decide +kernel +theorem required_origin_162 : ∀ x ∈ required_162, + (∃ j, x ∈ childrenC_162 j) ∨ ∀ j, x ∈ childrenD_162 j := by decide +kernel +theorem required_exact_162 : required_162 = + ((Finset.univ.biUnion childrenC_162) ∪ commonEnvelope childrenD_162).erase (4, 3) := by + exact required_eq_combination childrenC_162 childrenD_162 (4, 3) required_162 + (by decide +kernel) child_required_sub_162 common_sub_162 required_origin_162 +theorem envelope_origin_162 : ∀ x ∈ envelope_162, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_162 j := by decide +kernel +theorem envelope_exact_162 : envelope_162 = + insert (4, 3) (Finset.univ.biUnion childrenD_162) := by + exact envelope_eq_combination childrenD_162 (4, 3) envelope_162 + pivot_mem_162 child_envelope_sub_162 envelope_origin_162 +def checked_162 : CheckedCard where + required := required_162 + envelope := envelope_162 + height := height_162 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_162 +def height_166 : ℕ := 6 +def childrenH_166 : Fin 4 → ℕ := ![height_14, height_28, height_58, height_100] +theorem height_exact_166 : height_166 = 1 + Finset.univ.sup childrenH_166 := by decide +kernel +theorem required_origin_166 : ∀ x ∈ required_166, + (∃ j, x ∈ childrenC_166 j) ∨ ∀ j, x ∈ childrenD_166 j := by decide +kernel +theorem required_exact_166 : required_166 = + ((Finset.univ.biUnion childrenC_166) ∪ commonEnvelope childrenD_166).erase (3, 3) := by + exact required_eq_combination childrenC_166 childrenD_166 (3, 3) required_166 + (by decide +kernel) child_required_sub_166 common_sub_166 required_origin_166 +theorem envelope_origin_166 : ∀ x ∈ envelope_166, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_166 j := by decide +kernel +theorem envelope_exact_166 : envelope_166 = + insert (3, 3) (Finset.univ.biUnion childrenD_166) := by + exact envelope_eq_combination childrenD_166 (3, 3) envelope_166 + pivot_mem_166 child_envelope_sub_166 envelope_origin_166 +def checked_166 : CheckedCard where + required := required_166 + envelope := envelope_166 + height := height_166 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_166 +def height_167 : ℕ := 6 +def childrenH_167 : Fin 2 → ℕ := ![height_5, height_152] +theorem height_exact_167 : height_167 = 1 + Finset.univ.sup childrenH_167 := by decide +kernel +theorem required_origin_167 : ∀ x ∈ required_167, + (∃ j, x ∈ childrenC_167 j) ∨ ∀ j, x ∈ childrenD_167 j := by decide +kernel +theorem required_exact_167 : required_167 = + ((Finset.univ.biUnion childrenC_167) ∪ commonEnvelope childrenD_167).erase (3, 2) := by + exact required_eq_combination childrenC_167 childrenD_167 (3, 2) required_167 + (by decide +kernel) child_required_sub_167 common_sub_167 required_origin_167 +theorem envelope_origin_167 : ∀ x ∈ envelope_167, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_167 j := by decide +kernel +theorem envelope_exact_167 : envelope_167 = + insert (3, 2) (Finset.univ.biUnion childrenD_167) := by + exact envelope_eq_combination childrenD_167 (3, 2) envelope_167 + pivot_mem_167 child_envelope_sub_167 envelope_origin_167 +def checked_167 : CheckedCard where + required := required_167 + envelope := envelope_167 + height := height_167 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_167 +def height_172 : ℕ := 6 +def childrenH_172 : Fin 2 → ℕ := ![height_142, height_142] +theorem height_exact_172 : height_172 = 1 + Finset.univ.sup childrenH_172 := by decide +kernel +theorem required_origin_172 : ∀ x ∈ required_172, + (∃ j, x ∈ childrenC_172 j) ∨ ∀ j, x ∈ childrenD_172 j := by decide +kernel +theorem required_exact_172 : required_172 = + ((Finset.univ.biUnion childrenC_172) ∪ commonEnvelope childrenD_172).erase (4, 3) := by + exact required_eq_combination childrenC_172 childrenD_172 (4, 3) required_172 + (by decide +kernel) child_required_sub_172 common_sub_172 required_origin_172 +theorem envelope_origin_172 : ∀ x ∈ envelope_172, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_172 j := by decide +kernel +theorem envelope_exact_172 : envelope_172 = + insert (4, 3) (Finset.univ.biUnion childrenD_172) := by + exact envelope_eq_combination childrenD_172 (4, 3) envelope_172 + pivot_mem_172 child_envelope_sub_172 envelope_origin_172 +def checked_172 : CheckedCard where + required := required_172 + envelope := envelope_172 + height := height_172 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_172 +def height_173 : ℕ := 6 +def childrenH_173 : Fin 2 → ℕ := ![height_142, height_142] +theorem height_exact_173 : height_173 = 1 + Finset.univ.sup childrenH_173 := by decide +kernel +theorem required_origin_173 : ∀ x ∈ required_173, + (∃ j, x ∈ childrenC_173 j) ∨ ∀ j, x ∈ childrenD_173 j := by decide +kernel +theorem required_exact_173 : required_173 = + ((Finset.univ.biUnion childrenC_173) ∪ commonEnvelope childrenD_173).erase (4, 3) := by + exact required_eq_combination childrenC_173 childrenD_173 (4, 3) required_173 + (by decide +kernel) child_required_sub_173 common_sub_173 required_origin_173 +theorem envelope_origin_173 : ∀ x ∈ envelope_173, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_173 j := by decide +kernel +theorem envelope_exact_173 : envelope_173 = + insert (4, 3) (Finset.univ.biUnion childrenD_173) := by + exact envelope_eq_combination childrenD_173 (4, 3) envelope_173 + pivot_mem_173 child_envelope_sub_173 envelope_origin_173 +def checked_173 : CheckedCard where + required := required_173 + envelope := envelope_173 + height := height_173 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_173 +def height_180 : ℕ := 6 +def childrenH_180 : Fin 3 → ℕ := ![height_16, height_24, height_179] +theorem height_exact_180 : height_180 = 1 + Finset.univ.sup childrenH_180 := by decide +kernel +theorem required_origin_180 : ∀ x ∈ required_180, + (∃ j, x ∈ childrenC_180 j) ∨ ∀ j, x ∈ childrenD_180 j := by decide +kernel +theorem required_exact_180 : required_180 = + ((Finset.univ.biUnion childrenC_180) ∪ commonEnvelope childrenD_180).erase (4, 2) := by + exact required_eq_combination childrenC_180 childrenD_180 (4, 2) required_180 + (by decide +kernel) child_required_sub_180 common_sub_180 required_origin_180 +theorem envelope_origin_180 : ∀ x ∈ envelope_180, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_180 j := by decide +kernel +theorem envelope_exact_180 : envelope_180 = + insert (4, 2) (Finset.univ.biUnion childrenD_180) := by + exact envelope_eq_combination childrenD_180 (4, 2) envelope_180 + pivot_mem_180 child_envelope_sub_180 envelope_origin_180 +def checked_180 : CheckedCard where + required := required_180 + envelope := envelope_180 + height := height_180 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_180 +def height_181 : ℕ := 6 +def childrenH_181 : Fin 3 → ℕ := ![height_7, height_9, height_179] +theorem height_exact_181 : height_181 = 1 + Finset.univ.sup childrenH_181 := by decide +kernel +theorem required_origin_181 : ∀ x ∈ required_181, + (∃ j, x ∈ childrenC_181 j) ∨ ∀ j, x ∈ childrenD_181 j := by decide +kernel +theorem required_exact_181 : required_181 = + ((Finset.univ.biUnion childrenC_181) ∪ commonEnvelope childrenD_181).erase (4, 2) := by + exact required_eq_combination childrenC_181 childrenD_181 (4, 2) required_181 + (by decide +kernel) child_required_sub_181 common_sub_181 required_origin_181 +theorem envelope_origin_181 : ∀ x ∈ envelope_181, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_181 j := by decide +kernel +theorem envelope_exact_181 : envelope_181 = + insert (4, 2) (Finset.univ.biUnion childrenD_181) := by + exact envelope_eq_combination childrenD_181 (4, 2) envelope_181 + pivot_mem_181 child_envelope_sub_181 envelope_origin_181 +def checked_181 : CheckedCard where + required := required_181 + envelope := envelope_181 + height := height_181 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_181 +def height_182 : ℕ := 6 +def childrenH_182 : Fin 3 → ℕ := ![height_7, height_9, height_179] +theorem height_exact_182 : height_182 = 1 + Finset.univ.sup childrenH_182 := by decide +kernel +theorem required_origin_182 : ∀ x ∈ required_182, + (∃ j, x ∈ childrenC_182 j) ∨ ∀ j, x ∈ childrenD_182 j := by decide +kernel +theorem required_exact_182 : required_182 = + ((Finset.univ.biUnion childrenC_182) ∪ commonEnvelope childrenD_182).erase (2, 5) := by + exact required_eq_combination childrenC_182 childrenD_182 (2, 5) required_182 + (by decide +kernel) child_required_sub_182 common_sub_182 required_origin_182 +theorem envelope_origin_182 : ∀ x ∈ envelope_182, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_182 j := by decide +kernel +theorem envelope_exact_182 : envelope_182 = + insert (2, 5) (Finset.univ.biUnion childrenD_182) := by + exact envelope_eq_combination childrenD_182 (2, 5) envelope_182 + pivot_mem_182 child_envelope_sub_182 envelope_origin_182 +def checked_182 : CheckedCard where + required := required_182 + envelope := envelope_182 + height := height_182 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_182 +def height_184 : ℕ := 6 +def childrenH_184 : Fin 2 → ℕ := ![height_99, height_179] +theorem height_exact_184 : height_184 = 1 + Finset.univ.sup childrenH_184 := by decide +kernel +theorem required_origin_184 : ∀ x ∈ required_184, + (∃ j, x ∈ childrenC_184 j) ∨ ∀ j, x ∈ childrenD_184 j := by decide +kernel +theorem required_exact_184 : required_184 = + ((Finset.univ.biUnion childrenC_184) ∪ commonEnvelope childrenD_184).erase (2, 3) := by + exact required_eq_combination childrenC_184 childrenD_184 (2, 3) required_184 + (by decide +kernel) child_required_sub_184 common_sub_184 required_origin_184 +theorem envelope_origin_184 : ∀ x ∈ envelope_184, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_184 j := by decide +kernel +theorem envelope_exact_184 : envelope_184 = + insert (2, 3) (Finset.univ.biUnion childrenD_184) := by + exact envelope_eq_combination childrenD_184 (2, 3) envelope_184 + pivot_mem_184 child_envelope_sub_184 envelope_origin_184 +def checked_184 : CheckedCard where + required := required_184 + envelope := envelope_184 + height := height_184 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_184 +def height_188 : ℕ := 6 +def childrenH_188 : Fin 5 → ℕ := ![height_8, height_26, height_133, height_186, height_187] +theorem height_exact_188 : height_188 = 1 + Finset.univ.sup childrenH_188 := by decide +kernel +theorem required_origin_188 : ∀ x ∈ required_188, + (∃ j, x ∈ childrenC_188 j) ∨ ∀ j, x ∈ childrenD_188 j := by decide +kernel +theorem required_exact_188 : required_188 = + ((Finset.univ.biUnion childrenC_188) ∪ commonEnvelope childrenD_188).erase (2, 5) := by + exact required_eq_combination childrenC_188 childrenD_188 (2, 5) required_188 + (by decide +kernel) child_required_sub_188 common_sub_188 required_origin_188 +theorem envelope_origin_188 : ∀ x ∈ envelope_188, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_188 j := by decide +kernel +theorem envelope_exact_188 : envelope_188 = + insert (2, 5) (Finset.univ.biUnion childrenD_188) := by + exact envelope_eq_combination childrenD_188 (2, 5) envelope_188 + pivot_mem_188 child_envelope_sub_188 envelope_origin_188 +def checked_188 : CheckedCard where + required := required_188 + envelope := envelope_188 + height := height_188 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_188 +def height_189 : ℕ := 6 +def childrenH_189 : Fin 5 → ℕ := ![height_8, height_26, height_62, height_186, height_187] +theorem height_exact_189 : height_189 = 1 + Finset.univ.sup childrenH_189 := by decide +kernel +theorem required_origin_189 : ∀ x ∈ required_189, + (∃ j, x ∈ childrenC_189 j) ∨ ∀ j, x ∈ childrenD_189 j := by decide +kernel +theorem required_exact_189 : required_189 = + ((Finset.univ.biUnion childrenC_189) ∪ commonEnvelope childrenD_189).erase (1, 5) := by + exact required_eq_combination childrenC_189 childrenD_189 (1, 5) required_189 + (by decide +kernel) child_required_sub_189 common_sub_189 required_origin_189 +theorem envelope_origin_189 : ∀ x ∈ envelope_189, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_189 j := by decide +kernel +theorem envelope_exact_189 : envelope_189 = + insert (1, 5) (Finset.univ.biUnion childrenD_189) := by + exact envelope_eq_combination childrenD_189 (1, 5) envelope_189 + pivot_mem_189 child_envelope_sub_189 envelope_origin_189 +def checked_189 : CheckedCard where + required := required_189 + envelope := envelope_189 + height := height_189 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_189 +def height_190 : ℕ := 6 +def childrenH_190 : Fin 5 → ℕ := ![height_8, height_26, height_179, height_186, height_187] +theorem height_exact_190 : height_190 = 1 + Finset.univ.sup childrenH_190 := by decide +kernel +theorem required_origin_190 : ∀ x ∈ required_190, + (∃ j, x ∈ childrenC_190 j) ∨ ∀ j, x ∈ childrenD_190 j := by decide +kernel +theorem required_exact_190 : required_190 = + ((Finset.univ.biUnion childrenC_190) ∪ commonEnvelope childrenD_190).erase (2, 5) := by + exact required_eq_combination childrenC_190 childrenD_190 (2, 5) required_190 + (by decide +kernel) child_required_sub_190 common_sub_190 required_origin_190 +theorem envelope_origin_190 : ∀ x ∈ envelope_190, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_190 j := by decide +kernel +theorem envelope_exact_190 : envelope_190 = + insert (2, 5) (Finset.univ.biUnion childrenD_190) := by + exact envelope_eq_combination childrenD_190 (2, 5) envelope_190 + pivot_mem_190 child_envelope_sub_190 envelope_origin_190 +def checked_190 : CheckedCard where + required := required_190 + envelope := envelope_190 + height := height_190 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_190 +def height_192 : ℕ := 6 +def childrenH_192 : Fin 5 → ℕ := ![height_9, height_9, height_186, height_187, height_191] +theorem height_exact_192 : height_192 = 1 + Finset.univ.sup childrenH_192 := by decide +kernel +theorem required_origin_192 : ∀ x ∈ required_192, + (∃ j, x ∈ childrenC_192 j) ∨ ∀ j, x ∈ childrenD_192 j := by decide +kernel +theorem required_exact_192 : required_192 = + ((Finset.univ.biUnion childrenC_192) ∪ commonEnvelope childrenD_192).erase (1, 5) := by + exact required_eq_combination childrenC_192 childrenD_192 (1, 5) required_192 + (by decide +kernel) child_required_sub_192 common_sub_192 required_origin_192 +theorem envelope_origin_192 : ∀ x ∈ envelope_192, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_192 j := by decide +kernel +theorem envelope_exact_192 : envelope_192 = + insert (1, 5) (Finset.univ.biUnion childrenD_192) := by + exact envelope_eq_combination childrenD_192 (1, 5) envelope_192 + pivot_mem_192 child_envelope_sub_192 envelope_origin_192 +def checked_192 : CheckedCard where + required := required_192 + envelope := envelope_192 + height := height_192 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_192 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part02.lean new file mode 100644 index 0000000..aa639bb --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part02.lean @@ -0,0 +1,979 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_193 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_193 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_193 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) required_7), (placed21 5 (2, 2) required_26), (placed21 0 (0, 1) required_191)] +def childrenD_193 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) envelope_7), (placed21 5 (2, 2) envelope_26), (placed21 0 (0, 1) envelope_191)] +theorem common_sub_193 : commonEnvelope childrenD_193 ⊆ insert (1, 5) required_193 := by decide +kernel +theorem child_required_sub_193 : ∀ j, childrenC_193 j ⊆ insert (1, 5) required_193 := by decide +kernel +theorem child_envelope_sub_193 : ∀ j, childrenD_193 j ⊆ envelope_193 := by decide +kernel +theorem pivot_mem_193 : (1, 5) ∈ envelope_193 := by decide +kernel +theorem children_work_193 : ∀ j, Template HasSnaky 5 (childrenC_193 j) (childrenD_193 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_26 5 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_191 0 (0, 1)).mono (by decide +kernel) +theorem row_works_193 : Template HasSnaky 6 required_193 envelope_193 := by + refine compose HasSnaky 5 childrenC_193 childrenD_193 children_work_193 (1, 5) + required_193 envelope_193 pivot_mem_193 child_required_sub_193 child_envelope_sub_193 ?_ + intro b hb + exact common_sub_193 (mem_commonEnvelope childrenD_193 b hb) +def required_203 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 4), (2, 1), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_203 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 4), (4, 3), (4, 4), (5, 3), (5, 4), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_203 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 1 (0, 1) required_202)] +def childrenD_203 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_202)] +theorem common_sub_203 : commonEnvelope childrenD_203 ⊆ insert (1, 3) required_203 := by decide +kernel +theorem child_required_sub_203 : ∀ j, childrenC_203 j ⊆ insert (1, 3) required_203 := by decide +kernel +theorem child_envelope_sub_203 : ∀ j, childrenD_203 j ⊆ envelope_203 := by decide +kernel +theorem pivot_mem_203 : (1, 3) ∈ envelope_203 := by decide +kernel +theorem children_work_203 : ∀ j, Template HasSnaky 5 (childrenC_203 j) (childrenD_203 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_202 1 (0, 1)).mono (by decide +kernel) +theorem row_works_203 : Template HasSnaky 6 required_203 envelope_203 := by + refine compose HasSnaky 5 childrenC_203 childrenD_203 children_work_203 (1, 3) + required_203 envelope_203 pivot_mem_203 child_required_sub_203 child_envelope_sub_203 ?_ + intro b hb + exact common_sub_203 (mem_commonEnvelope childrenD_203 b hb) +def required_217 : Finset Cell := ⟨(([(1, 2), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_217 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (3, 6), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_217 : Fin 3 → Finset Cell := ![(placed21 2 (2, 1) required_21), (placed21 0 (1, 1) required_37), (placed21 3 (0, 5) required_179)] +def childrenD_217 : Fin 3 → Finset Cell := ![(placed21 2 (2, 1) envelope_21), (placed21 0 (1, 1) envelope_37), (placed21 3 (0, 5) envelope_179)] +theorem common_sub_217 : commonEnvelope childrenD_217 ⊆ insert (2, 4) required_217 := by decide +kernel +theorem child_required_sub_217 : ∀ j, childrenC_217 j ⊆ insert (2, 4) required_217 := by decide +kernel +theorem child_envelope_sub_217 : ∀ j, childrenD_217 j ⊆ envelope_217 := by decide +kernel +theorem pivot_mem_217 : (2, 4) ∈ envelope_217 := by decide +kernel +theorem children_work_217 : ∀ j, Template HasSnaky 5 (childrenC_217 j) (childrenD_217 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 2 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_37 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_179 3 (0, 5)).mono (by decide +kernel) +theorem row_works_217 : Template HasSnaky 6 required_217 envelope_217 := by + refine compose HasSnaky 5 childrenC_217 childrenD_217 children_work_217 (2, 4) + required_217 envelope_217 pivot_mem_217 child_required_sub_217 child_envelope_sub_217 ?_ + intro b hb + exact common_sub_217 (mem_commonEnvelope childrenD_217 b hb) +def required_238 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_238 : Finset Cell := ⟨(([(0, 4), (1, 1), (1, 2), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_238 : Fin 2 → Finset Cell := ![(placed21 7 (2, 5) required_0), (placed21 3 (0, 5) required_133)] +def childrenD_238 : Fin 2 → Finset Cell := ![(placed21 7 (2, 5) envelope_0), (placed21 3 (0, 5) envelope_133)] +theorem common_sub_238 : commonEnvelope childrenD_238 ⊆ insert (2, 4) required_238 := by decide +kernel +theorem child_required_sub_238 : ∀ j, childrenC_238 j ⊆ insert (2, 4) required_238 := by decide +kernel +theorem child_envelope_sub_238 : ∀ j, childrenD_238 j ⊆ envelope_238 := by decide +kernel +theorem pivot_mem_238 : (2, 4) ∈ envelope_238 := by decide +kernel +theorem children_work_238 : ∀ j, Template HasSnaky 5 (childrenC_238 j) (childrenD_238 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_133 3 (0, 5)).mono (by decide +kernel) +theorem row_works_238 : Template HasSnaky 6 required_238 envelope_238 := by + refine compose HasSnaky 5 childrenC_238 childrenD_238 children_work_238 (2, 4) + required_238 envelope_238 pivot_mem_238 child_required_sub_238 child_envelope_sub_238 ?_ + intro b hb + exact common_sub_238 (mem_commonEnvelope childrenD_238 b hb) +def required_248 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_248 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_248 : Fin 3 → Finset Cell := ![(placed21 6 (2, 6) required_44), (placed21 3 (0, 6) required_47), (placed21 0 (1, 1) required_127)] +def childrenD_248 : Fin 3 → Finset Cell := ![(placed21 6 (2, 6) envelope_44), (placed21 3 (0, 6) envelope_47), (placed21 0 (1, 1) envelope_127)] +theorem common_sub_248 : commonEnvelope childrenD_248 ⊆ insert (2, 5) required_248 := by decide +kernel +theorem child_required_sub_248 : ∀ j, childrenC_248 j ⊆ insert (2, 5) required_248 := by decide +kernel +theorem child_envelope_sub_248 : ∀ j, childrenD_248 j ⊆ envelope_248 := by decide +kernel +theorem pivot_mem_248 : (2, 5) ∈ envelope_248 := by decide +kernel +theorem children_work_248 : ∀ j, Template HasSnaky 5 (childrenC_248 j) (childrenD_248 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_47 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_127 0 (1, 1)).mono (by decide +kernel) +theorem row_works_248 : Template HasSnaky 6 required_248 envelope_248 := by + refine compose HasSnaky 5 childrenC_248 childrenD_248 children_work_248 (2, 5) + required_248 envelope_248 pivot_mem_248 child_required_sub_248 child_envelope_sub_248 ?_ + intro b hb + exact common_sub_248 (mem_commonEnvelope childrenD_248 b hb) +def required_253 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_253 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_253 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) required_6), (placed21 1 (1, 2) required_18), required_252] +def childrenD_253 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) envelope_6), (placed21 1 (1, 2) envelope_18), envelope_252] +theorem common_sub_253 : commonEnvelope childrenD_253 ⊆ insert (4, 3) required_253 := by decide +kernel +theorem child_required_sub_253 : ∀ j, childrenC_253 j ⊆ insert (4, 3) required_253 := by decide +kernel +theorem child_envelope_sub_253 : ∀ j, childrenD_253 j ⊆ envelope_253 := by decide +kernel +theorem pivot_mem_253 : (4, 3) ∈ envelope_253 := by decide +kernel +theorem children_work_253 : ∀ j, Template HasSnaky 5 (childrenC_253 j) (childrenD_253 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_18 1 (1, 2)).mono (by decide +kernel) + · exact row_works_252.mono (by decide +kernel) +theorem row_works_253 : Template HasSnaky 6 required_253 envelope_253 := by + refine compose HasSnaky 5 childrenC_253 childrenD_253 children_work_253 (4, 3) + required_253 envelope_253 pivot_mem_253 child_required_sub_253 child_envelope_sub_253 ?_ + intro b hb + exact common_sub_253 (mem_commonEnvelope childrenD_253 b hb) +def required_255 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_255 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_255 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_5), (placed21 0 (2, 0) required_254)] +def childrenD_255 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_5), (placed21 0 (2, 0) envelope_254)] +theorem common_sub_255 : commonEnvelope childrenD_255 ⊆ insert (3, 2) required_255 := by decide +kernel +theorem child_required_sub_255 : ∀ j, childrenC_255 j ⊆ insert (3, 2) required_255 := by decide +kernel +theorem child_envelope_sub_255 : ∀ j, childrenD_255 j ⊆ envelope_255 := by decide +kernel +theorem pivot_mem_255 : (3, 2) ∈ envelope_255 := by decide +kernel +theorem children_work_255 : ∀ j, Template HasSnaky 5 (childrenC_255 j) (childrenD_255 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_254 0 (2, 0)).mono (by decide +kernel) +theorem row_works_255 : Template HasSnaky 6 required_255 envelope_255 := by + refine compose HasSnaky 5 childrenC_255 childrenD_255 children_work_255 (3, 2) + required_255 envelope_255 pivot_mem_255 child_required_sub_255 child_envelope_sub_255 ?_ + intro b hb + exact common_sub_255 (mem_commonEnvelope childrenD_255 b hb) +def required_267 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_267 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_267 : Fin 5 → Finset Cell := ![(placed21 1 (1, 2) required_8), (placed21 0 (1, 2) required_17), (placed21 0 (1, 0) required_75), (placed21 3 (0, 6) required_179), (placed21 2 (2, 0) required_266)] +def childrenD_267 : Fin 5 → Finset Cell := ![(placed21 1 (1, 2) envelope_8), (placed21 0 (1, 2) envelope_17), (placed21 0 (1, 0) envelope_75), (placed21 3 (0, 6) envelope_179), (placed21 2 (2, 0) envelope_266)] +theorem common_sub_267 : commonEnvelope childrenD_267 ⊆ insert (2, 5) required_267 := by decide +kernel +theorem child_required_sub_267 : ∀ j, childrenC_267 j ⊆ insert (2, 5) required_267 := by decide +kernel +theorem child_envelope_sub_267 : ∀ j, childrenD_267 j ⊆ envelope_267 := by decide +kernel +theorem pivot_mem_267 : (2, 5) ∈ envelope_267 := by decide +kernel +theorem children_work_267 : ∀ j, Template HasSnaky 5 (childrenC_267 j) (childrenD_267 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_17 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_75 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_179 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_266 2 (2, 0)).mono (by decide +kernel) +theorem row_works_267 : Template HasSnaky 6 required_267 envelope_267 := by + refine compose HasSnaky 5 childrenC_267 childrenD_267 children_work_267 (2, 5) + required_267 envelope_267 pivot_mem_267 child_required_sub_267 child_envelope_sub_267 ?_ + intro b hb + exact common_sub_267 (mem_commonEnvelope childrenD_267 b hb) +def required_270 : Finset Cell := ⟨(([(0, 1), (2, 2), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_270 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (4, 2), (4, 3), (5, 1), (5, 2), (5, 3), (6, 1), (6, 2), (6, 3), (7, 1), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_270 : Fin 4 → Finset Cell := ![(placed21 7 (4, 2) required_70), (placed21 1 (0, 1) required_106), (placed21 1 (1, 0) required_122), (placed21 1 (0, 1) required_269)] +def childrenD_270 : Fin 4 → Finset Cell := ![(placed21 7 (4, 2) envelope_70), (placed21 1 (0, 1) envelope_106), (placed21 1 (1, 0) envelope_122), (placed21 1 (0, 1) envelope_269)] +theorem common_sub_270 : commonEnvelope childrenD_270 ⊆ insert (4, 2) required_270 := by decide +kernel +theorem child_required_sub_270 : ∀ j, childrenC_270 j ⊆ insert (4, 2) required_270 := by decide +kernel +theorem child_envelope_sub_270 : ∀ j, childrenD_270 j ⊆ envelope_270 := by decide +kernel +theorem pivot_mem_270 : (4, 2) ∈ envelope_270 := by decide +kernel +theorem children_work_270 : ∀ j, Template HasSnaky 5 (childrenC_270 j) (childrenD_270 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_70 7 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_106 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_122 1 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_269 1 (0, 1)).mono (by decide +kernel) +theorem row_works_270 : Template HasSnaky 6 required_270 envelope_270 := by + refine compose HasSnaky 5 childrenC_270 childrenD_270 children_work_270 (4, 2) + required_270 envelope_270 pivot_mem_270 child_required_sub_270 child_envelope_sub_270 ?_ + intro b hb + exact common_sub_270 (mem_commonEnvelope childrenD_270 b hb) +def required_275 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_275 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_275 : Fin 3 → Finset Cell := ![(placed21 3 (1, 2) required_16), (placed21 0 (1, 1) required_24), (placed21 2 (5, 0) required_179)] +def childrenD_275 : Fin 3 → Finset Cell := ![(placed21 3 (1, 2) envelope_16), (placed21 0 (1, 1) envelope_24), (placed21 2 (5, 0) envelope_179)] +theorem common_sub_275 : commonEnvelope childrenD_275 ⊆ insert (4, 2) required_275 := by decide +kernel +theorem child_required_sub_275 : ∀ j, childrenC_275 j ⊆ insert (4, 2) required_275 := by decide +kernel +theorem child_envelope_sub_275 : ∀ j, childrenD_275 j ⊆ envelope_275 := by decide +kernel +theorem pivot_mem_275 : (4, 2) ∈ envelope_275 := by decide +kernel +theorem children_work_275 : ∀ j, Template HasSnaky 5 (childrenC_275 j) (childrenD_275 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_16 3 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_24 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_179 2 (5, 0)).mono (by decide +kernel) +theorem row_works_275 : Template HasSnaky 6 required_275 envelope_275 := by + refine compose HasSnaky 5 childrenC_275 childrenD_275 children_work_275 (4, 2) + required_275 envelope_275 pivot_mem_275 child_required_sub_275 child_envelope_sub_275 ?_ + intro b hb + exact common_sub_275 (mem_commonEnvelope childrenD_275 b hb) +def required_283 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_283 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (6, 1), (6, 2), (6, 3), (7, 1), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_283 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_1), (placed21 0 (2, 0) required_282)] +def childrenD_283 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_1), (placed21 0 (2, 0) envelope_282)] +theorem common_sub_283 : commonEnvelope childrenD_283 ⊆ insert (2, 2) required_283 := by decide +kernel +theorem child_required_sub_283 : ∀ j, childrenC_283 j ⊆ insert (2, 2) required_283 := by decide +kernel +theorem child_envelope_sub_283 : ∀ j, childrenD_283 j ⊆ envelope_283 := by decide +kernel +theorem pivot_mem_283 : (2, 2) ∈ envelope_283 := by decide +kernel +theorem children_work_283 : ∀ j, Template HasSnaky 5 (childrenC_283 j) (childrenD_283 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_282 0 (2, 0)).mono (by decide +kernel) +theorem row_works_283 : Template HasSnaky 6 required_283 envelope_283 := by + refine compose HasSnaky 5 childrenC_283 childrenD_283 children_work_283 (2, 2) + required_283 envelope_283 pivot_mem_283 child_required_sub_283 child_envelope_sub_283 ?_ + intro b hb + exact common_sub_283 (mem_commonEnvelope childrenD_283 b hb) +def required_284 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_284 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 6), (2, 7), (2, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_284 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) required_8), (placed21 0 (0, 3) required_17), (placed21 4 (0, 7) required_19), (placed21 0 (0, 1) required_75)] +def childrenD_284 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) envelope_8), (placed21 0 (0, 3) envelope_17), (placed21 4 (0, 7) envelope_19), (placed21 0 (0, 1) envelope_75)] +theorem common_sub_284 : commonEnvelope childrenD_284 ⊆ insert (1, 3) required_284 := by decide +kernel +theorem child_required_sub_284 : ∀ j, childrenC_284 j ⊆ insert (1, 3) required_284 := by decide +kernel +theorem child_envelope_sub_284 : ∀ j, childrenD_284 j ⊆ envelope_284 := by decide +kernel +theorem pivot_mem_284 : (1, 3) ∈ envelope_284 := by decide +kernel +theorem children_work_284 : ∀ j, Template HasSnaky 5 (childrenC_284 j) (childrenD_284 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_17 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_19 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_75 0 (0, 1)).mono (by decide +kernel) +theorem row_works_284 : Template HasSnaky 6 required_284 envelope_284 := by + refine compose HasSnaky 5 childrenC_284 childrenD_284 children_work_284 (1, 3) + required_284 envelope_284 pivot_mem_284 child_required_sub_284 child_envelope_sub_284 ?_ + intro b hb + exact common_sub_284 (mem_commonEnvelope childrenD_284 b hb) +def required_287 : Finset Cell := ⟨(([(0, 0), (0, 3), (1, 3), (1, 4), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_287 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_287 : Fin 2 → Finset Cell := ![(placed21 6 (1, 6) required_169), (placed21 5 (5, 2) required_230)] +def childrenD_287 : Fin 2 → Finset Cell := ![(placed21 6 (1, 6) envelope_169), (placed21 5 (5, 2) envelope_230)] +theorem common_sub_287 : commonEnvelope childrenD_287 ⊆ insert (1, 6) required_287 := by decide +kernel +theorem child_required_sub_287 : ∀ j, childrenC_287 j ⊆ insert (1, 6) required_287 := by decide +kernel +theorem child_envelope_sub_287 : ∀ j, childrenD_287 j ⊆ envelope_287 := by decide +kernel +theorem pivot_mem_287 : (1, 6) ∈ envelope_287 := by decide +kernel +theorem children_work_287 : ∀ j, Template HasSnaky 5 (childrenC_287 j) (childrenD_287 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_169 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_230 5 (5, 2)).mono (by decide +kernel) +theorem row_works_287 : Template HasSnaky 6 required_287 envelope_287 := by + refine compose HasSnaky 5 childrenC_287 childrenD_287 children_work_287 (1, 6) + required_287 envelope_287 pivot_mem_287 child_required_sub_287 child_envelope_sub_287 ?_ + intro b hb + exact common_sub_287 (mem_commonEnvelope childrenD_287 b hb) +def required_292 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_292 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_292 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) required_6), (placed21 1 (0, 2) required_19), required_214] +def childrenD_292 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) envelope_6), (placed21 1 (0, 2) envelope_19), envelope_214] +theorem common_sub_292 : commonEnvelope childrenD_292 ⊆ insert (4, 3) required_292 := by decide +kernel +theorem child_required_sub_292 : ∀ j, childrenC_292 j ⊆ insert (4, 3) required_292 := by decide +kernel +theorem child_envelope_sub_292 : ∀ j, childrenD_292 j ⊆ envelope_292 := by decide +kernel +theorem pivot_mem_292 : (4, 3) ∈ envelope_292 := by decide +kernel +theorem children_work_292 : ∀ j, Template HasSnaky 5 (childrenC_292 j) (childrenD_292 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_19 1 (0, 2)).mono (by decide +kernel) + · exact row_works_214.mono (by decide +kernel) +theorem row_works_292 : Template HasSnaky 6 required_292 envelope_292 := by + refine compose HasSnaky 5 childrenC_292 childrenD_292 children_work_292 (4, 3) + required_292 envelope_292 pivot_mem_292 child_required_sub_292 child_envelope_sub_292 ?_ + intro b hb + exact common_sub_292 (mem_commonEnvelope childrenD_292 b hb) +def required_300 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_300 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_300 : Fin 4 → Finset Cell := ![(placed21 6 (2, 6) required_44), (placed21 6 (2, 6) required_52), (placed21 0 (1, 1) required_128), (placed21 3 (0, 6) required_155)] +def childrenD_300 : Fin 4 → Finset Cell := ![(placed21 6 (2, 6) envelope_44), (placed21 6 (2, 6) envelope_52), (placed21 0 (1, 1) envelope_128), (placed21 3 (0, 6) envelope_155)] +theorem common_sub_300 : commonEnvelope childrenD_300 ⊆ insert (2, 5) required_300 := by decide +kernel +theorem child_required_sub_300 : ∀ j, childrenC_300 j ⊆ insert (2, 5) required_300 := by decide +kernel +theorem child_envelope_sub_300 : ∀ j, childrenD_300 j ⊆ envelope_300 := by decide +kernel +theorem pivot_mem_300 : (2, 5) ∈ envelope_300 := by decide +kernel +theorem children_work_300 : ∀ j, Template HasSnaky 5 (childrenC_300 j) (childrenD_300 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_128 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_155 3 (0, 6)).mono (by decide +kernel) +theorem row_works_300 : Template HasSnaky 6 required_300 envelope_300 := by + refine compose HasSnaky 5 childrenC_300 childrenD_300 children_work_300 (2, 5) + required_300 envelope_300 pivot_mem_300 child_required_sub_300 child_envelope_sub_300 ?_ + intro b hb + exact common_sub_300 (mem_commonEnvelope childrenD_300 b hb) +def required_302 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_302 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (6, 3), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_302 : Fin 2 → Finset Cell := ![(placed21 7 (5, 3) required_6), (placed21 4 (1, 6) required_214)] +def childrenD_302 : Fin 2 → Finset Cell := ![(placed21 7 (5, 3) envelope_6), (placed21 4 (1, 6) envelope_214)] +theorem common_sub_302 : commonEnvelope childrenD_302 ⊆ insert (5, 3) required_302 := by decide +kernel +theorem child_required_sub_302 : ∀ j, childrenC_302 j ⊆ insert (5, 3) required_302 := by decide +kernel +theorem child_envelope_sub_302 : ∀ j, childrenD_302 j ⊆ envelope_302 := by decide +kernel +theorem pivot_mem_302 : (5, 3) ∈ envelope_302 := by decide +kernel +theorem children_work_302 : ∀ j, Template HasSnaky 5 (childrenC_302 j) (childrenD_302 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 7 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_214 4 (1, 6)).mono (by decide +kernel) +theorem row_works_302 : Template HasSnaky 6 required_302 envelope_302 := by + refine compose HasSnaky 5 childrenC_302 childrenD_302 children_work_302 (5, 3) + required_302 envelope_302 pivot_mem_302 child_required_sub_302 child_envelope_sub_302 ?_ + intro b hb + exact common_sub_302 (mem_commonEnvelope childrenD_302 b hb) +def required_303 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_303 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (5, 2), (5, 3), (5, 4), (6, 3), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_303 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) required_55), (placed21 3 (0, 4) required_234)] +def childrenD_303 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) envelope_55), (placed21 3 (0, 4) envelope_234)] +theorem common_sub_303 : commonEnvelope childrenD_303 ⊆ insert (3, 4) required_303 := by decide +kernel +theorem child_required_sub_303 : ∀ j, childrenC_303 j ⊆ insert (3, 4) required_303 := by decide +kernel +theorem child_envelope_sub_303 : ∀ j, childrenD_303 j ⊆ envelope_303 := by decide +kernel +theorem pivot_mem_303 : (3, 4) ∈ envelope_303 := by decide +kernel +theorem children_work_303 : ∀ j, Template HasSnaky 5 (childrenC_303 j) (childrenD_303 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_55 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_234 3 (0, 4)).mono (by decide +kernel) +theorem row_works_303 : Template HasSnaky 6 required_303 envelope_303 := by + refine compose HasSnaky 5 childrenC_303 childrenD_303 children_work_303 (3, 4) + required_303 envelope_303 pivot_mem_303 child_required_sub_303 child_envelope_sub_303 ?_ + intro b hb + exact common_sub_303 (mem_commonEnvelope childrenD_303 b hb) +def required_313 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_313 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_313 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), (placed21 5 (4, 0) required_312)] +def childrenD_313 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), (placed21 5 (4, 0) envelope_312)] +theorem common_sub_313 : commonEnvelope childrenD_313 ⊆ insert (3, 0) required_313 := by decide +kernel +theorem child_required_sub_313 : ∀ j, childrenC_313 j ⊆ insert (3, 0) required_313 := by decide +kernel +theorem child_envelope_sub_313 : ∀ j, childrenD_313 j ⊆ envelope_313 := by decide +kernel +theorem pivot_mem_313 : (3, 0) ∈ envelope_313 := by decide +kernel +theorem children_work_313 : ∀ j, Template HasSnaky 5 (childrenC_313 j) (childrenD_313 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_312 5 (4, 0)).mono (by decide +kernel) +theorem row_works_313 : Template HasSnaky 6 required_313 envelope_313 := by + refine compose HasSnaky 5 childrenC_313 childrenD_313 children_work_313 (3, 0) + required_313 envelope_313 pivot_mem_313 child_required_sub_313 child_envelope_sub_313 ?_ + intro b hb + exact common_sub_313 (mem_commonEnvelope childrenD_313 b hb) +def required_315 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_315 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_315 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 1 (0, 1) required_314)] +def childrenD_315 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_314)] +theorem common_sub_315 : commonEnvelope childrenD_315 ⊆ insert (1, 4) required_315 := by decide +kernel +theorem child_required_sub_315 : ∀ j, childrenC_315 j ⊆ insert (1, 4) required_315 := by decide +kernel +theorem child_envelope_sub_315 : ∀ j, childrenD_315 j ⊆ envelope_315 := by decide +kernel +theorem pivot_mem_315 : (1, 4) ∈ envelope_315 := by decide +kernel +theorem children_work_315 : ∀ j, Template HasSnaky 5 (childrenC_315 j) (childrenD_315 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_314 1 (0, 1)).mono (by decide +kernel) +theorem row_works_315 : Template HasSnaky 6 required_315 envelope_315 := by + refine compose HasSnaky 5 childrenC_315 childrenD_315 children_work_315 (1, 4) + required_315 envelope_315 pivot_mem_315 child_required_sub_315 child_envelope_sub_315 ?_ + intro b hb + exact common_sub_315 (mem_commonEnvelope childrenD_315 b hb) +def required_316 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_316 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 6), (2, 7), (2, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_316 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) required_8), (placed21 1 (0, 2) required_314)] +def childrenD_316 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) envelope_8), (placed21 1 (0, 2) envelope_314)] +theorem common_sub_316 : commonEnvelope childrenD_316 ⊆ insert (1, 2) required_316 := by decide +kernel +theorem child_required_sub_316 : ∀ j, childrenC_316 j ⊆ insert (1, 2) required_316 := by decide +kernel +theorem child_envelope_sub_316 : ∀ j, childrenD_316 j ⊆ envelope_316 := by decide +kernel +theorem pivot_mem_316 : (1, 2) ∈ envelope_316 := by decide +kernel +theorem children_work_316 : ∀ j, Template HasSnaky 5 (childrenC_316 j) (childrenD_316 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_314 1 (0, 2)).mono (by decide +kernel) +theorem row_works_316 : Template HasSnaky 6 required_316 envelope_316 := by + refine compose HasSnaky 5 childrenC_316 childrenD_316 children_work_316 (1, 2) + required_316 envelope_316 pivot_mem_316 child_required_sub_316 child_envelope_sub_316 ?_ + intro b hb + exact common_sub_316 (mem_commonEnvelope childrenD_316 b hb) +def required_331_i1 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_331_i1 : Finset Cell := ⟨(([(2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_331_i1 : Fin 2 → Finset Cell := ![(placed21 0 (2, 2) required_20), (placed21 6 (3, 5) required_29)] +def childrenD_331_i1 : Fin 2 → Finset Cell := ![(placed21 0 (2, 2) envelope_20), (placed21 6 (3, 5) envelope_29)] +theorem common_sub_331_i1 : commonEnvelope childrenD_331_i1 ⊆ insert (3, 5) required_331_i1 := by decide +kernel +theorem child_required_sub_331_i1 : ∀ j, childrenC_331_i1 j ⊆ insert (3, 5) required_331_i1 := by decide +kernel +theorem child_envelope_sub_331_i1 : ∀ j, childrenD_331_i1 j ⊆ envelope_331_i1 := by decide +kernel +theorem pivot_mem_331_i1 : (3, 5) ∈ envelope_331_i1 := by decide +kernel +theorem children_work_331_i1 : ∀ j, Template HasSnaky 3 (childrenC_331_i1 j) (childrenD_331_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_20 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_29 6 (3, 5)).mono (by decide +kernel) +theorem row_works_331_i1 : Template HasSnaky 4 required_331_i1 envelope_331_i1 := by + refine compose HasSnaky 3 childrenC_331_i1 childrenD_331_i1 children_work_331_i1 (3, 5) + required_331_i1 envelope_331_i1 pivot_mem_331_i1 child_required_sub_331_i1 child_envelope_sub_331_i1 ?_ + intro b hb + exact common_sub_331_i1 (mem_commonEnvelope childrenD_331_i1 b hb) +def required_331_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_331_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_331_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_5), required_331_i1] +def childrenD_331_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_5), envelope_331_i1] +theorem common_sub_331_i0 : commonEnvelope childrenD_331_i0 ⊆ insert (3, 2) required_331_i0 := by decide +kernel +theorem child_required_sub_331_i0 : ∀ j, childrenC_331_i0 j ⊆ insert (3, 2) required_331_i0 := by decide +kernel +theorem child_envelope_sub_331_i0 : ∀ j, childrenD_331_i0 j ⊆ envelope_331_i0 := by decide +kernel +theorem pivot_mem_331_i0 : (3, 2) ∈ envelope_331_i0 := by decide +kernel +theorem children_work_331_i0 : ∀ j, Template HasSnaky 4 (childrenC_331_i0 j) (childrenD_331_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact row_works_331_i1.mono (by decide +kernel) +theorem row_works_331_i0 : Template HasSnaky 5 required_331_i0 envelope_331_i0 := by + refine compose HasSnaky 4 childrenC_331_i0 childrenD_331_i0 children_work_331_i0 (3, 2) + required_331_i0 envelope_331_i0 pivot_mem_331_i0 child_required_sub_331_i0 child_envelope_sub_331_i0 ?_ + intro b hb + exact common_sub_331_i0 (mem_commonEnvelope childrenD_331_i0 b hb) +def required_331 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_331 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_331 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_5), required_331_i0] +def childrenD_331 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_5), envelope_331_i0] +theorem common_sub_331 : commonEnvelope childrenD_331 ⊆ insert (3, 4) required_331 := by decide +kernel +theorem child_required_sub_331 : ∀ j, childrenC_331 j ⊆ insert (3, 4) required_331 := by decide +kernel +theorem child_envelope_sub_331 : ∀ j, childrenD_331 j ⊆ envelope_331 := by decide +kernel +theorem pivot_mem_331 : (3, 4) ∈ envelope_331 := by decide +kernel +theorem children_work_331 : ∀ j, Template HasSnaky 5 (childrenC_331 j) (childrenD_331 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact row_works_331_i0.mono (by decide +kernel) +theorem row_works_331 : Template HasSnaky 6 required_331 envelope_331 := by + refine compose HasSnaky 5 childrenC_331 childrenD_331 children_work_331 (3, 4) + required_331 envelope_331 pivot_mem_331 child_required_sub_331 child_envelope_sub_331 ?_ + intro b hb + exact common_sub_331 (mem_commonEnvelope childrenD_331 b hb) +def height_193 : ℕ := 6 +def childrenH_193 : Fin 3 → ℕ := ![height_7, height_26, height_191] +theorem height_exact_193 : height_193 = 1 + Finset.univ.sup childrenH_193 := by decide +kernel +theorem required_origin_193 : ∀ x ∈ required_193, + (∃ j, x ∈ childrenC_193 j) ∨ ∀ j, x ∈ childrenD_193 j := by decide +kernel +theorem required_exact_193 : required_193 = + ((Finset.univ.biUnion childrenC_193) ∪ commonEnvelope childrenD_193).erase (1, 5) := by + exact required_eq_combination childrenC_193 childrenD_193 (1, 5) required_193 + (by decide +kernel) child_required_sub_193 common_sub_193 required_origin_193 +theorem envelope_origin_193 : ∀ x ∈ envelope_193, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_193 j := by decide +kernel +theorem envelope_exact_193 : envelope_193 = + insert (1, 5) (Finset.univ.biUnion childrenD_193) := by + exact envelope_eq_combination childrenD_193 (1, 5) envelope_193 + pivot_mem_193 child_envelope_sub_193 envelope_origin_193 +def checked_193 : CheckedCard where + required := required_193 + envelope := envelope_193 + height := height_193 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_193 +def height_203 : ℕ := 6 +def childrenH_203 : Fin 2 → ℕ := ![height_5, height_202] +theorem height_exact_203 : height_203 = 1 + Finset.univ.sup childrenH_203 := by decide +kernel +theorem required_origin_203 : ∀ x ∈ required_203, + (∃ j, x ∈ childrenC_203 j) ∨ ∀ j, x ∈ childrenD_203 j := by decide +kernel +theorem required_exact_203 : required_203 = + ((Finset.univ.biUnion childrenC_203) ∪ commonEnvelope childrenD_203).erase (1, 3) := by + exact required_eq_combination childrenC_203 childrenD_203 (1, 3) required_203 + (by decide +kernel) child_required_sub_203 common_sub_203 required_origin_203 +theorem envelope_origin_203 : ∀ x ∈ envelope_203, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_203 j := by decide +kernel +theorem envelope_exact_203 : envelope_203 = + insert (1, 3) (Finset.univ.biUnion childrenD_203) := by + exact envelope_eq_combination childrenD_203 (1, 3) envelope_203 + pivot_mem_203 child_envelope_sub_203 envelope_origin_203 +def checked_203 : CheckedCard where + required := required_203 + envelope := envelope_203 + height := height_203 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_203 +def height_217 : ℕ := 6 +def childrenH_217 : Fin 3 → ℕ := ![height_21, height_37, height_179] +theorem height_exact_217 : height_217 = 1 + Finset.univ.sup childrenH_217 := by decide +kernel +theorem required_origin_217 : ∀ x ∈ required_217, + (∃ j, x ∈ childrenC_217 j) ∨ ∀ j, x ∈ childrenD_217 j := by decide +kernel +theorem required_exact_217 : required_217 = + ((Finset.univ.biUnion childrenC_217) ∪ commonEnvelope childrenD_217).erase (2, 4) := by + exact required_eq_combination childrenC_217 childrenD_217 (2, 4) required_217 + (by decide +kernel) child_required_sub_217 common_sub_217 required_origin_217 +theorem envelope_origin_217 : ∀ x ∈ envelope_217, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_217 j := by decide +kernel +theorem envelope_exact_217 : envelope_217 = + insert (2, 4) (Finset.univ.biUnion childrenD_217) := by + exact envelope_eq_combination childrenD_217 (2, 4) envelope_217 + pivot_mem_217 child_envelope_sub_217 envelope_origin_217 +def checked_217 : CheckedCard where + required := required_217 + envelope := envelope_217 + height := height_217 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_217 +def height_238 : ℕ := 6 +def childrenH_238 : Fin 2 → ℕ := ![height_0, height_133] +theorem height_exact_238 : height_238 = 1 + Finset.univ.sup childrenH_238 := by decide +kernel +theorem required_origin_238 : ∀ x ∈ required_238, + (∃ j, x ∈ childrenC_238 j) ∨ ∀ j, x ∈ childrenD_238 j := by decide +kernel +theorem required_exact_238 : required_238 = + ((Finset.univ.biUnion childrenC_238) ∪ commonEnvelope childrenD_238).erase (2, 4) := by + exact required_eq_combination childrenC_238 childrenD_238 (2, 4) required_238 + (by decide +kernel) child_required_sub_238 common_sub_238 required_origin_238 +theorem envelope_origin_238 : ∀ x ∈ envelope_238, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_238 j := by decide +kernel +theorem envelope_exact_238 : envelope_238 = + insert (2, 4) (Finset.univ.biUnion childrenD_238) := by + exact envelope_eq_combination childrenD_238 (2, 4) envelope_238 + pivot_mem_238 child_envelope_sub_238 envelope_origin_238 +def checked_238 : CheckedCard where + required := required_238 + envelope := envelope_238 + height := height_238 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_238 +def height_248 : ℕ := 6 +def childrenH_248 : Fin 3 → ℕ := ![height_44, height_47, height_127] +theorem height_exact_248 : height_248 = 1 + Finset.univ.sup childrenH_248 := by decide +kernel +theorem required_origin_248 : ∀ x ∈ required_248, + (∃ j, x ∈ childrenC_248 j) ∨ ∀ j, x ∈ childrenD_248 j := by decide +kernel +theorem required_exact_248 : required_248 = + ((Finset.univ.biUnion childrenC_248) ∪ commonEnvelope childrenD_248).erase (2, 5) := by + exact required_eq_combination childrenC_248 childrenD_248 (2, 5) required_248 + (by decide +kernel) child_required_sub_248 common_sub_248 required_origin_248 +theorem envelope_origin_248 : ∀ x ∈ envelope_248, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_248 j := by decide +kernel +theorem envelope_exact_248 : envelope_248 = + insert (2, 5) (Finset.univ.biUnion childrenD_248) := by + exact envelope_eq_combination childrenD_248 (2, 5) envelope_248 + pivot_mem_248 child_envelope_sub_248 envelope_origin_248 +def checked_248 : CheckedCard where + required := required_248 + envelope := envelope_248 + height := height_248 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_248 +def height_253 : ℕ := 6 +def childrenH_253 : Fin 3 → ℕ := ![height_6, height_18, height_252] +theorem height_exact_253 : height_253 = 1 + Finset.univ.sup childrenH_253 := by decide +kernel +theorem required_origin_253 : ∀ x ∈ required_253, + (∃ j, x ∈ childrenC_253 j) ∨ ∀ j, x ∈ childrenD_253 j := by decide +kernel +theorem required_exact_253 : required_253 = + ((Finset.univ.biUnion childrenC_253) ∪ commonEnvelope childrenD_253).erase (4, 3) := by + exact required_eq_combination childrenC_253 childrenD_253 (4, 3) required_253 + (by decide +kernel) child_required_sub_253 common_sub_253 required_origin_253 +theorem envelope_origin_253 : ∀ x ∈ envelope_253, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_253 j := by decide +kernel +theorem envelope_exact_253 : envelope_253 = + insert (4, 3) (Finset.univ.biUnion childrenD_253) := by + exact envelope_eq_combination childrenD_253 (4, 3) envelope_253 + pivot_mem_253 child_envelope_sub_253 envelope_origin_253 +def checked_253 : CheckedCard where + required := required_253 + envelope := envelope_253 + height := height_253 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_253 +def height_255 : ℕ := 6 +def childrenH_255 : Fin 2 → ℕ := ![height_5, height_254] +theorem height_exact_255 : height_255 = 1 + Finset.univ.sup childrenH_255 := by decide +kernel +theorem required_origin_255 : ∀ x ∈ required_255, + (∃ j, x ∈ childrenC_255 j) ∨ ∀ j, x ∈ childrenD_255 j := by decide +kernel +theorem required_exact_255 : required_255 = + ((Finset.univ.biUnion childrenC_255) ∪ commonEnvelope childrenD_255).erase (3, 2) := by + exact required_eq_combination childrenC_255 childrenD_255 (3, 2) required_255 + (by decide +kernel) child_required_sub_255 common_sub_255 required_origin_255 +theorem envelope_origin_255 : ∀ x ∈ envelope_255, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_255 j := by decide +kernel +theorem envelope_exact_255 : envelope_255 = + insert (3, 2) (Finset.univ.biUnion childrenD_255) := by + exact envelope_eq_combination childrenD_255 (3, 2) envelope_255 + pivot_mem_255 child_envelope_sub_255 envelope_origin_255 +def checked_255 : CheckedCard where + required := required_255 + envelope := envelope_255 + height := height_255 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_255 +def height_267 : ℕ := 6 +def childrenH_267 : Fin 5 → ℕ := ![height_8, height_17, height_75, height_179, height_266] +theorem height_exact_267 : height_267 = 1 + Finset.univ.sup childrenH_267 := by decide +kernel +theorem required_origin_267 : ∀ x ∈ required_267, + (∃ j, x ∈ childrenC_267 j) ∨ ∀ j, x ∈ childrenD_267 j := by decide +kernel +theorem required_exact_267 : required_267 = + ((Finset.univ.biUnion childrenC_267) ∪ commonEnvelope childrenD_267).erase (2, 5) := by + exact required_eq_combination childrenC_267 childrenD_267 (2, 5) required_267 + (by decide +kernel) child_required_sub_267 common_sub_267 required_origin_267 +theorem envelope_origin_267 : ∀ x ∈ envelope_267, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_267 j := by decide +kernel +theorem envelope_exact_267 : envelope_267 = + insert (2, 5) (Finset.univ.biUnion childrenD_267) := by + exact envelope_eq_combination childrenD_267 (2, 5) envelope_267 + pivot_mem_267 child_envelope_sub_267 envelope_origin_267 +def checked_267 : CheckedCard where + required := required_267 + envelope := envelope_267 + height := height_267 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_267 +def height_270 : ℕ := 6 +def childrenH_270 : Fin 4 → ℕ := ![height_70, height_106, height_122, height_269] +theorem height_exact_270 : height_270 = 1 + Finset.univ.sup childrenH_270 := by decide +kernel +theorem required_origin_270 : ∀ x ∈ required_270, + (∃ j, x ∈ childrenC_270 j) ∨ ∀ j, x ∈ childrenD_270 j := by decide +kernel +theorem required_exact_270 : required_270 = + ((Finset.univ.biUnion childrenC_270) ∪ commonEnvelope childrenD_270).erase (4, 2) := by + exact required_eq_combination childrenC_270 childrenD_270 (4, 2) required_270 + (by decide +kernel) child_required_sub_270 common_sub_270 required_origin_270 +theorem envelope_origin_270 : ∀ x ∈ envelope_270, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_270 j := by decide +kernel +theorem envelope_exact_270 : envelope_270 = + insert (4, 2) (Finset.univ.biUnion childrenD_270) := by + exact envelope_eq_combination childrenD_270 (4, 2) envelope_270 + pivot_mem_270 child_envelope_sub_270 envelope_origin_270 +def checked_270 : CheckedCard where + required := required_270 + envelope := envelope_270 + height := height_270 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_270 +def height_275 : ℕ := 6 +def childrenH_275 : Fin 3 → ℕ := ![height_16, height_24, height_179] +theorem height_exact_275 : height_275 = 1 + Finset.univ.sup childrenH_275 := by decide +kernel +theorem required_origin_275 : ∀ x ∈ required_275, + (∃ j, x ∈ childrenC_275 j) ∨ ∀ j, x ∈ childrenD_275 j := by decide +kernel +theorem required_exact_275 : required_275 = + ((Finset.univ.biUnion childrenC_275) ∪ commonEnvelope childrenD_275).erase (4, 2) := by + exact required_eq_combination childrenC_275 childrenD_275 (4, 2) required_275 + (by decide +kernel) child_required_sub_275 common_sub_275 required_origin_275 +theorem envelope_origin_275 : ∀ x ∈ envelope_275, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_275 j := by decide +kernel +theorem envelope_exact_275 : envelope_275 = + insert (4, 2) (Finset.univ.biUnion childrenD_275) := by + exact envelope_eq_combination childrenD_275 (4, 2) envelope_275 + pivot_mem_275 child_envelope_sub_275 envelope_origin_275 +def checked_275 : CheckedCard where + required := required_275 + envelope := envelope_275 + height := height_275 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_275 +def height_283 : ℕ := 6 +def childrenH_283 : Fin 2 → ℕ := ![height_1, height_282] +theorem height_exact_283 : height_283 = 1 + Finset.univ.sup childrenH_283 := by decide +kernel +theorem required_origin_283 : ∀ x ∈ required_283, + (∃ j, x ∈ childrenC_283 j) ∨ ∀ j, x ∈ childrenD_283 j := by decide +kernel +theorem required_exact_283 : required_283 = + ((Finset.univ.biUnion childrenC_283) ∪ commonEnvelope childrenD_283).erase (2, 2) := by + exact required_eq_combination childrenC_283 childrenD_283 (2, 2) required_283 + (by decide +kernel) child_required_sub_283 common_sub_283 required_origin_283 +theorem envelope_origin_283 : ∀ x ∈ envelope_283, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_283 j := by decide +kernel +theorem envelope_exact_283 : envelope_283 = + insert (2, 2) (Finset.univ.biUnion childrenD_283) := by + exact envelope_eq_combination childrenD_283 (2, 2) envelope_283 + pivot_mem_283 child_envelope_sub_283 envelope_origin_283 +def checked_283 : CheckedCard where + required := required_283 + envelope := envelope_283 + height := height_283 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_283 +def height_284 : ℕ := 6 +def childrenH_284 : Fin 4 → ℕ := ![height_8, height_17, height_19, height_75] +theorem height_exact_284 : height_284 = 1 + Finset.univ.sup childrenH_284 := by decide +kernel +theorem required_origin_284 : ∀ x ∈ required_284, + (∃ j, x ∈ childrenC_284 j) ∨ ∀ j, x ∈ childrenD_284 j := by decide +kernel +theorem required_exact_284 : required_284 = + ((Finset.univ.biUnion childrenC_284) ∪ commonEnvelope childrenD_284).erase (1, 3) := by + exact required_eq_combination childrenC_284 childrenD_284 (1, 3) required_284 + (by decide +kernel) child_required_sub_284 common_sub_284 required_origin_284 +theorem envelope_origin_284 : ∀ x ∈ envelope_284, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_284 j := by decide +kernel +theorem envelope_exact_284 : envelope_284 = + insert (1, 3) (Finset.univ.biUnion childrenD_284) := by + exact envelope_eq_combination childrenD_284 (1, 3) envelope_284 + pivot_mem_284 child_envelope_sub_284 envelope_origin_284 +def checked_284 : CheckedCard where + required := required_284 + envelope := envelope_284 + height := height_284 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_284 +def height_287 : ℕ := 6 +def childrenH_287 : Fin 2 → ℕ := ![height_169, height_230] +theorem height_exact_287 : height_287 = 1 + Finset.univ.sup childrenH_287 := by decide +kernel +theorem required_origin_287 : ∀ x ∈ required_287, + (∃ j, x ∈ childrenC_287 j) ∨ ∀ j, x ∈ childrenD_287 j := by decide +kernel +theorem required_exact_287 : required_287 = + ((Finset.univ.biUnion childrenC_287) ∪ commonEnvelope childrenD_287).erase (1, 6) := by + exact required_eq_combination childrenC_287 childrenD_287 (1, 6) required_287 + (by decide +kernel) child_required_sub_287 common_sub_287 required_origin_287 +theorem envelope_origin_287 : ∀ x ∈ envelope_287, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_287 j := by decide +kernel +theorem envelope_exact_287 : envelope_287 = + insert (1, 6) (Finset.univ.biUnion childrenD_287) := by + exact envelope_eq_combination childrenD_287 (1, 6) envelope_287 + pivot_mem_287 child_envelope_sub_287 envelope_origin_287 +def checked_287 : CheckedCard where + required := required_287 + envelope := envelope_287 + height := height_287 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_287 +def height_292 : ℕ := 6 +def childrenH_292 : Fin 3 → ℕ := ![height_6, height_19, height_214] +theorem height_exact_292 : height_292 = 1 + Finset.univ.sup childrenH_292 := by decide +kernel +theorem required_origin_292 : ∀ x ∈ required_292, + (∃ j, x ∈ childrenC_292 j) ∨ ∀ j, x ∈ childrenD_292 j := by decide +kernel +theorem required_exact_292 : required_292 = + ((Finset.univ.biUnion childrenC_292) ∪ commonEnvelope childrenD_292).erase (4, 3) := by + exact required_eq_combination childrenC_292 childrenD_292 (4, 3) required_292 + (by decide +kernel) child_required_sub_292 common_sub_292 required_origin_292 +theorem envelope_origin_292 : ∀ x ∈ envelope_292, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_292 j := by decide +kernel +theorem envelope_exact_292 : envelope_292 = + insert (4, 3) (Finset.univ.biUnion childrenD_292) := by + exact envelope_eq_combination childrenD_292 (4, 3) envelope_292 + pivot_mem_292 child_envelope_sub_292 envelope_origin_292 +def checked_292 : CheckedCard where + required := required_292 + envelope := envelope_292 + height := height_292 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_292 +def height_300 : ℕ := 6 +def childrenH_300 : Fin 4 → ℕ := ![height_44, height_52, height_128, height_155] +theorem height_exact_300 : height_300 = 1 + Finset.univ.sup childrenH_300 := by decide +kernel +theorem required_origin_300 : ∀ x ∈ required_300, + (∃ j, x ∈ childrenC_300 j) ∨ ∀ j, x ∈ childrenD_300 j := by decide +kernel +theorem required_exact_300 : required_300 = + ((Finset.univ.biUnion childrenC_300) ∪ commonEnvelope childrenD_300).erase (2, 5) := by + exact required_eq_combination childrenC_300 childrenD_300 (2, 5) required_300 + (by decide +kernel) child_required_sub_300 common_sub_300 required_origin_300 +theorem envelope_origin_300 : ∀ x ∈ envelope_300, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_300 j := by decide +kernel +theorem envelope_exact_300 : envelope_300 = + insert (2, 5) (Finset.univ.biUnion childrenD_300) := by + exact envelope_eq_combination childrenD_300 (2, 5) envelope_300 + pivot_mem_300 child_envelope_sub_300 envelope_origin_300 +def checked_300 : CheckedCard where + required := required_300 + envelope := envelope_300 + height := height_300 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_300 +def height_302 : ℕ := 6 +def childrenH_302 : Fin 2 → ℕ := ![height_6, height_214] +theorem height_exact_302 : height_302 = 1 + Finset.univ.sup childrenH_302 := by decide +kernel +theorem required_origin_302 : ∀ x ∈ required_302, + (∃ j, x ∈ childrenC_302 j) ∨ ∀ j, x ∈ childrenD_302 j := by decide +kernel +theorem required_exact_302 : required_302 = + ((Finset.univ.biUnion childrenC_302) ∪ commonEnvelope childrenD_302).erase (5, 3) := by + exact required_eq_combination childrenC_302 childrenD_302 (5, 3) required_302 + (by decide +kernel) child_required_sub_302 common_sub_302 required_origin_302 +theorem envelope_origin_302 : ∀ x ∈ envelope_302, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_302 j := by decide +kernel +theorem envelope_exact_302 : envelope_302 = + insert (5, 3) (Finset.univ.biUnion childrenD_302) := by + exact envelope_eq_combination childrenD_302 (5, 3) envelope_302 + pivot_mem_302 child_envelope_sub_302 envelope_origin_302 +def checked_302 : CheckedCard where + required := required_302 + envelope := envelope_302 + height := height_302 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_302 +def height_303 : ℕ := 6 +def childrenH_303 : Fin 2 → ℕ := ![height_55, height_234] +theorem height_exact_303 : height_303 = 1 + Finset.univ.sup childrenH_303 := by decide +kernel +theorem required_origin_303 : ∀ x ∈ required_303, + (∃ j, x ∈ childrenC_303 j) ∨ ∀ j, x ∈ childrenD_303 j := by decide +kernel +theorem required_exact_303 : required_303 = + ((Finset.univ.biUnion childrenC_303) ∪ commonEnvelope childrenD_303).erase (3, 4) := by + exact required_eq_combination childrenC_303 childrenD_303 (3, 4) required_303 + (by decide +kernel) child_required_sub_303 common_sub_303 required_origin_303 +theorem envelope_origin_303 : ∀ x ∈ envelope_303, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_303 j := by decide +kernel +theorem envelope_exact_303 : envelope_303 = + insert (3, 4) (Finset.univ.biUnion childrenD_303) := by + exact envelope_eq_combination childrenD_303 (3, 4) envelope_303 + pivot_mem_303 child_envelope_sub_303 envelope_origin_303 +def checked_303 : CheckedCard where + required := required_303 + envelope := envelope_303 + height := height_303 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_303 +def height_313 : ℕ := 6 +def childrenH_313 : Fin 2 → ℕ := ![height_5, height_312] +theorem height_exact_313 : height_313 = 1 + Finset.univ.sup childrenH_313 := by decide +kernel +theorem required_origin_313 : ∀ x ∈ required_313, + (∃ j, x ∈ childrenC_313 j) ∨ ∀ j, x ∈ childrenD_313 j := by decide +kernel +theorem required_exact_313 : required_313 = + ((Finset.univ.biUnion childrenC_313) ∪ commonEnvelope childrenD_313).erase (3, 0) := by + exact required_eq_combination childrenC_313 childrenD_313 (3, 0) required_313 + (by decide +kernel) child_required_sub_313 common_sub_313 required_origin_313 +theorem envelope_origin_313 : ∀ x ∈ envelope_313, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_313 j := by decide +kernel +theorem envelope_exact_313 : envelope_313 = + insert (3, 0) (Finset.univ.biUnion childrenD_313) := by + exact envelope_eq_combination childrenD_313 (3, 0) envelope_313 + pivot_mem_313 child_envelope_sub_313 envelope_origin_313 +def checked_313 : CheckedCard where + required := required_313 + envelope := envelope_313 + height := height_313 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_313 +def height_315 : ℕ := 6 +def childrenH_315 : Fin 2 → ℕ := ![height_5, height_314] +theorem height_exact_315 : height_315 = 1 + Finset.univ.sup childrenH_315 := by decide +kernel +theorem required_origin_315 : ∀ x ∈ required_315, + (∃ j, x ∈ childrenC_315 j) ∨ ∀ j, x ∈ childrenD_315 j := by decide +kernel +theorem required_exact_315 : required_315 = + ((Finset.univ.biUnion childrenC_315) ∪ commonEnvelope childrenD_315).erase (1, 4) := by + exact required_eq_combination childrenC_315 childrenD_315 (1, 4) required_315 + (by decide +kernel) child_required_sub_315 common_sub_315 required_origin_315 +theorem envelope_origin_315 : ∀ x ∈ envelope_315, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_315 j := by decide +kernel +theorem envelope_exact_315 : envelope_315 = + insert (1, 4) (Finset.univ.biUnion childrenD_315) := by + exact envelope_eq_combination childrenD_315 (1, 4) envelope_315 + pivot_mem_315 child_envelope_sub_315 envelope_origin_315 +def checked_315 : CheckedCard where + required := required_315 + envelope := envelope_315 + height := height_315 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_315 +def height_316 : ℕ := 6 +def childrenH_316 : Fin 2 → ℕ := ![height_8, height_314] +theorem height_exact_316 : height_316 = 1 + Finset.univ.sup childrenH_316 := by decide +kernel +theorem required_origin_316 : ∀ x ∈ required_316, + (∃ j, x ∈ childrenC_316 j) ∨ ∀ j, x ∈ childrenD_316 j := by decide +kernel +theorem required_exact_316 : required_316 = + ((Finset.univ.biUnion childrenC_316) ∪ commonEnvelope childrenD_316).erase (1, 2) := by + exact required_eq_combination childrenC_316 childrenD_316 (1, 2) required_316 + (by decide +kernel) child_required_sub_316 common_sub_316 required_origin_316 +theorem envelope_origin_316 : ∀ x ∈ envelope_316, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_316 j := by decide +kernel +theorem envelope_exact_316 : envelope_316 = + insert (1, 2) (Finset.univ.biUnion childrenD_316) := by + exact envelope_eq_combination childrenD_316 (1, 2) envelope_316 + pivot_mem_316 child_envelope_sub_316 envelope_origin_316 +def checked_316 : CheckedCard where + required := required_316 + envelope := envelope_316 + height := height_316 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_316 +def height_331_i1 : ℕ := 4 +def childrenH_331_i1 : Fin 2 → ℕ := ![height_20, height_29] +theorem height_exact_331_i1 : height_331_i1 = 1 + Finset.univ.sup childrenH_331_i1 := by decide +kernel +theorem required_origin_331_i1 : ∀ x ∈ required_331_i1, + (∃ j, x ∈ childrenC_331_i1 j) ∨ ∀ j, x ∈ childrenD_331_i1 j := by decide +kernel +theorem required_exact_331_i1 : required_331_i1 = + ((Finset.univ.biUnion childrenC_331_i1) ∪ commonEnvelope childrenD_331_i1).erase (3, 5) := by + exact required_eq_combination childrenC_331_i1 childrenD_331_i1 (3, 5) required_331_i1 + (by decide +kernel) child_required_sub_331_i1 common_sub_331_i1 required_origin_331_i1 +theorem envelope_origin_331_i1 : ∀ x ∈ envelope_331_i1, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_331_i1 j := by decide +kernel +theorem envelope_exact_331_i1 : envelope_331_i1 = + insert (3, 5) (Finset.univ.biUnion childrenD_331_i1) := by + exact envelope_eq_combination childrenD_331_i1 (3, 5) envelope_331_i1 + pivot_mem_331_i1 child_envelope_sub_331_i1 envelope_origin_331_i1 +def checked_331_i1 : CheckedCard where + required := required_331_i1 + envelope := envelope_331_i1 + height := height_331_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_331_i1 +def height_331_i0 : ℕ := 5 +def childrenH_331_i0 : Fin 2 → ℕ := ![height_5, height_331_i1] +theorem height_exact_331_i0 : height_331_i0 = 1 + Finset.univ.sup childrenH_331_i0 := by decide +kernel +theorem required_origin_331_i0 : ∀ x ∈ required_331_i0, + (∃ j, x ∈ childrenC_331_i0 j) ∨ ∀ j, x ∈ childrenD_331_i0 j := by decide +kernel +theorem required_exact_331_i0 : required_331_i0 = + ((Finset.univ.biUnion childrenC_331_i0) ∪ commonEnvelope childrenD_331_i0).erase (3, 2) := by + exact required_eq_combination childrenC_331_i0 childrenD_331_i0 (3, 2) required_331_i0 + (by decide +kernel) child_required_sub_331_i0 common_sub_331_i0 required_origin_331_i0 +theorem envelope_origin_331_i0 : ∀ x ∈ envelope_331_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_331_i0 j := by decide +kernel +theorem envelope_exact_331_i0 : envelope_331_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_331_i0) := by + exact envelope_eq_combination childrenD_331_i0 (3, 2) envelope_331_i0 + pivot_mem_331_i0 child_envelope_sub_331_i0 envelope_origin_331_i0 +def checked_331_i0 : CheckedCard where + required := required_331_i0 + envelope := envelope_331_i0 + height := height_331_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_331_i0 +def height_331 : ℕ := 6 +def childrenH_331 : Fin 2 → ℕ := ![height_5, height_331_i0] +theorem height_exact_331 : height_331 = 1 + Finset.univ.sup childrenH_331 := by decide +kernel +theorem required_origin_331 : ∀ x ∈ required_331, + (∃ j, x ∈ childrenC_331 j) ∨ ∀ j, x ∈ childrenD_331 j := by decide +kernel +theorem required_exact_331 : required_331 = + ((Finset.univ.biUnion childrenC_331) ∪ commonEnvelope childrenD_331).erase (3, 4) := by + exact required_eq_combination childrenC_331 childrenD_331 (3, 4) required_331 + (by decide +kernel) child_required_sub_331 common_sub_331 required_origin_331 +theorem envelope_origin_331 : ∀ x ∈ envelope_331, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_331 j := by decide +kernel +theorem envelope_exact_331 : envelope_331 = + insert (3, 4) (Finset.univ.biUnion childrenD_331) := by + exact envelope_eq_combination childrenD_331 (3, 4) envelope_331 + pivot_mem_331 child_envelope_sub_331 envelope_origin_331 +def checked_331 : CheckedCard where + required := required_331 + envelope := envelope_331 + height := height_331 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_331 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part03.lean new file mode 100644 index 0000000..fa31fbc --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part03.lean @@ -0,0 +1,977 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_336_i1 : Finset Cell := ⟨(([(0, 1), (1, 2), (1, 3), (1, 4), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_336_i1 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_336_i1 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_4), (placed21 2 (2, 2) required_37)] +def childrenD_336_i1 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_4), (placed21 2 (2, 2) envelope_37)] +theorem common_sub_336_i1 : commonEnvelope childrenD_336_i1 ⊆ insert (1, 5) required_336_i1 := by decide +kernel +theorem child_required_sub_336_i1 : ∀ j, childrenC_336_i1 j ⊆ insert (1, 5) required_336_i1 := by decide +kernel +theorem child_envelope_sub_336_i1 : ∀ j, childrenD_336_i1 j ⊆ envelope_336_i1 := by decide +kernel +theorem pivot_mem_336_i1 : (1, 5) ∈ envelope_336_i1 := by decide +kernel +theorem children_work_336_i1 : ∀ j, Template HasSnaky 3 (childrenC_336_i1 j) (childrenD_336_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_37 2 (2, 2)).mono (by decide +kernel) +theorem row_works_336_i1 : Template HasSnaky 4 required_336_i1 envelope_336_i1 := by + refine compose HasSnaky 3 childrenC_336_i1 childrenD_336_i1 children_work_336_i1 (1, 5) + required_336_i1 envelope_336_i1 pivot_mem_336_i1 child_required_sub_336_i1 child_envelope_sub_336_i1 ?_ + intro b hb + exact common_sub_336_i1 (mem_commonEnvelope childrenD_336_i1 b hb) +def required_336_i0 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_336_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_336_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 0) required_5), required_336_i1] +def childrenD_336_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 0) envelope_5), envelope_336_i1] +theorem common_sub_336_i0 : commonEnvelope childrenD_336_i0 ⊆ insert (2, 3) required_336_i0 := by decide +kernel +theorem child_required_sub_336_i0 : ∀ j, childrenC_336_i0 j ⊆ insert (2, 3) required_336_i0 := by decide +kernel +theorem child_envelope_sub_336_i0 : ∀ j, childrenD_336_i0 j ⊆ envelope_336_i0 := by decide +kernel +theorem pivot_mem_336_i0 : (2, 3) ∈ envelope_336_i0 := by decide +kernel +theorem children_work_336_i0 : ∀ j, Template HasSnaky 4 (childrenC_336_i0 j) (childrenD_336_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 0)).mono (by decide +kernel) + · exact row_works_336_i1.mono (by decide +kernel) +theorem row_works_336_i0 : Template HasSnaky 5 required_336_i0 envelope_336_i0 := by + refine compose HasSnaky 4 childrenC_336_i0 childrenD_336_i0 children_work_336_i0 (2, 3) + required_336_i0 envelope_336_i0 pivot_mem_336_i0 child_required_sub_336_i0 child_envelope_sub_336_i0 ?_ + intro b hb + exact common_sub_336_i0 (mem_commonEnvelope childrenD_336_i0 b hb) +def required_336 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_336 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_336 : Fin 3 → Finset Cell := ![(placed21 0 (1, 0) required_6), (placed21 0 (0, 1) required_18), required_336_i0] +def childrenD_336 : Fin 3 → Finset Cell := ![(placed21 0 (1, 0) envelope_6), (placed21 0 (0, 1) envelope_18), envelope_336_i0] +theorem common_sub_336 : commonEnvelope childrenD_336 ⊆ insert (1, 4) required_336 := by decide +kernel +theorem child_required_sub_336 : ∀ j, childrenC_336 j ⊆ insert (1, 4) required_336 := by decide +kernel +theorem child_envelope_sub_336 : ∀ j, childrenD_336 j ⊆ envelope_336 := by decide +kernel +theorem pivot_mem_336 : (1, 4) ∈ envelope_336 := by decide +kernel +theorem children_work_336 : ∀ j, Template HasSnaky 5 (childrenC_336 j) (childrenD_336 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_18 0 (0, 1)).mono (by decide +kernel) + · exact row_works_336_i0.mono (by decide +kernel) +theorem row_works_336 : Template HasSnaky 6 required_336 envelope_336 := by + refine compose HasSnaky 5 childrenC_336 childrenD_336 children_work_336 (1, 4) + required_336 envelope_336 pivot_mem_336 child_required_sub_336 child_envelope_sub_336 ?_ + intro b hb + exact common_sub_336 (mem_commonEnvelope childrenD_336 b hb) +def required_340_i0 : Finset Cell := ⟨(([(0, 3), (0, 6), (1, 3), (1, 4), (1, 5), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_340_i0 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 4), (2, 5), (2, 7), (2, 8), (2, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_340_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 3) required_5), (placed21 0 (0, 3) required_91)] +def childrenD_340_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 3) envelope_5), (placed21 0 (0, 3) envelope_91)] +theorem common_sub_340_i0 : commonEnvelope childrenD_340_i0 ⊆ insert (1, 6) required_340_i0 := by decide +kernel +theorem child_required_sub_340_i0 : ∀ j, childrenC_340_i0 j ⊆ insert (1, 6) required_340_i0 := by decide +kernel +theorem child_envelope_sub_340_i0 : ∀ j, childrenD_340_i0 j ⊆ envelope_340_i0 := by decide +kernel +theorem pivot_mem_340_i0 : (1, 6) ∈ envelope_340_i0 := by decide +kernel +theorem children_work_340_i0 : ∀ j, Template HasSnaky 4 (childrenC_340_i0 j) (childrenD_340_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_91 0 (0, 3)).mono (by decide +kernel) +theorem row_works_340_i0 : Template HasSnaky 5 required_340_i0 envelope_340_i0 := by + refine compose HasSnaky 4 childrenC_340_i0 childrenD_340_i0 children_work_340_i0 (1, 6) + required_340_i0 envelope_340_i0 pivot_mem_340_i0 child_required_sub_340_i0 child_envelope_sub_340_i0 ?_ + intro b hb + exact common_sub_340_i0 (mem_commonEnvelope childrenD_340_i0 b hb) +def required_340 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (1, 5), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_340 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 7), (2, 8), (2, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_340 : Fin 3 → Finset Cell := ![(placed21 2 (1, 2) required_139), (placed21 4 (0, 6) required_148), required_340_i0] +def childrenD_340 : Fin 3 → Finset Cell := ![(placed21 2 (1, 2) envelope_139), (placed21 4 (0, 6) envelope_148), envelope_340_i0] +theorem common_sub_340 : commonEnvelope childrenD_340 ⊆ insert (0, 6) required_340 := by decide +kernel +theorem child_required_sub_340 : ∀ j, childrenC_340 j ⊆ insert (0, 6) required_340 := by decide +kernel +theorem child_envelope_sub_340 : ∀ j, childrenD_340 j ⊆ envelope_340 := by decide +kernel +theorem pivot_mem_340 : (0, 6) ∈ envelope_340 := by decide +kernel +theorem children_work_340 : ∀ j, Template HasSnaky 5 (childrenC_340 j) (childrenD_340 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_139 2 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_148 4 (0, 6)).mono (by decide +kernel) + · exact row_works_340_i0.mono (by decide +kernel) +theorem row_works_340 : Template HasSnaky 6 required_340 envelope_340 := by + refine compose HasSnaky 5 childrenC_340 childrenD_340 children_work_340 (0, 6) + required_340 envelope_340 pivot_mem_340 child_required_sub_340 child_envelope_sub_340 ?_ + intro b hb + exact common_sub_340 (mem_commonEnvelope childrenD_340 b hb) +def required_343 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_343 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_343 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), required_342] +def childrenD_343 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), envelope_342] +theorem common_sub_343 : commonEnvelope childrenD_343 ⊆ insert (3, 3) required_343 := by decide +kernel +theorem child_required_sub_343 : ∀ j, childrenC_343 j ⊆ insert (3, 3) required_343 := by decide +kernel +theorem child_envelope_sub_343 : ∀ j, childrenD_343 j ⊆ envelope_343 := by decide +kernel +theorem pivot_mem_343 : (3, 3) ∈ envelope_343 := by decide +kernel +theorem children_work_343 : ∀ j, Template HasSnaky 5 (childrenC_343 j) (childrenD_343 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact row_works_342.mono (by decide +kernel) +theorem row_works_343 : Template HasSnaky 6 required_343 envelope_343 := by + refine compose HasSnaky 5 childrenC_343 childrenD_343 children_work_343 (3, 3) + required_343 envelope_343 pivot_mem_343 child_required_sub_343 child_envelope_sub_343 ?_ + intro b hb + exact common_sub_343 (mem_commonEnvelope childrenD_343 b hb) +def required_346 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_346 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_346 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_0), (placed21 4 (0, 5) required_342)] +def childrenD_346 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_0), (placed21 4 (0, 5) envelope_342)] +theorem common_sub_346 : commonEnvelope childrenD_346 ⊆ insert (2, 3) required_346 := by decide +kernel +theorem child_required_sub_346 : ∀ j, childrenC_346 j ⊆ insert (2, 3) required_346 := by decide +kernel +theorem child_envelope_sub_346 : ∀ j, childrenD_346 j ⊆ envelope_346 := by decide +kernel +theorem pivot_mem_346 : (2, 3) ∈ envelope_346 := by decide +kernel +theorem children_work_346 : ∀ j, Template HasSnaky 5 (childrenC_346 j) (childrenD_346 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_342 4 (0, 5)).mono (by decide +kernel) +theorem row_works_346 : Template HasSnaky 6 required_346 envelope_346 := by + refine compose HasSnaky 5 childrenC_346 childrenD_346 children_work_346 (2, 3) + required_346 envelope_346 pivot_mem_346 child_required_sub_346 child_envelope_sub_346 ?_ + intro b hb + exact common_sub_346 (mem_commonEnvelope childrenD_346 b hb) +def required_348_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_348_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_348_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), (placed21 1 (2, 0) required_311)] +def childrenD_348_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), (placed21 1 (2, 0) envelope_311)] +theorem common_sub_348_i0 : commonEnvelope childrenD_348_i0 ⊆ insert (3, 0) required_348_i0 := by decide +kernel +theorem child_required_sub_348_i0 : ∀ j, childrenC_348_i0 j ⊆ insert (3, 0) required_348_i0 := by decide +kernel +theorem child_envelope_sub_348_i0 : ∀ j, childrenD_348_i0 j ⊆ envelope_348_i0 := by decide +kernel +theorem pivot_mem_348_i0 : (3, 0) ∈ envelope_348_i0 := by decide +kernel +theorem children_work_348_i0 : ∀ j, Template HasSnaky 4 (childrenC_348_i0 j) (childrenD_348_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_311 1 (2, 0)).mono (by decide +kernel) +theorem row_works_348_i0 : Template HasSnaky 5 required_348_i0 envelope_348_i0 := by + refine compose HasSnaky 4 childrenC_348_i0 childrenD_348_i0 children_work_348_i0 (3, 0) + required_348_i0 envelope_348_i0 pivot_mem_348_i0 child_required_sub_348_i0 child_envelope_sub_348_i0 ?_ + intro b hb + exact common_sub_348_i0 (mem_commonEnvelope childrenD_348_i0 b hb) +def required_348 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_348 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_348 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), required_348_i0] +def childrenD_348 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), envelope_348_i0] +theorem common_sub_348 : commonEnvelope childrenD_348 ⊆ insert (3, 1) required_348 := by decide +kernel +theorem child_required_sub_348 : ∀ j, childrenC_348 j ⊆ insert (3, 1) required_348 := by decide +kernel +theorem child_envelope_sub_348 : ∀ j, childrenD_348 j ⊆ envelope_348 := by decide +kernel +theorem pivot_mem_348 : (3, 1) ∈ envelope_348 := by decide +kernel +theorem children_work_348 : ∀ j, Template HasSnaky 5 (childrenC_348 j) (childrenD_348 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact row_works_348_i0.mono (by decide +kernel) +theorem row_works_348 : Template HasSnaky 6 required_348 envelope_348 := by + refine compose HasSnaky 5 childrenC_348 childrenD_348 children_work_348 (3, 1) + required_348 envelope_348 pivot_mem_348 child_required_sub_348 child_envelope_sub_348 ?_ + intro b hb + exact common_sub_348 (mem_commonEnvelope childrenD_348 b hb) +def required_349_i0 : Finset Cell := ⟨(([(1, 4), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_349_i0 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (4, 8), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_349_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_10), (placed21 3 (0, 4) required_54)] +def childrenD_349_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_10), (placed21 3 (0, 4) envelope_54)] +theorem common_sub_349_i0 : commonEnvelope childrenD_349_i0 ⊆ insert (4, 3) required_349_i0 := by decide +kernel +theorem child_required_sub_349_i0 : ∀ j, childrenC_349_i0 j ⊆ insert (4, 3) required_349_i0 := by decide +kernel +theorem child_envelope_sub_349_i0 : ∀ j, childrenD_349_i0 j ⊆ envelope_349_i0 := by decide +kernel +theorem pivot_mem_349_i0 : (4, 3) ∈ envelope_349_i0 := by decide +kernel +theorem children_work_349_i0 : ∀ j, Template HasSnaky 4 (childrenC_349_i0 j) (childrenD_349_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_54 3 (0, 4)).mono (by decide +kernel) +theorem row_works_349_i0 : Template HasSnaky 5 required_349_i0 envelope_349_i0 := by + refine compose HasSnaky 4 childrenC_349_i0 childrenD_349_i0 children_work_349_i0 (4, 3) + required_349_i0 envelope_349_i0 pivot_mem_349_i0 child_required_sub_349_i0 child_envelope_sub_349_i0 ?_ + intro b hb + exact common_sub_349_i0 (mem_commonEnvelope childrenD_349_i0 b hb) +def required_349 : Finset Cell := ⟨(([(1, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_349 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 5), (6, 3), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_349 : Fin 4 → Finset Cell := ![(placed21 2 (4, 1) required_12), (placed21 0 (0, 2) required_165), (placed21 4 (0, 6) required_216), required_349_i0] +def childrenD_349 : Fin 4 → Finset Cell := ![(placed21 2 (4, 1) envelope_12), (placed21 0 (0, 2) envelope_165), (placed21 4 (0, 6) envelope_216), envelope_349_i0] +theorem common_sub_349 : commonEnvelope childrenD_349 ⊆ insert (3, 5) required_349 := by decide +kernel +theorem child_required_sub_349 : ∀ j, childrenC_349 j ⊆ insert (3, 5) required_349 := by decide +kernel +theorem child_envelope_sub_349 : ∀ j, childrenD_349 j ⊆ envelope_349 := by decide +kernel +theorem pivot_mem_349 : (3, 5) ∈ envelope_349 := by decide +kernel +theorem children_work_349 : ∀ j, Template HasSnaky 5 (childrenC_349 j) (childrenD_349 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_165 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_216 4 (0, 6)).mono (by decide +kernel) + · exact row_works_349_i0.mono (by decide +kernel) +theorem row_works_349 : Template HasSnaky 6 required_349 envelope_349 := by + refine compose HasSnaky 5 childrenC_349 childrenD_349 children_work_349 (3, 5) + required_349 envelope_349 pivot_mem_349 child_required_sub_349 child_envelope_sub_349 ?_ + intro b hb + exact common_sub_349 (mem_commonEnvelope childrenD_349 b hb) +def required_358 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_358 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 2), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_358 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), (placed21 3 (0, 4) required_357)] +def childrenD_358 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), (placed21 3 (0, 4) envelope_357)] +theorem common_sub_358 : commonEnvelope childrenD_358 ⊆ insert (2, 4) required_358 := by decide +kernel +theorem child_required_sub_358 : ∀ j, childrenC_358 j ⊆ insert (2, 4) required_358 := by decide +kernel +theorem child_envelope_sub_358 : ∀ j, childrenD_358 j ⊆ envelope_358 := by decide +kernel +theorem pivot_mem_358 : (2, 4) ∈ envelope_358 := by decide +kernel +theorem children_work_358 : ∀ j, Template HasSnaky 5 (childrenC_358 j) (childrenD_358 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_357 3 (0, 4)).mono (by decide +kernel) +theorem row_works_358 : Template HasSnaky 6 required_358 envelope_358 := by + refine compose HasSnaky 5 childrenC_358 childrenD_358 children_work_358 (2, 4) + required_358 envelope_358 pivot_mem_358 child_required_sub_358 child_envelope_sub_358 ?_ + intro b hb + exact common_sub_358 (mem_commonEnvelope childrenD_358 b hb) +def required_360_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 1), (2, 2), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_360_i0 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (4, 1), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_360_i0 : Fin 2 → Finset Cell := ![(placed21 7 (2, 4) required_5), (placed21 3 (0, 4) required_45)] +def childrenD_360_i0 : Fin 2 → Finset Cell := ![(placed21 7 (2, 4) envelope_5), (placed21 3 (0, 4) envelope_45)] +theorem common_sub_360_i0 : commonEnvelope childrenD_360_i0 ⊆ insert (2, 3) required_360_i0 := by decide +kernel +theorem child_required_sub_360_i0 : ∀ j, childrenC_360_i0 j ⊆ insert (2, 3) required_360_i0 := by decide +kernel +theorem child_envelope_sub_360_i0 : ∀ j, childrenD_360_i0 j ⊆ envelope_360_i0 := by decide +kernel +theorem pivot_mem_360_i0 : (2, 3) ∈ envelope_360_i0 := by decide +kernel +theorem children_work_360_i0 : ∀ j, Template HasSnaky 3 (childrenC_360_i0 j) (childrenD_360_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_45 3 (0, 4)).mono (by decide +kernel) +theorem row_works_360_i0 : Template HasSnaky 4 required_360_i0 envelope_360_i0 := by + refine compose HasSnaky 3 childrenC_360_i0 childrenD_360_i0 children_work_360_i0 (2, 3) + required_360_i0 envelope_360_i0 pivot_mem_360_i0 child_required_sub_360_i0 child_envelope_sub_360_i0 ?_ + intro b hb + exact common_sub_360_i0 (mem_commonEnvelope childrenD_360_i0 b hb) +def required_360 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_360 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_360 : Fin 3 → Finset Cell := ![(placed21 2 (2, 0) required_22), (placed21 1 (0, 1) required_347), required_360_i0] +def childrenD_360 : Fin 3 → Finset Cell := ![(placed21 2 (2, 0) envelope_22), (placed21 1 (0, 1) envelope_347), envelope_360_i0] +theorem common_sub_360 : commonEnvelope childrenD_360 ⊆ insert (2, 4) required_360 := by decide +kernel +theorem child_required_sub_360 : ∀ j, childrenC_360 j ⊆ insert (2, 4) required_360 := by decide +kernel +theorem child_envelope_sub_360 : ∀ j, childrenD_360 j ⊆ envelope_360 := by decide +kernel +theorem pivot_mem_360 : (2, 4) ∈ envelope_360 := by decide +kernel +theorem children_work_360 : ∀ j, Template HasSnaky 5 (childrenC_360 j) (childrenD_360 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 2 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_347 1 (0, 1)).mono (by decide +kernel) + · exact row_works_360_i0.mono (by decide +kernel) +theorem row_works_360 : Template HasSnaky 6 required_360 envelope_360 := by + refine compose HasSnaky 5 childrenC_360 childrenD_360 children_work_360 (2, 4) + required_360 envelope_360 pivot_mem_360 child_required_sub_360 child_envelope_sub_360 ?_ + intro b hb + exact common_sub_360 (mem_commonEnvelope childrenD_360 b hb) +def required_363 : Finset Cell := ⟨(([(0, 2), (0, 3), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_363 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_363 : Fin 2 → Finset Cell := ![(placed21 0 (3, 1) required_44), required_362] +def childrenD_363 : Fin 2 → Finset Cell := ![(placed21 0 (3, 1) envelope_44), envelope_362] +theorem common_sub_363 : commonEnvelope childrenD_363 ⊆ insert (4, 4) required_363 := by decide +kernel +theorem child_required_sub_363 : ∀ j, childrenC_363 j ⊆ insert (4, 4) required_363 := by decide +kernel +theorem child_envelope_sub_363 : ∀ j, childrenD_363 j ⊆ envelope_363 := by decide +kernel +theorem pivot_mem_363 : (4, 4) ∈ envelope_363 := by decide +kernel +theorem children_work_363 : ∀ j, Template HasSnaky 5 (childrenC_363 j) (childrenD_363 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 0 (3, 1)).mono (by decide +kernel) + · exact row_works_362.mono (by decide +kernel) +theorem row_works_363 : Template HasSnaky 6 required_363 envelope_363 := by + refine compose HasSnaky 5 childrenC_363 childrenD_363 children_work_363 (4, 4) + required_363 envelope_363 pivot_mem_363 child_required_sub_363 child_envelope_sub_363 ?_ + intro b hb + exact common_sub_363 (mem_commonEnvelope childrenD_363 b hb) +def required_364 : Finset Cell := ⟨(([(0, 2), (0, 3), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_364 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_364 : Fin 2 → Finset Cell := ![(placed21 0 (3, 1) required_52), required_362] +def childrenD_364 : Fin 2 → Finset Cell := ![(placed21 0 (3, 1) envelope_52), envelope_362] +theorem common_sub_364 : commonEnvelope childrenD_364 ⊆ insert (4, 4) required_364 := by decide +kernel +theorem child_required_sub_364 : ∀ j, childrenC_364 j ⊆ insert (4, 4) required_364 := by decide +kernel +theorem child_envelope_sub_364 : ∀ j, childrenD_364 j ⊆ envelope_364 := by decide +kernel +theorem pivot_mem_364 : (4, 4) ∈ envelope_364 := by decide +kernel +theorem children_work_364 : ∀ j, Template HasSnaky 5 (childrenC_364 j) (childrenD_364 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 0 (3, 1)).mono (by decide +kernel) + · exact row_works_362.mono (by decide +kernel) +theorem row_works_364 : Template HasSnaky 6 required_364 envelope_364 := by + refine compose HasSnaky 5 childrenC_364 childrenD_364 children_work_364 (4, 4) + required_364 envelope_364 pivot_mem_364 child_required_sub_364 child_envelope_sub_364 ?_ + intro b hb + exact common_sub_364 (mem_commonEnvelope childrenD_364 b hb) +def required_367 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_367 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_367 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) required_8), (placed21 6 (2, 6) required_9), required_366] +def childrenD_367 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) envelope_8), (placed21 6 (2, 6) envelope_9), envelope_366] +theorem common_sub_367 : commonEnvelope childrenD_367 ⊆ insert (1, 5) required_367 := by decide +kernel +theorem child_required_sub_367 : ∀ j, childrenC_367 j ⊆ insert (1, 5) required_367 := by decide +kernel +theorem child_envelope_sub_367 : ∀ j, childrenD_367 j ⊆ envelope_367 := by decide +kernel +theorem pivot_mem_367 : (1, 5) ∈ envelope_367 := by decide +kernel +theorem children_work_367 : ∀ j, Template HasSnaky 5 (childrenC_367 j) (childrenD_367 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 6 (2, 6)).mono (by decide +kernel) + · exact row_works_366.mono (by decide +kernel) +theorem row_works_367 : Template HasSnaky 6 required_367 envelope_367 := by + refine compose HasSnaky 5 childrenC_367 childrenD_367 children_work_367 (1, 5) + required_367 envelope_367 pivot_mem_367 child_required_sub_367 child_envelope_sub_367 ?_ + intro b hb + exact common_sub_367 (mem_commonEnvelope childrenD_367 b hb) +def required_369_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_369_i0 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_369_i0 : Fin 3 → Finset Cell := ![(placed21 2 (1, 3) required_6), (placed21 1 (0, 4) required_8), (placed21 0 (0, 2) required_365)] +def childrenD_369_i0 : Fin 3 → Finset Cell := ![(placed21 2 (1, 3) envelope_6), (placed21 1 (0, 4) envelope_8), (placed21 0 (0, 2) envelope_365)] +theorem common_sub_369_i0 : commonEnvelope childrenD_369_i0 ⊆ insert (1, 7) required_369_i0 := by decide +kernel +theorem child_required_sub_369_i0 : ∀ j, childrenC_369_i0 j ⊆ insert (1, 7) required_369_i0 := by decide +kernel +theorem child_envelope_sub_369_i0 : ∀ j, childrenD_369_i0 j ⊆ envelope_369_i0 := by decide +kernel +theorem pivot_mem_369_i0 : (1, 7) ∈ envelope_369_i0 := by decide +kernel +theorem children_work_369_i0 : ∀ j, Template HasSnaky 4 (childrenC_369_i0 j) (childrenD_369_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 2 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_365 0 (0, 2)).mono (by decide +kernel) +theorem row_works_369_i0 : Template HasSnaky 5 required_369_i0 envelope_369_i0 := by + refine compose HasSnaky 4 childrenC_369_i0 childrenD_369_i0 children_work_369_i0 (1, 7) + required_369_i0 envelope_369_i0 pivot_mem_369_i0 child_required_sub_369_i0 child_envelope_sub_369_i0 ?_ + intro b hb + exact common_sub_369_i0 (mem_commonEnvelope childrenD_369_i0 b hb) +def required_369 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_369 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_369 : Fin 4 → Finset Cell := ![(placed21 6 (1, 7) required_7), (placed21 0 (0, 2) required_19), (placed21 6 (1, 8) required_187), required_369_i0] +def childrenD_369 : Fin 4 → Finset Cell := ![(placed21 6 (1, 7) envelope_7), (placed21 0 (0, 2) envelope_19), (placed21 6 (1, 8) envelope_187), envelope_369_i0] +theorem common_sub_369 : commonEnvelope childrenD_369 ⊆ insert (1, 6) required_369 := by decide +kernel +theorem child_required_sub_369 : ∀ j, childrenC_369 j ⊆ insert (1, 6) required_369 := by decide +kernel +theorem child_envelope_sub_369 : ∀ j, childrenD_369 j ⊆ envelope_369 := by decide +kernel +theorem pivot_mem_369 : (1, 6) ∈ envelope_369 := by decide +kernel +theorem children_work_369 : ∀ j, Template HasSnaky 5 (childrenC_369 j) (childrenD_369 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 6 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_19 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_187 6 (1, 8)).mono (by decide +kernel) + · exact row_works_369_i0.mono (by decide +kernel) +theorem row_works_369 : Template HasSnaky 6 required_369 envelope_369 := by + refine compose HasSnaky 5 childrenC_369 childrenD_369 children_work_369 (1, 6) + required_369 envelope_369 pivot_mem_369 child_required_sub_369 child_envelope_sub_369 ?_ + intro b hb + exact common_sub_369 (mem_commonEnvelope childrenD_369 b hb) +def required_371_i2 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (3, 1), (4, 1), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_371_i2 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 2), (3, 1), (3, 2), (4, 1), (4, 2), (5, 1), (6, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_371_i2 : Fin 2 → Finset Cell := ![(placed21 2 (6, 1) required_0), (placed21 0 (0, 1) required_5)] +def childrenD_371_i2 : Fin 2 → Finset Cell := ![(placed21 2 (6, 1) envelope_0), (placed21 0 (0, 1) envelope_5)] +theorem common_sub_371_i2 : commonEnvelope childrenD_371_i2 ⊆ insert (3, 2) required_371_i2 := by decide +kernel +theorem child_required_sub_371_i2 : ∀ j, childrenC_371_i2 j ⊆ insert (3, 2) required_371_i2 := by decide +kernel +theorem child_envelope_sub_371_i2 : ∀ j, childrenD_371_i2 j ⊆ envelope_371_i2 := by decide +kernel +theorem pivot_mem_371_i2 : (3, 2) ∈ envelope_371_i2 := by decide +kernel +theorem children_work_371_i2 : ∀ j, Template HasSnaky 1 (childrenC_371_i2 j) (childrenD_371_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) +theorem row_works_371_i2 : Template HasSnaky 2 required_371_i2 envelope_371_i2 := by + refine compose HasSnaky 1 childrenC_371_i2 childrenD_371_i2 children_work_371_i2 (3, 2) + required_371_i2 envelope_371_i2 pivot_mem_371_i2 child_required_sub_371_i2 child_envelope_sub_371_i2 ?_ + intro b hb + exact common_sub_371_i2 (mem_commonEnvelope childrenD_371_i2 b hb) +def required_371_i1 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 1), (4, 1), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_371_i1 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (4, 1), (4, 2), (5, 1), (6, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_371_i1 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) required_210), required_371_i2] +def childrenD_371_i1 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) envelope_210), envelope_371_i2] +theorem common_sub_371_i1 : commonEnvelope childrenD_371_i1 ⊆ insert (2, 2) required_371_i1 := by decide +kernel +theorem child_required_sub_371_i1 : ∀ j, childrenC_371_i1 j ⊆ insert (2, 2) required_371_i1 := by decide +kernel +theorem child_envelope_sub_371_i1 : ∀ j, childrenD_371_i1 j ⊆ envelope_371_i1 := by decide +kernel +theorem pivot_mem_371_i1 : (2, 2) ∈ envelope_371_i1 := by decide +kernel +theorem children_work_371_i1 : ∀ j, Template HasSnaky 2 (childrenC_371_i1 j) (childrenD_371_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_210 0 (1, 0)).mono (by decide +kernel) + · exact row_works_371_i2.mono (by decide +kernel) +theorem row_works_371_i1 : Template HasSnaky 3 required_371_i1 envelope_371_i1 := by + refine compose HasSnaky 2 childrenC_371_i1 childrenD_371_i1 children_work_371_i1 (2, 2) + required_371_i1 envelope_371_i1 pivot_mem_371_i1 child_required_sub_371_i1 child_envelope_sub_371_i1 ?_ + intro b hb + exact common_sub_371_i1 (mem_commonEnvelope childrenD_371_i1 b hb) +def required_371_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_371_i0 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (6, 0), (6, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_371_i0 : Fin 2 → Finset Cell := ![(placed21 3 (1, 1) required_6), required_371_i1] +def childrenD_371_i0 : Fin 2 → Finset Cell := ![(placed21 3 (1, 1) envelope_6), envelope_371_i1] +theorem common_sub_371_i0 : commonEnvelope childrenD_371_i0 ⊆ insert (5, 1) required_371_i0 := by decide +kernel +theorem child_required_sub_371_i0 : ∀ j, childrenC_371_i0 j ⊆ insert (5, 1) required_371_i0 := by decide +kernel +theorem child_envelope_sub_371_i0 : ∀ j, childrenD_371_i0 j ⊆ envelope_371_i0 := by decide +kernel +theorem pivot_mem_371_i0 : (5, 1) ∈ envelope_371_i0 := by decide +kernel +theorem children_work_371_i0 : ∀ j, Template HasSnaky 3 (childrenC_371_i0 j) (childrenD_371_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (1, 1)).mono (by decide +kernel) + · exact row_works_371_i1.mono (by decide +kernel) +theorem row_works_371_i0 : Template HasSnaky 4 required_371_i0 envelope_371_i0 := by + refine compose HasSnaky 3 childrenC_371_i0 childrenD_371_i0 children_work_371_i0 (5, 1) + required_371_i0 envelope_371_i0 pivot_mem_371_i0 child_required_sub_371_i0 child_envelope_sub_371_i0 ?_ + intro b hb + exact common_sub_371_i0 (mem_commonEnvelope childrenD_371_i0 b hb) +def required_371 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_371 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 0), (6, 1), (6, 2), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_371 : Fin 4 → Finset Cell := ![(placed21 1 (0, 1) required_6), (placed21 0 (1, 0) required_8), (placed21 0 (1, 0) required_370), required_371_i0] +def childrenD_371 : Fin 4 → Finset Cell := ![(placed21 1 (0, 1) envelope_6), (placed21 0 (1, 0) envelope_8), (placed21 0 (1, 0) envelope_370), envelope_371_i0] +theorem common_sub_371 : commonEnvelope childrenD_371 ⊆ insert (4, 1) required_371 := by decide +kernel +theorem child_required_sub_371 : ∀ j, childrenC_371 j ⊆ insert (4, 1) required_371 := by decide +kernel +theorem child_envelope_sub_371 : ∀ j, childrenD_371 j ⊆ envelope_371 := by decide +kernel +theorem pivot_mem_371 : (4, 1) ∈ envelope_371 := by decide +kernel +theorem children_work_371 : ∀ j, Template HasSnaky 5 (childrenC_371 j) (childrenD_371 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_8 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_370 0 (1, 0)).mono (by decide +kernel) + · exact row_works_371_i0.mono (by decide +kernel) +theorem row_works_371 : Template HasSnaky 6 required_371 envelope_371 := by + refine compose HasSnaky 5 childrenC_371 childrenD_371 children_work_371 (4, 1) + required_371 envelope_371 pivot_mem_371 child_required_sub_371 child_envelope_sub_371 ?_ + intro b hb + exact common_sub_371 (mem_commonEnvelope childrenD_371 b hb) +def height_336_i1 : ℕ := 4 +def childrenH_336_i1 : Fin 2 → ℕ := ![height_4, height_37] +theorem height_exact_336_i1 : height_336_i1 = 1 + Finset.univ.sup childrenH_336_i1 := by decide +kernel +theorem required_origin_336_i1 : ∀ x ∈ required_336_i1, + (∃ j, x ∈ childrenC_336_i1 j) ∨ ∀ j, x ∈ childrenD_336_i1 j := by decide +kernel +theorem required_exact_336_i1 : required_336_i1 = + ((Finset.univ.biUnion childrenC_336_i1) ∪ commonEnvelope childrenD_336_i1).erase (1, 5) := by + exact required_eq_combination childrenC_336_i1 childrenD_336_i1 (1, 5) required_336_i1 + (by decide +kernel) child_required_sub_336_i1 common_sub_336_i1 required_origin_336_i1 +theorem envelope_origin_336_i1 : ∀ x ∈ envelope_336_i1, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_336_i1 j := by decide +kernel +theorem envelope_exact_336_i1 : envelope_336_i1 = + insert (1, 5) (Finset.univ.biUnion childrenD_336_i1) := by + exact envelope_eq_combination childrenD_336_i1 (1, 5) envelope_336_i1 + pivot_mem_336_i1 child_envelope_sub_336_i1 envelope_origin_336_i1 +def checked_336_i1 : CheckedCard where + required := required_336_i1 + envelope := envelope_336_i1 + height := height_336_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_336_i1 +def height_336_i0 : ℕ := 5 +def childrenH_336_i0 : Fin 2 → ℕ := ![height_5, height_336_i1] +theorem height_exact_336_i0 : height_336_i0 = 1 + Finset.univ.sup childrenH_336_i0 := by decide +kernel +theorem required_origin_336_i0 : ∀ x ∈ required_336_i0, + (∃ j, x ∈ childrenC_336_i0 j) ∨ ∀ j, x ∈ childrenD_336_i0 j := by decide +kernel +theorem required_exact_336_i0 : required_336_i0 = + ((Finset.univ.biUnion childrenC_336_i0) ∪ commonEnvelope childrenD_336_i0).erase (2, 3) := by + exact required_eq_combination childrenC_336_i0 childrenD_336_i0 (2, 3) required_336_i0 + (by decide +kernel) child_required_sub_336_i0 common_sub_336_i0 required_origin_336_i0 +theorem envelope_origin_336_i0 : ∀ x ∈ envelope_336_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_336_i0 j := by decide +kernel +theorem envelope_exact_336_i0 : envelope_336_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_336_i0) := by + exact envelope_eq_combination childrenD_336_i0 (2, 3) envelope_336_i0 + pivot_mem_336_i0 child_envelope_sub_336_i0 envelope_origin_336_i0 +def checked_336_i0 : CheckedCard where + required := required_336_i0 + envelope := envelope_336_i0 + height := height_336_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_336_i0 +def height_336 : ℕ := 6 +def childrenH_336 : Fin 3 → ℕ := ![height_6, height_18, height_336_i0] +theorem height_exact_336 : height_336 = 1 + Finset.univ.sup childrenH_336 := by decide +kernel +theorem required_origin_336 : ∀ x ∈ required_336, + (∃ j, x ∈ childrenC_336 j) ∨ ∀ j, x ∈ childrenD_336 j := by decide +kernel +theorem required_exact_336 : required_336 = + ((Finset.univ.biUnion childrenC_336) ∪ commonEnvelope childrenD_336).erase (1, 4) := by + exact required_eq_combination childrenC_336 childrenD_336 (1, 4) required_336 + (by decide +kernel) child_required_sub_336 common_sub_336 required_origin_336 +theorem envelope_origin_336 : ∀ x ∈ envelope_336, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_336 j := by decide +kernel +theorem envelope_exact_336 : envelope_336 = + insert (1, 4) (Finset.univ.biUnion childrenD_336) := by + exact envelope_eq_combination childrenD_336 (1, 4) envelope_336 + pivot_mem_336 child_envelope_sub_336 envelope_origin_336 +def checked_336 : CheckedCard where + required := required_336 + envelope := envelope_336 + height := height_336 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_336 +def height_340_i0 : ℕ := 5 +def childrenH_340_i0 : Fin 2 → ℕ := ![height_5, height_91] +theorem height_exact_340_i0 : height_340_i0 = 1 + Finset.univ.sup childrenH_340_i0 := by decide +kernel +theorem required_origin_340_i0 : ∀ x ∈ required_340_i0, + (∃ j, x ∈ childrenC_340_i0 j) ∨ ∀ j, x ∈ childrenD_340_i0 j := by decide +kernel +theorem required_exact_340_i0 : required_340_i0 = + ((Finset.univ.biUnion childrenC_340_i0) ∪ commonEnvelope childrenD_340_i0).erase (1, 6) := by + exact required_eq_combination childrenC_340_i0 childrenD_340_i0 (1, 6) required_340_i0 + (by decide +kernel) child_required_sub_340_i0 common_sub_340_i0 required_origin_340_i0 +theorem envelope_origin_340_i0 : ∀ x ∈ envelope_340_i0, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_340_i0 j := by decide +kernel +theorem envelope_exact_340_i0 : envelope_340_i0 = + insert (1, 6) (Finset.univ.biUnion childrenD_340_i0) := by + exact envelope_eq_combination childrenD_340_i0 (1, 6) envelope_340_i0 + pivot_mem_340_i0 child_envelope_sub_340_i0 envelope_origin_340_i0 +def checked_340_i0 : CheckedCard where + required := required_340_i0 + envelope := envelope_340_i0 + height := height_340_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_340_i0 +def height_340 : ℕ := 6 +def childrenH_340 : Fin 3 → ℕ := ![height_139, height_148, height_340_i0] +theorem height_exact_340 : height_340 = 1 + Finset.univ.sup childrenH_340 := by decide +kernel +theorem required_origin_340 : ∀ x ∈ required_340, + (∃ j, x ∈ childrenC_340 j) ∨ ∀ j, x ∈ childrenD_340 j := by decide +kernel +theorem required_exact_340 : required_340 = + ((Finset.univ.biUnion childrenC_340) ∪ commonEnvelope childrenD_340).erase (0, 6) := by + exact required_eq_combination childrenC_340 childrenD_340 (0, 6) required_340 + (by decide +kernel) child_required_sub_340 common_sub_340 required_origin_340 +theorem envelope_origin_340 : ∀ x ∈ envelope_340, + x = (0, 6) ∨ ∃ j, x ∈ childrenD_340 j := by decide +kernel +theorem envelope_exact_340 : envelope_340 = + insert (0, 6) (Finset.univ.biUnion childrenD_340) := by + exact envelope_eq_combination childrenD_340 (0, 6) envelope_340 + pivot_mem_340 child_envelope_sub_340 envelope_origin_340 +def checked_340 : CheckedCard where + required := required_340 + envelope := envelope_340 + height := height_340 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_340 +def height_343 : ℕ := 6 +def childrenH_343 : Fin 2 → ℕ := ![height_5, height_342] +theorem height_exact_343 : height_343 = 1 + Finset.univ.sup childrenH_343 := by decide +kernel +theorem required_origin_343 : ∀ x ∈ required_343, + (∃ j, x ∈ childrenC_343 j) ∨ ∀ j, x ∈ childrenD_343 j := by decide +kernel +theorem required_exact_343 : required_343 = + ((Finset.univ.biUnion childrenC_343) ∪ commonEnvelope childrenD_343).erase (3, 3) := by + exact required_eq_combination childrenC_343 childrenD_343 (3, 3) required_343 + (by decide +kernel) child_required_sub_343 common_sub_343 required_origin_343 +theorem envelope_origin_343 : ∀ x ∈ envelope_343, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_343 j := by decide +kernel +theorem envelope_exact_343 : envelope_343 = + insert (3, 3) (Finset.univ.biUnion childrenD_343) := by + exact envelope_eq_combination childrenD_343 (3, 3) envelope_343 + pivot_mem_343 child_envelope_sub_343 envelope_origin_343 +def checked_343 : CheckedCard where + required := required_343 + envelope := envelope_343 + height := height_343 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_343 +def height_346 : ℕ := 6 +def childrenH_346 : Fin 2 → ℕ := ![height_0, height_342] +theorem height_exact_346 : height_346 = 1 + Finset.univ.sup childrenH_346 := by decide +kernel +theorem required_origin_346 : ∀ x ∈ required_346, + (∃ j, x ∈ childrenC_346 j) ∨ ∀ j, x ∈ childrenD_346 j := by decide +kernel +theorem required_exact_346 : required_346 = + ((Finset.univ.biUnion childrenC_346) ∪ commonEnvelope childrenD_346).erase (2, 3) := by + exact required_eq_combination childrenC_346 childrenD_346 (2, 3) required_346 + (by decide +kernel) child_required_sub_346 common_sub_346 required_origin_346 +theorem envelope_origin_346 : ∀ x ∈ envelope_346, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_346 j := by decide +kernel +theorem envelope_exact_346 : envelope_346 = + insert (2, 3) (Finset.univ.biUnion childrenD_346) := by + exact envelope_eq_combination childrenD_346 (2, 3) envelope_346 + pivot_mem_346 child_envelope_sub_346 envelope_origin_346 +def checked_346 : CheckedCard where + required := required_346 + envelope := envelope_346 + height := height_346 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_346 +def height_348_i0 : ℕ := 5 +def childrenH_348_i0 : Fin 2 → ℕ := ![height_5, height_311] +theorem height_exact_348_i0 : height_348_i0 = 1 + Finset.univ.sup childrenH_348_i0 := by decide +kernel +theorem required_origin_348_i0 : ∀ x ∈ required_348_i0, + (∃ j, x ∈ childrenC_348_i0 j) ∨ ∀ j, x ∈ childrenD_348_i0 j := by decide +kernel +theorem required_exact_348_i0 : required_348_i0 = + ((Finset.univ.biUnion childrenC_348_i0) ∪ commonEnvelope childrenD_348_i0).erase (3, 0) := by + exact required_eq_combination childrenC_348_i0 childrenD_348_i0 (3, 0) required_348_i0 + (by decide +kernel) child_required_sub_348_i0 common_sub_348_i0 required_origin_348_i0 +theorem envelope_origin_348_i0 : ∀ x ∈ envelope_348_i0, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_348_i0 j := by decide +kernel +theorem envelope_exact_348_i0 : envelope_348_i0 = + insert (3, 0) (Finset.univ.biUnion childrenD_348_i0) := by + exact envelope_eq_combination childrenD_348_i0 (3, 0) envelope_348_i0 + pivot_mem_348_i0 child_envelope_sub_348_i0 envelope_origin_348_i0 +def checked_348_i0 : CheckedCard where + required := required_348_i0 + envelope := envelope_348_i0 + height := height_348_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_348_i0 +def height_348 : ℕ := 6 +def childrenH_348 : Fin 2 → ℕ := ![height_5, height_348_i0] +theorem height_exact_348 : height_348 = 1 + Finset.univ.sup childrenH_348 := by decide +kernel +theorem required_origin_348 : ∀ x ∈ required_348, + (∃ j, x ∈ childrenC_348 j) ∨ ∀ j, x ∈ childrenD_348 j := by decide +kernel +theorem required_exact_348 : required_348 = + ((Finset.univ.biUnion childrenC_348) ∪ commonEnvelope childrenD_348).erase (3, 1) := by + exact required_eq_combination childrenC_348 childrenD_348 (3, 1) required_348 + (by decide +kernel) child_required_sub_348 common_sub_348 required_origin_348 +theorem envelope_origin_348 : ∀ x ∈ envelope_348, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_348 j := by decide +kernel +theorem envelope_exact_348 : envelope_348 = + insert (3, 1) (Finset.univ.biUnion childrenD_348) := by + exact envelope_eq_combination childrenD_348 (3, 1) envelope_348 + pivot_mem_348 child_envelope_sub_348 envelope_origin_348 +def checked_348 : CheckedCard where + required := required_348 + envelope := envelope_348 + height := height_348 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_348 +def height_349_i0 : ℕ := 5 +def childrenH_349_i0 : Fin 2 → ℕ := ![height_10, height_54] +theorem height_exact_349_i0 : height_349_i0 = 1 + Finset.univ.sup childrenH_349_i0 := by decide +kernel +theorem required_origin_349_i0 : ∀ x ∈ required_349_i0, + (∃ j, x ∈ childrenC_349_i0 j) ∨ ∀ j, x ∈ childrenD_349_i0 j := by decide +kernel +theorem required_exact_349_i0 : required_349_i0 = + ((Finset.univ.biUnion childrenC_349_i0) ∪ commonEnvelope childrenD_349_i0).erase (4, 3) := by + exact required_eq_combination childrenC_349_i0 childrenD_349_i0 (4, 3) required_349_i0 + (by decide +kernel) child_required_sub_349_i0 common_sub_349_i0 required_origin_349_i0 +theorem envelope_origin_349_i0 : ∀ x ∈ envelope_349_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_349_i0 j := by decide +kernel +theorem envelope_exact_349_i0 : envelope_349_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_349_i0) := by + exact envelope_eq_combination childrenD_349_i0 (4, 3) envelope_349_i0 + pivot_mem_349_i0 child_envelope_sub_349_i0 envelope_origin_349_i0 +def checked_349_i0 : CheckedCard where + required := required_349_i0 + envelope := envelope_349_i0 + height := height_349_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_349_i0 +def height_349 : ℕ := 6 +def childrenH_349 : Fin 4 → ℕ := ![height_12, height_165, height_216, height_349_i0] +theorem height_exact_349 : height_349 = 1 + Finset.univ.sup childrenH_349 := by decide +kernel +theorem required_origin_349 : ∀ x ∈ required_349, + (∃ j, x ∈ childrenC_349 j) ∨ ∀ j, x ∈ childrenD_349 j := by decide +kernel +theorem required_exact_349 : required_349 = + ((Finset.univ.biUnion childrenC_349) ∪ commonEnvelope childrenD_349).erase (3, 5) := by + exact required_eq_combination childrenC_349 childrenD_349 (3, 5) required_349 + (by decide +kernel) child_required_sub_349 common_sub_349 required_origin_349 +theorem envelope_origin_349 : ∀ x ∈ envelope_349, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_349 j := by decide +kernel +theorem envelope_exact_349 : envelope_349 = + insert (3, 5) (Finset.univ.biUnion childrenD_349) := by + exact envelope_eq_combination childrenD_349 (3, 5) envelope_349 + pivot_mem_349 child_envelope_sub_349 envelope_origin_349 +def checked_349 : CheckedCard where + required := required_349 + envelope := envelope_349 + height := height_349 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_349 +def height_358 : ℕ := 6 +def childrenH_358 : Fin 2 → ℕ := ![height_5, height_357] +theorem height_exact_358 : height_358 = 1 + Finset.univ.sup childrenH_358 := by decide +kernel +theorem required_origin_358 : ∀ x ∈ required_358, + (∃ j, x ∈ childrenC_358 j) ∨ ∀ j, x ∈ childrenD_358 j := by decide +kernel +theorem required_exact_358 : required_358 = + ((Finset.univ.biUnion childrenC_358) ∪ commonEnvelope childrenD_358).erase (2, 4) := by + exact required_eq_combination childrenC_358 childrenD_358 (2, 4) required_358 + (by decide +kernel) child_required_sub_358 common_sub_358 required_origin_358 +theorem envelope_origin_358 : ∀ x ∈ envelope_358, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_358 j := by decide +kernel +theorem envelope_exact_358 : envelope_358 = + insert (2, 4) (Finset.univ.biUnion childrenD_358) := by + exact envelope_eq_combination childrenD_358 (2, 4) envelope_358 + pivot_mem_358 child_envelope_sub_358 envelope_origin_358 +def checked_358 : CheckedCard where + required := required_358 + envelope := envelope_358 + height := height_358 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_358 +def height_360_i0 : ℕ := 4 +def childrenH_360_i0 : Fin 2 → ℕ := ![height_5, height_45] +theorem height_exact_360_i0 : height_360_i0 = 1 + Finset.univ.sup childrenH_360_i0 := by decide +kernel +theorem required_origin_360_i0 : ∀ x ∈ required_360_i0, + (∃ j, x ∈ childrenC_360_i0 j) ∨ ∀ j, x ∈ childrenD_360_i0 j := by decide +kernel +theorem required_exact_360_i0 : required_360_i0 = + ((Finset.univ.biUnion childrenC_360_i0) ∪ commonEnvelope childrenD_360_i0).erase (2, 3) := by + exact required_eq_combination childrenC_360_i0 childrenD_360_i0 (2, 3) required_360_i0 + (by decide +kernel) child_required_sub_360_i0 common_sub_360_i0 required_origin_360_i0 +theorem envelope_origin_360_i0 : ∀ x ∈ envelope_360_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_360_i0 j := by decide +kernel +theorem envelope_exact_360_i0 : envelope_360_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_360_i0) := by + exact envelope_eq_combination childrenD_360_i0 (2, 3) envelope_360_i0 + pivot_mem_360_i0 child_envelope_sub_360_i0 envelope_origin_360_i0 +def checked_360_i0 : CheckedCard where + required := required_360_i0 + envelope := envelope_360_i0 + height := height_360_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_360_i0 +def height_360 : ℕ := 6 +def childrenH_360 : Fin 3 → ℕ := ![height_22, height_347, height_360_i0] +theorem height_exact_360 : height_360 = 1 + Finset.univ.sup childrenH_360 := by decide +kernel +theorem required_origin_360 : ∀ x ∈ required_360, + (∃ j, x ∈ childrenC_360 j) ∨ ∀ j, x ∈ childrenD_360 j := by decide +kernel +theorem required_exact_360 : required_360 = + ((Finset.univ.biUnion childrenC_360) ∪ commonEnvelope childrenD_360).erase (2, 4) := by + exact required_eq_combination childrenC_360 childrenD_360 (2, 4) required_360 + (by decide +kernel) child_required_sub_360 common_sub_360 required_origin_360 +theorem envelope_origin_360 : ∀ x ∈ envelope_360, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_360 j := by decide +kernel +theorem envelope_exact_360 : envelope_360 = + insert (2, 4) (Finset.univ.biUnion childrenD_360) := by + exact envelope_eq_combination childrenD_360 (2, 4) envelope_360 + pivot_mem_360 child_envelope_sub_360 envelope_origin_360 +def checked_360 : CheckedCard where + required := required_360 + envelope := envelope_360 + height := height_360 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_360 +def height_363 : ℕ := 6 +def childrenH_363 : Fin 2 → ℕ := ![height_44, height_362] +theorem height_exact_363 : height_363 = 1 + Finset.univ.sup childrenH_363 := by decide +kernel +theorem required_origin_363 : ∀ x ∈ required_363, + (∃ j, x ∈ childrenC_363 j) ∨ ∀ j, x ∈ childrenD_363 j := by decide +kernel +theorem required_exact_363 : required_363 = + ((Finset.univ.biUnion childrenC_363) ∪ commonEnvelope childrenD_363).erase (4, 4) := by + exact required_eq_combination childrenC_363 childrenD_363 (4, 4) required_363 + (by decide +kernel) child_required_sub_363 common_sub_363 required_origin_363 +theorem envelope_origin_363 : ∀ x ∈ envelope_363, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_363 j := by decide +kernel +theorem envelope_exact_363 : envelope_363 = + insert (4, 4) (Finset.univ.biUnion childrenD_363) := by + exact envelope_eq_combination childrenD_363 (4, 4) envelope_363 + pivot_mem_363 child_envelope_sub_363 envelope_origin_363 +def checked_363 : CheckedCard where + required := required_363 + envelope := envelope_363 + height := height_363 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_363 +def height_364 : ℕ := 6 +def childrenH_364 : Fin 2 → ℕ := ![height_52, height_362] +theorem height_exact_364 : height_364 = 1 + Finset.univ.sup childrenH_364 := by decide +kernel +theorem required_origin_364 : ∀ x ∈ required_364, + (∃ j, x ∈ childrenC_364 j) ∨ ∀ j, x ∈ childrenD_364 j := by decide +kernel +theorem required_exact_364 : required_364 = + ((Finset.univ.biUnion childrenC_364) ∪ commonEnvelope childrenD_364).erase (4, 4) := by + exact required_eq_combination childrenC_364 childrenD_364 (4, 4) required_364 + (by decide +kernel) child_required_sub_364 common_sub_364 required_origin_364 +theorem envelope_origin_364 : ∀ x ∈ envelope_364, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_364 j := by decide +kernel +theorem envelope_exact_364 : envelope_364 = + insert (4, 4) (Finset.univ.biUnion childrenD_364) := by + exact envelope_eq_combination childrenD_364 (4, 4) envelope_364 + pivot_mem_364 child_envelope_sub_364 envelope_origin_364 +def checked_364 : CheckedCard where + required := required_364 + envelope := envelope_364 + height := height_364 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_364 +def height_367 : ℕ := 6 +def childrenH_367 : Fin 3 → ℕ := ![height_8, height_9, height_366] +theorem height_exact_367 : height_367 = 1 + Finset.univ.sup childrenH_367 := by decide +kernel +theorem required_origin_367 : ∀ x ∈ required_367, + (∃ j, x ∈ childrenC_367 j) ∨ ∀ j, x ∈ childrenD_367 j := by decide +kernel +theorem required_exact_367 : required_367 = + ((Finset.univ.biUnion childrenC_367) ∪ commonEnvelope childrenD_367).erase (1, 5) := by + exact required_eq_combination childrenC_367 childrenD_367 (1, 5) required_367 + (by decide +kernel) child_required_sub_367 common_sub_367 required_origin_367 +theorem envelope_origin_367 : ∀ x ∈ envelope_367, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_367 j := by decide +kernel +theorem envelope_exact_367 : envelope_367 = + insert (1, 5) (Finset.univ.biUnion childrenD_367) := by + exact envelope_eq_combination childrenD_367 (1, 5) envelope_367 + pivot_mem_367 child_envelope_sub_367 envelope_origin_367 +def checked_367 : CheckedCard where + required := required_367 + envelope := envelope_367 + height := height_367 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_367 +def height_369_i0 : ℕ := 5 +def childrenH_369_i0 : Fin 3 → ℕ := ![height_6, height_8, height_365] +theorem height_exact_369_i0 : height_369_i0 = 1 + Finset.univ.sup childrenH_369_i0 := by decide +kernel +theorem required_origin_369_i0 : ∀ x ∈ required_369_i0, + (∃ j, x ∈ childrenC_369_i0 j) ∨ ∀ j, x ∈ childrenD_369_i0 j := by decide +kernel +theorem required_exact_369_i0 : required_369_i0 = + ((Finset.univ.biUnion childrenC_369_i0) ∪ commonEnvelope childrenD_369_i0).erase (1, 7) := by + exact required_eq_combination childrenC_369_i0 childrenD_369_i0 (1, 7) required_369_i0 + (by decide +kernel) child_required_sub_369_i0 common_sub_369_i0 required_origin_369_i0 +theorem envelope_origin_369_i0 : ∀ x ∈ envelope_369_i0, + x = (1, 7) ∨ ∃ j, x ∈ childrenD_369_i0 j := by decide +kernel +theorem envelope_exact_369_i0 : envelope_369_i0 = + insert (1, 7) (Finset.univ.biUnion childrenD_369_i0) := by + exact envelope_eq_combination childrenD_369_i0 (1, 7) envelope_369_i0 + pivot_mem_369_i0 child_envelope_sub_369_i0 envelope_origin_369_i0 +def checked_369_i0 : CheckedCard where + required := required_369_i0 + envelope := envelope_369_i0 + height := height_369_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_369_i0 +def height_369 : ℕ := 6 +def childrenH_369 : Fin 4 → ℕ := ![height_7, height_19, height_187, height_369_i0] +theorem height_exact_369 : height_369 = 1 + Finset.univ.sup childrenH_369 := by decide +kernel +theorem required_origin_369 : ∀ x ∈ required_369, + (∃ j, x ∈ childrenC_369 j) ∨ ∀ j, x ∈ childrenD_369 j := by decide +kernel +theorem required_exact_369 : required_369 = + ((Finset.univ.biUnion childrenC_369) ∪ commonEnvelope childrenD_369).erase (1, 6) := by + exact required_eq_combination childrenC_369 childrenD_369 (1, 6) required_369 + (by decide +kernel) child_required_sub_369 common_sub_369 required_origin_369 +theorem envelope_origin_369 : ∀ x ∈ envelope_369, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_369 j := by decide +kernel +theorem envelope_exact_369 : envelope_369 = + insert (1, 6) (Finset.univ.biUnion childrenD_369) := by + exact envelope_eq_combination childrenD_369 (1, 6) envelope_369 + pivot_mem_369 child_envelope_sub_369 envelope_origin_369 +def checked_369 : CheckedCard where + required := required_369 + envelope := envelope_369 + height := height_369 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_369 +def height_371_i2 : ℕ := 2 +def childrenH_371_i2 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_371_i2 : height_371_i2 = 1 + Finset.univ.sup childrenH_371_i2 := by decide +kernel +theorem required_origin_371_i2 : ∀ x ∈ required_371_i2, + (∃ j, x ∈ childrenC_371_i2 j) ∨ ∀ j, x ∈ childrenD_371_i2 j := by decide +kernel +theorem required_exact_371_i2 : required_371_i2 = + ((Finset.univ.biUnion childrenC_371_i2) ∪ commonEnvelope childrenD_371_i2).erase (3, 2) := by + exact required_eq_combination childrenC_371_i2 childrenD_371_i2 (3, 2) required_371_i2 + (by decide +kernel) child_required_sub_371_i2 common_sub_371_i2 required_origin_371_i2 +theorem envelope_origin_371_i2 : ∀ x ∈ envelope_371_i2, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_371_i2 j := by decide +kernel +theorem envelope_exact_371_i2 : envelope_371_i2 = + insert (3, 2) (Finset.univ.biUnion childrenD_371_i2) := by + exact envelope_eq_combination childrenD_371_i2 (3, 2) envelope_371_i2 + pivot_mem_371_i2 child_envelope_sub_371_i2 envelope_origin_371_i2 +def checked_371_i2 : CheckedCard where + required := required_371_i2 + envelope := envelope_371_i2 + height := height_371_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_371_i2 +def height_371_i1 : ℕ := 3 +def childrenH_371_i1 : Fin 2 → ℕ := ![height_210, height_371_i2] +theorem height_exact_371_i1 : height_371_i1 = 1 + Finset.univ.sup childrenH_371_i1 := by decide +kernel +theorem required_origin_371_i1 : ∀ x ∈ required_371_i1, + (∃ j, x ∈ childrenC_371_i1 j) ∨ ∀ j, x ∈ childrenD_371_i1 j := by decide +kernel +theorem required_exact_371_i1 : required_371_i1 = + ((Finset.univ.biUnion childrenC_371_i1) ∪ commonEnvelope childrenD_371_i1).erase (2, 2) := by + exact required_eq_combination childrenC_371_i1 childrenD_371_i1 (2, 2) required_371_i1 + (by decide +kernel) child_required_sub_371_i1 common_sub_371_i1 required_origin_371_i1 +theorem envelope_origin_371_i1 : ∀ x ∈ envelope_371_i1, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_371_i1 j := by decide +kernel +theorem envelope_exact_371_i1 : envelope_371_i1 = + insert (2, 2) (Finset.univ.biUnion childrenD_371_i1) := by + exact envelope_eq_combination childrenD_371_i1 (2, 2) envelope_371_i1 + pivot_mem_371_i1 child_envelope_sub_371_i1 envelope_origin_371_i1 +def checked_371_i1 : CheckedCard where + required := required_371_i1 + envelope := envelope_371_i1 + height := height_371_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_371_i1 +def height_371_i0 : ℕ := 4 +def childrenH_371_i0 : Fin 2 → ℕ := ![height_6, height_371_i1] +theorem height_exact_371_i0 : height_371_i0 = 1 + Finset.univ.sup childrenH_371_i0 := by decide +kernel +theorem required_origin_371_i0 : ∀ x ∈ required_371_i0, + (∃ j, x ∈ childrenC_371_i0 j) ∨ ∀ j, x ∈ childrenD_371_i0 j := by decide +kernel +theorem required_exact_371_i0 : required_371_i0 = + ((Finset.univ.biUnion childrenC_371_i0) ∪ commonEnvelope childrenD_371_i0).erase (5, 1) := by + exact required_eq_combination childrenC_371_i0 childrenD_371_i0 (5, 1) required_371_i0 + (by decide +kernel) child_required_sub_371_i0 common_sub_371_i0 required_origin_371_i0 +theorem envelope_origin_371_i0 : ∀ x ∈ envelope_371_i0, + x = (5, 1) ∨ ∃ j, x ∈ childrenD_371_i0 j := by decide +kernel +theorem envelope_exact_371_i0 : envelope_371_i0 = + insert (5, 1) (Finset.univ.biUnion childrenD_371_i0) := by + exact envelope_eq_combination childrenD_371_i0 (5, 1) envelope_371_i0 + pivot_mem_371_i0 child_envelope_sub_371_i0 envelope_origin_371_i0 +def checked_371_i0 : CheckedCard where + required := required_371_i0 + envelope := envelope_371_i0 + height := height_371_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_371_i0 +def height_371 : ℕ := 6 +def childrenH_371 : Fin 4 → ℕ := ![height_6, height_8, height_370, height_371_i0] +theorem height_exact_371 : height_371 = 1 + Finset.univ.sup childrenH_371 := by decide +kernel +theorem required_origin_371 : ∀ x ∈ required_371, + (∃ j, x ∈ childrenC_371 j) ∨ ∀ j, x ∈ childrenD_371 j := by decide +kernel +theorem required_exact_371 : required_371 = + ((Finset.univ.biUnion childrenC_371) ∪ commonEnvelope childrenD_371).erase (4, 1) := by + exact required_eq_combination childrenC_371 childrenD_371 (4, 1) required_371 + (by decide +kernel) child_required_sub_371 common_sub_371 required_origin_371 +theorem envelope_origin_371 : ∀ x ∈ envelope_371, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_371 j := by decide +kernel +theorem envelope_exact_371 : envelope_371 = + insert (4, 1) (Finset.univ.biUnion childrenD_371) := by + exact envelope_eq_combination childrenD_371 (4, 1) envelope_371 + pivot_mem_371 child_envelope_sub_371 envelope_origin_371 +def checked_371 : CheckedCard where + required := required_371 + envelope := envelope_371 + height := height_371 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_371 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part04.lean new file mode 100644 index 0000000..9cc3010 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part04.lean @@ -0,0 +1,852 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_378_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 2), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_378_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_378_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), (placed21 0 (2, 0) required_18)] +def childrenD_378_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), (placed21 0 (2, 0) envelope_18)] +theorem common_sub_378_i0 : commonEnvelope childrenD_378_i0 ⊆ insert (3, 3) required_378_i0 := by decide +kernel +theorem child_required_sub_378_i0 : ∀ j, childrenC_378_i0 j ⊆ insert (3, 3) required_378_i0 := by decide +kernel +theorem child_envelope_sub_378_i0 : ∀ j, childrenD_378_i0 j ⊆ envelope_378_i0 := by decide +kernel +theorem pivot_mem_378_i0 : (3, 3) ∈ envelope_378_i0 := by decide +kernel +theorem children_work_378_i0 : ∀ j, Template HasSnaky 4 (childrenC_378_i0 j) (childrenD_378_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_18 0 (2, 0)).mono (by decide +kernel) +theorem row_works_378_i0 : Template HasSnaky 5 required_378_i0 envelope_378_i0 := by + refine compose HasSnaky 4 childrenC_378_i0 childrenD_378_i0 children_work_378_i0 (3, 3) + required_378_i0 envelope_378_i0 pivot_mem_378_i0 child_required_sub_378_i0 child_envelope_sub_378_i0 ?_ + intro b hb + exact common_sub_378_i0 (mem_commonEnvelope childrenD_378_i0 b hb) +def required_378 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_378 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_378 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_5), required_378_i0] +def childrenD_378 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_5), envelope_378_i0] +theorem common_sub_378 : commonEnvelope childrenD_378 ⊆ insert (3, 1) required_378 := by decide +kernel +theorem child_required_sub_378 : ∀ j, childrenC_378 j ⊆ insert (3, 1) required_378 := by decide +kernel +theorem child_envelope_sub_378 : ∀ j, childrenD_378 j ⊆ envelope_378 := by decide +kernel +theorem pivot_mem_378 : (3, 1) ∈ envelope_378 := by decide +kernel +theorem children_work_378 : ∀ j, Template HasSnaky 5 (childrenC_378 j) (childrenD_378 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact row_works_378_i0.mono (by decide +kernel) +theorem row_works_378 : Template HasSnaky 6 required_378 envelope_378 := by + refine compose HasSnaky 5 childrenC_378 childrenD_378 children_work_378 (3, 1) + required_378 envelope_378 pivot_mem_378 child_required_sub_378 child_envelope_sub_378 ?_ + intro b hb + exact common_sub_378 (mem_commonEnvelope childrenD_378 b hb) +def required_384 : Finset Cell := ⟨(([(0, 2), (3, 1), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_384 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_384 : Fin 2 → Finset Cell := ![(placed21 1 (2, 1) required_8), (placed21 7 (5, 4) required_383)] +def childrenD_384 : Fin 2 → Finset Cell := ![(placed21 1 (2, 1) envelope_8), (placed21 7 (5, 4) envelope_383)] +theorem common_sub_384 : commonEnvelope childrenD_384 ⊆ insert (3, 3) required_384 := by decide +kernel +theorem child_required_sub_384 : ∀ j, childrenC_384 j ⊆ insert (3, 3) required_384 := by decide +kernel +theorem child_envelope_sub_384 : ∀ j, childrenD_384 j ⊆ envelope_384 := by decide +kernel +theorem pivot_mem_384 : (3, 3) ∈ envelope_384 := by decide +kernel +theorem children_work_384 : ∀ j, Template HasSnaky 5 (childrenC_384 j) (childrenD_384 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_383 7 (5, 4)).mono (by decide +kernel) +theorem row_works_384 : Template HasSnaky 6 required_384 envelope_384 := by + refine compose HasSnaky 5 childrenC_384 childrenD_384 children_work_384 (3, 3) + required_384 envelope_384 pivot_mem_384 child_required_sub_384 child_envelope_sub_384 ?_ + intro b hb + exact common_sub_384 (mem_commonEnvelope childrenD_384 b hb) +def required_387 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_387 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_387 : Fin 3 → Finset Cell := ![(placed21 1 (0, 1) required_200), (placed21 1 (1, 0) required_376), (placed21 1 (0, 0) required_386)] +def childrenD_387 : Fin 3 → Finset Cell := ![(placed21 1 (0, 1) envelope_200), (placed21 1 (1, 0) envelope_376), (placed21 1 (0, 0) envelope_386)] +theorem common_sub_387 : commonEnvelope childrenD_387 ⊆ insert (4, 2) required_387 := by decide +kernel +theorem child_required_sub_387 : ∀ j, childrenC_387 j ⊆ insert (4, 2) required_387 := by decide +kernel +theorem child_envelope_sub_387 : ∀ j, childrenD_387 j ⊆ envelope_387 := by decide +kernel +theorem pivot_mem_387 : (4, 2) ∈ envelope_387 := by decide +kernel +theorem children_work_387 : ∀ j, Template HasSnaky 5 (childrenC_387 j) (childrenD_387 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_200 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_376 1 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_386 1 (0, 0)).mono (by decide +kernel) +theorem row_works_387 : Template HasSnaky 6 required_387 envelope_387 := by + refine compose HasSnaky 5 childrenC_387 childrenD_387 children_work_387 (4, 2) + required_387 envelope_387 pivot_mem_387 child_required_sub_387 child_envelope_sub_387 ?_ + intro b hb + exact common_sub_387 (mem_commonEnvelope childrenD_387 b hb) +def required_390 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_390 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 8), (0, 9), (0, 10), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_390 : Fin 3 → Finset Cell := ![(placed21 2 (1, 3) required_11), (placed21 0 (0, 4) required_17), (placed21 6 (1, 7) required_389)] +def childrenD_390 : Fin 3 → Finset Cell := ![(placed21 2 (1, 3) envelope_11), (placed21 0 (0, 4) envelope_17), (placed21 6 (1, 7) envelope_389)] +theorem common_sub_390 : commonEnvelope childrenD_390 ⊆ insert (1, 7) required_390 := by decide +kernel +theorem child_required_sub_390 : ∀ j, childrenC_390 j ⊆ insert (1, 7) required_390 := by decide +kernel +theorem child_envelope_sub_390 : ∀ j, childrenD_390 j ⊆ envelope_390 := by decide +kernel +theorem pivot_mem_390 : (1, 7) ∈ envelope_390 := by decide +kernel +theorem children_work_390 : ∀ j, Template HasSnaky 5 (childrenC_390 j) (childrenD_390 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 2 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_17 0 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_389 6 (1, 7)).mono (by decide +kernel) +theorem row_works_390 : Template HasSnaky 6 required_390 envelope_390 := by + refine compose HasSnaky 5 childrenC_390 childrenD_390 children_work_390 (1, 7) + required_390 envelope_390 pivot_mem_390 child_required_sub_390 child_envelope_sub_390 ?_ + intro b hb + exact common_sub_390 (mem_commonEnvelope childrenD_390 b hb) +def required_392 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_392 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_392 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_0), required_391] +def childrenD_392 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_0), envelope_391] +theorem common_sub_392 : commonEnvelope childrenD_392 ⊆ insert (3, 3) required_392 := by decide +kernel +theorem child_required_sub_392 : ∀ j, childrenC_392 j ⊆ insert (3, 3) required_392 := by decide +kernel +theorem child_envelope_sub_392 : ∀ j, childrenD_392 j ⊆ envelope_392 := by decide +kernel +theorem pivot_mem_392 : (3, 3) ∈ envelope_392 := by decide +kernel +theorem children_work_392 : ∀ j, Template HasSnaky 5 (childrenC_392 j) (childrenD_392 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact row_works_391.mono (by decide +kernel) +theorem row_works_392 : Template HasSnaky 6 required_392 envelope_392 := by + refine compose HasSnaky 5 childrenC_392 childrenD_392 children_work_392 (3, 3) + required_392 envelope_392 pivot_mem_392 child_required_sub_392 child_envelope_sub_392 ?_ + intro b hb + exact common_sub_392 (mem_commonEnvelope childrenD_392 b hb) +def required_393 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_393 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_393 : Fin 3 → Finset Cell := ![(placed21 0 (1, 0) required_11), (placed21 0 (0, 1) required_20), (placed21 4 (0, 5) required_391)] +def childrenD_393 : Fin 3 → Finset Cell := ![(placed21 0 (1, 0) envelope_11), (placed21 0 (0, 1) envelope_20), (placed21 4 (0, 5) envelope_391)] +theorem common_sub_393 : commonEnvelope childrenD_393 ⊆ insert (1, 4) required_393 := by decide +kernel +theorem child_required_sub_393 : ∀ j, childrenC_393 j ⊆ insert (1, 4) required_393 := by decide +kernel +theorem child_envelope_sub_393 : ∀ j, childrenD_393 j ⊆ envelope_393 := by decide +kernel +theorem pivot_mem_393 : (1, 4) ∈ envelope_393 := by decide +kernel +theorem children_work_393 : ∀ j, Template HasSnaky 5 (childrenC_393 j) (childrenD_393 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_20 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_391 4 (0, 5)).mono (by decide +kernel) +theorem row_works_393 : Template HasSnaky 6 required_393 envelope_393 := by + refine compose HasSnaky 5 childrenC_393 childrenD_393 children_work_393 (1, 4) + required_393 envelope_393 pivot_mem_393 child_required_sub_393 child_envelope_sub_393 ?_ + intro b hb + exact common_sub_393 (mem_commonEnvelope childrenD_393 b hb) +def required_403_i0 : Finset Cell := ⟨(([(1, 5), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_403_i0 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_403_i0 : Fin 2 → Finset Cell := ![(placed21 5 (3, 1) required_4), (placed21 5 (4, 2) required_381)] +def childrenD_403_i0 : Fin 2 → Finset Cell := ![(placed21 5 (3, 1) envelope_4), (placed21 5 (4, 2) envelope_381)] +theorem common_sub_403_i0 : commonEnvelope childrenD_403_i0 ⊆ insert (2, 5) required_403_i0 := by decide +kernel +theorem child_required_sub_403_i0 : ∀ j, childrenC_403_i0 j ⊆ insert (2, 5) required_403_i0 := by decide +kernel +theorem child_envelope_sub_403_i0 : ∀ j, childrenD_403_i0 j ⊆ envelope_403_i0 := by decide +kernel +theorem pivot_mem_403_i0 : (2, 5) ∈ envelope_403_i0 := by decide +kernel +theorem children_work_403_i0 : ∀ j, Template HasSnaky 4 (childrenC_403_i0 j) (childrenD_403_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 5 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_381 5 (4, 2)).mono (by decide +kernel) +theorem row_works_403_i0 : Template HasSnaky 5 required_403_i0 envelope_403_i0 := by + refine compose HasSnaky 4 childrenC_403_i0 childrenD_403_i0 children_work_403_i0 (2, 5) + required_403_i0 envelope_403_i0 pivot_mem_403_i0 child_required_sub_403_i0 child_envelope_sub_403_i0 ?_ + intro b hb + exact common_sub_403_i0 (mem_commonEnvelope childrenD_403_i0 b hb) +def required_403 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_403 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_403 : Fin 2 → Finset Cell := ![required_86, required_403_i0] +def childrenD_403 : Fin 2 → Finset Cell := ![envelope_86, envelope_403_i0] +theorem common_sub_403 : commonEnvelope childrenD_403 ⊆ insert (1, 5) required_403 := by decide +kernel +theorem child_required_sub_403 : ∀ j, childrenC_403 j ⊆ insert (1, 5) required_403 := by decide +kernel +theorem child_envelope_sub_403 : ∀ j, childrenD_403 j ⊆ envelope_403 := by decide +kernel +theorem pivot_mem_403 : (1, 5) ∈ envelope_403 := by decide +kernel +theorem children_work_403 : ∀ j, Template HasSnaky 5 (childrenC_403 j) (childrenD_403 j) := by + intro j + fin_cases j + · exact row_works_86.mono (by decide +kernel) + · exact row_works_403_i0.mono (by decide +kernel) +theorem row_works_403 : Template HasSnaky 6 required_403 envelope_403 := by + refine compose HasSnaky 5 childrenC_403 childrenD_403 children_work_403 (1, 5) + required_403 envelope_403 pivot_mem_403 child_required_sub_403 child_envelope_sub_403 ?_ + intro b hb + exact common_sub_403 (mem_commonEnvelope childrenD_403 b hb) +def required_414 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_414 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_414 : Fin 2 → Finset Cell := ![(placed21 3 (1, 5) required_0), required_413] +def childrenD_414 : Fin 2 → Finset Cell := ![(placed21 3 (1, 5) envelope_0), envelope_413] +theorem common_sub_414 : commonEnvelope childrenD_414 ⊆ insert (1, 4) required_414 := by decide +kernel +theorem child_required_sub_414 : ∀ j, childrenC_414 j ⊆ insert (1, 4) required_414 := by decide +kernel +theorem child_envelope_sub_414 : ∀ j, childrenD_414 j ⊆ envelope_414 := by decide +kernel +theorem pivot_mem_414 : (1, 4) ∈ envelope_414 := by decide +kernel +theorem children_work_414 : ∀ j, Template HasSnaky 5 (childrenC_414 j) (childrenD_414 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (1, 5)).mono (by decide +kernel) + · exact row_works_413.mono (by decide +kernel) +theorem row_works_414 : Template HasSnaky 6 required_414 envelope_414 := by + refine compose HasSnaky 5 childrenC_414 childrenD_414 children_work_414 (1, 4) + required_414 envelope_414 pivot_mem_414 child_required_sub_414 child_envelope_sub_414 ?_ + intro b hb + exact common_sub_414 (mem_commonEnvelope childrenD_414 b hb) +def required_417 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_417 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_417 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_0), required_416] +def childrenD_417 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_0), envelope_416] +theorem common_sub_417 : commonEnvelope childrenD_417 ⊆ insert (3, 2) required_417 := by decide +kernel +theorem child_required_sub_417 : ∀ j, childrenC_417 j ⊆ insert (3, 2) required_417 := by decide +kernel +theorem child_envelope_sub_417 : ∀ j, childrenD_417 j ⊆ envelope_417 := by decide +kernel +theorem pivot_mem_417 : (3, 2) ∈ envelope_417 := by decide +kernel +theorem children_work_417 : ∀ j, Template HasSnaky 5 (childrenC_417 j) (childrenD_417 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 2)).mono (by decide +kernel) + · exact row_works_416.mono (by decide +kernel) +theorem row_works_417 : Template HasSnaky 6 required_417 envelope_417 := by + refine compose HasSnaky 5 childrenC_417 childrenD_417 children_work_417 (3, 2) + required_417 envelope_417 pivot_mem_417 child_required_sub_417 child_envelope_sub_417 ?_ + intro b hb + exact common_sub_417 (mem_commonEnvelope childrenD_417 b hb) +def required_423_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_423_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_423_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_5), required_244] +def childrenD_423_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_5), envelope_244] +theorem common_sub_423_i0 : commonEnvelope childrenD_423_i0 ⊆ insert (1, 2) required_423_i0 := by decide +kernel +theorem child_required_sub_423_i0 : ∀ j, childrenC_423_i0 j ⊆ insert (1, 2) required_423_i0 := by decide +kernel +theorem child_envelope_sub_423_i0 : ∀ j, childrenD_423_i0 j ⊆ envelope_423_i0 := by decide +kernel +theorem pivot_mem_423_i0 : (1, 2) ∈ envelope_423_i0 := by decide +kernel +theorem children_work_423_i0 : ∀ j, Template HasSnaky 2 (childrenC_423_i0 j) (childrenD_423_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 3)).mono (by decide +kernel) + · exact row_works_244.mono (by decide +kernel) +theorem row_works_423_i0 : Template HasSnaky 3 required_423_i0 envelope_423_i0 := by + refine compose HasSnaky 2 childrenC_423_i0 childrenD_423_i0 children_work_423_i0 (1, 2) + required_423_i0 envelope_423_i0 pivot_mem_423_i0 child_required_sub_423_i0 child_envelope_sub_423_i0 ?_ + intro b hb + exact common_sub_423_i0 (mem_commonEnvelope childrenD_423_i0 b hb) +def required_423 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (3, 0), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_423 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (3, 0), (3, 1), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_423 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) required_383), required_423_i0] +def childrenD_423 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) envelope_383), envelope_423_i0] +theorem common_sub_423 : commonEnvelope childrenD_423 ⊆ insert (2, 3) required_423 := by decide +kernel +theorem child_required_sub_423 : ∀ j, childrenC_423 j ⊆ insert (2, 3) required_423 := by decide +kernel +theorem child_envelope_sub_423 : ∀ j, childrenD_423 j ⊆ envelope_423 := by decide +kernel +theorem pivot_mem_423 : (2, 3) ∈ envelope_423 := by decide +kernel +theorem children_work_423 : ∀ j, Template HasSnaky 5 (childrenC_423 j) (childrenD_423 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_383 4 (1, 5)).mono (by decide +kernel) + · exact row_works_423_i0.mono (by decide +kernel) +theorem row_works_423 : Template HasSnaky 6 required_423 envelope_423 := by + refine compose HasSnaky 5 childrenC_423 childrenD_423 children_work_423 (2, 3) + required_423 envelope_423 pivot_mem_423 child_required_sub_423 child_envelope_sub_423 ?_ + intro b hb + exact common_sub_423 (mem_commonEnvelope childrenD_423 b hb) +def required_429_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_429_i0 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 4), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_429_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_2), (placed21 5 (5, 1) required_46)] +def childrenD_429_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_2), (placed21 5 (5, 1) envelope_46)] +theorem common_sub_429_i0 : commonEnvelope childrenD_429_i0 ⊆ insert (4, 3) required_429_i0 := by decide +kernel +theorem child_required_sub_429_i0 : ∀ j, childrenC_429_i0 j ⊆ insert (4, 3) required_429_i0 := by decide +kernel +theorem child_envelope_sub_429_i0 : ∀ j, childrenD_429_i0 j ⊆ envelope_429_i0 := by decide +kernel +theorem pivot_mem_429_i0 : (4, 3) ∈ envelope_429_i0 := by decide +kernel +theorem children_work_429_i0 : ∀ j, Template HasSnaky 4 (childrenC_429_i0 j) (childrenD_429_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_46 5 (5, 1)).mono (by decide +kernel) +theorem row_works_429_i0 : Template HasSnaky 5 required_429_i0 envelope_429_i0 := by + refine compose HasSnaky 4 childrenC_429_i0 childrenD_429_i0 children_work_429_i0 (4, 3) + required_429_i0 envelope_429_i0 pivot_mem_429_i0 child_required_sub_429_i0 child_envelope_sub_429_i0 ?_ + intro b hb + exact common_sub_429_i0 (mem_commonEnvelope childrenD_429_i0 b hb) +def required_429 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_429 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_429 : Fin 4 → Finset Cell := ![(placed21 2 (3, 0) required_7), (placed21 1 (2, 1) required_8), (placed21 0 (2, 0) required_9), required_429_i0] +def childrenD_429 : Fin 4 → Finset Cell := ![(placed21 2 (3, 0) envelope_7), (placed21 1 (2, 1) envelope_8), (placed21 0 (2, 0) envelope_9), envelope_429_i0] +theorem common_sub_429 : commonEnvelope childrenD_429 ⊆ insert (3, 4) required_429 := by decide +kernel +theorem child_required_sub_429 : ∀ j, childrenC_429 j ⊆ insert (3, 4) required_429 := by decide +kernel +theorem child_envelope_sub_429 : ∀ j, childrenD_429 j ⊆ envelope_429 := by decide +kernel +theorem pivot_mem_429 : (3, 4) ∈ envelope_429 := by decide +kernel +theorem children_work_429 : ∀ j, Template HasSnaky 5 (childrenC_429 j) (childrenD_429 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 0 (2, 0)).mono (by decide +kernel) + · exact row_works_429_i0.mono (by decide +kernel) +theorem row_works_429 : Template HasSnaky 6 required_429 envelope_429 := by + refine compose HasSnaky 5 childrenC_429 childrenD_429 children_work_429 (3, 4) + required_429 envelope_429 pivot_mem_429 child_required_sub_429 child_envelope_sub_429 ?_ + intro b hb + exact common_sub_429 (mem_commonEnvelope childrenD_429 b hb) +def required_435_i1 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3), (3, 4), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_435_i1 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_435_i1 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_0), (placed21 2 (4, 1) required_212)] +def childrenD_435_i1 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_0), (placed21 2 (4, 1) envelope_212)] +theorem common_sub_435_i1 : commonEnvelope childrenD_435_i1 ⊆ insert (3, 2) required_435_i1 := by decide +kernel +theorem child_required_sub_435_i1 : ∀ j, childrenC_435_i1 j ⊆ insert (3, 2) required_435_i1 := by decide +kernel +theorem child_envelope_sub_435_i1 : ∀ j, childrenD_435_i1 j ⊆ envelope_435_i1 := by decide +kernel +theorem pivot_mem_435_i1 : (3, 2) ∈ envelope_435_i1 := by decide +kernel +theorem children_work_435_i1 : ∀ j, Template HasSnaky 3 (childrenC_435_i1 j) (childrenD_435_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 4 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_212 2 (4, 1)).mono (by decide +kernel) +theorem row_works_435_i1 : Template HasSnaky 4 required_435_i1 envelope_435_i1 := by + refine compose HasSnaky 3 childrenC_435_i1 childrenD_435_i1 children_work_435_i1 (3, 2) + required_435_i1 envelope_435_i1 pivot_mem_435_i1 child_required_sub_435_i1 child_envelope_sub_435_i1 ?_ + intro b hb + exact common_sub_435_i1 (mem_commonEnvelope childrenD_435_i1 b hb) +def required_435_i3 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (3, 5), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_435_i3 : Finset Cell := ⟨(([(2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_435_i3 : Fin 2 → Finset Cell := ![(placed21 3 (3, 5) required_5), (placed21 2 (3, 1) required_11)] +def childrenD_435_i3 : Fin 2 → Finset Cell := ![(placed21 3 (3, 5) envelope_5), (placed21 2 (3, 1) envelope_11)] +theorem common_sub_435_i3 : commonEnvelope childrenD_435_i3 ⊆ insert (3, 2) required_435_i3 := by decide +kernel +theorem child_required_sub_435_i3 : ∀ j, childrenC_435_i3 j ⊆ insert (3, 2) required_435_i3 := by decide +kernel +theorem child_envelope_sub_435_i3 : ∀ j, childrenD_435_i3 j ⊆ envelope_435_i3 := by decide +kernel +theorem pivot_mem_435_i3 : (3, 2) ∈ envelope_435_i3 := by decide +kernel +theorem children_work_435_i3 : ∀ j, Template HasSnaky 2 (childrenC_435_i3 j) (childrenD_435_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_11 2 (3, 1)).mono (by decide +kernel) +theorem row_works_435_i3 : Template HasSnaky 3 required_435_i3 envelope_435_i3 := by + refine compose HasSnaky 2 childrenC_435_i3 childrenD_435_i3 children_work_435_i3 (3, 2) + required_435_i3 envelope_435_i3 pivot_mem_435_i3 child_required_sub_435_i3 child_envelope_sub_435_i3 ?_ + intro b hb + exact common_sub_435_i3 (mem_commonEnvelope childrenD_435_i3 b hb) +def required_435_i2 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_435_i2 : Finset Cell := ⟨(([(2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_435_i2 : Fin 3 → Finset Cell := ![(placed21 2 (4, 2) required_76), (placed21 4 (3, 5) required_130), required_435_i3] +def childrenD_435_i2 : Fin 3 → Finset Cell := ![(placed21 2 (4, 2) envelope_76), (placed21 4 (3, 5) envelope_130), envelope_435_i3] +theorem common_sub_435_i2 : commonEnvelope childrenD_435_i2 ⊆ insert (3, 5) required_435_i2 := by decide +kernel +theorem child_required_sub_435_i2 : ∀ j, childrenC_435_i2 j ⊆ insert (3, 5) required_435_i2 := by decide +kernel +theorem child_envelope_sub_435_i2 : ∀ j, childrenD_435_i2 j ⊆ envelope_435_i2 := by decide +kernel +theorem pivot_mem_435_i2 : (3, 5) ∈ envelope_435_i2 := by decide +kernel +theorem children_work_435_i2 : ∀ j, Template HasSnaky 3 (childrenC_435_i2 j) (childrenD_435_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_76 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_130 4 (3, 5)).mono (by decide +kernel) + · exact row_works_435_i3.mono (by decide +kernel) +theorem row_works_435_i2 : Template HasSnaky 4 required_435_i2 envelope_435_i2 := by + refine compose HasSnaky 3 childrenC_435_i2 childrenD_435_i2 children_work_435_i2 (3, 5) + required_435_i2 envelope_435_i2 pivot_mem_435_i2 child_required_sub_435_i2 child_envelope_sub_435_i2 ?_ + intro b hb + exact common_sub_435_i2 (mem_commonEnvelope childrenD_435_i2 b hb) +def required_435_i0 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_435_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_435_i0 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) required_52), (placed21 5 (4, 2) required_76), required_435_i1, required_435_i2] +def childrenD_435_i0 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) envelope_52), (placed21 5 (4, 2) envelope_76), envelope_435_i1, envelope_435_i2] +theorem common_sub_435_i0 : commonEnvelope childrenD_435_i0 ⊆ insert (3, 4) required_435_i0 := by decide +kernel +theorem child_required_sub_435_i0 : ∀ j, childrenC_435_i0 j ⊆ insert (3, 4) required_435_i0 := by decide +kernel +theorem child_envelope_sub_435_i0 : ∀ j, childrenD_435_i0 j ⊆ envelope_435_i0 := by decide +kernel +theorem pivot_mem_435_i0 : (3, 4) ∈ envelope_435_i0 := by decide +kernel +theorem children_work_435_i0 : ∀ j, Template HasSnaky 4 (childrenC_435_i0 j) (childrenD_435_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_76 5 (4, 2)).mono (by decide +kernel) + · exact row_works_435_i1.mono (by decide +kernel) + · exact row_works_435_i2.mono (by decide +kernel) +theorem row_works_435_i0 : Template HasSnaky 5 required_435_i0 envelope_435_i0 := by + refine compose HasSnaky 4 childrenC_435_i0 childrenD_435_i0 children_work_435_i0 (3, 4) + required_435_i0 envelope_435_i0 pivot_mem_435_i0 child_required_sub_435_i0 child_envelope_sub_435_i0 ?_ + intro b hb + exact common_sub_435_i0 (mem_commonEnvelope childrenD_435_i0 b hb) +def required_435 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_435 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_435 : Fin 4 → Finset Cell := ![(placed21 3 (1, 3) required_130), (placed21 3 (0, 3) required_140), (placed21 4 (0, 5) required_183), required_435_i0] +def childrenD_435 : Fin 4 → Finset Cell := ![(placed21 3 (1, 3) envelope_130), (placed21 3 (0, 3) envelope_140), (placed21 4 (0, 5) envelope_183), envelope_435_i0] +theorem common_sub_435 : commonEnvelope childrenD_435 ⊆ insert (4, 2) required_435 := by decide +kernel +theorem child_required_sub_435 : ∀ j, childrenC_435 j ⊆ insert (4, 2) required_435 := by decide +kernel +theorem child_envelope_sub_435 : ∀ j, childrenD_435 j ⊆ envelope_435 := by decide +kernel +theorem pivot_mem_435 : (4, 2) ∈ envelope_435 := by decide +kernel +theorem children_work_435 : ∀ j, Template HasSnaky 5 (childrenC_435 j) (childrenD_435 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_130 3 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_140 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_183 4 (0, 5)).mono (by decide +kernel) + · exact row_works_435_i0.mono (by decide +kernel) +theorem row_works_435 : Template HasSnaky 6 required_435 envelope_435 := by + refine compose HasSnaky 5 childrenC_435 childrenD_435 children_work_435 (4, 2) + required_435 envelope_435 pivot_mem_435 child_required_sub_435 child_envelope_sub_435 ?_ + intro b hb + exact common_sub_435 (mem_commonEnvelope childrenD_435 b hb) +def height_378_i0 : ℕ := 5 +def childrenH_378_i0 : Fin 2 → ℕ := ![height_5, height_18] +theorem height_exact_378_i0 : height_378_i0 = 1 + Finset.univ.sup childrenH_378_i0 := by decide +kernel +theorem required_origin_378_i0 : ∀ x ∈ required_378_i0, + (∃ j, x ∈ childrenC_378_i0 j) ∨ ∀ j, x ∈ childrenD_378_i0 j := by decide +kernel +theorem required_exact_378_i0 : required_378_i0 = + ((Finset.univ.biUnion childrenC_378_i0) ∪ commonEnvelope childrenD_378_i0).erase (3, 3) := by + exact required_eq_combination childrenC_378_i0 childrenD_378_i0 (3, 3) required_378_i0 + (by decide +kernel) child_required_sub_378_i0 common_sub_378_i0 required_origin_378_i0 +theorem envelope_origin_378_i0 : ∀ x ∈ envelope_378_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_378_i0 j := by decide +kernel +theorem envelope_exact_378_i0 : envelope_378_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_378_i0) := by + exact envelope_eq_combination childrenD_378_i0 (3, 3) envelope_378_i0 + pivot_mem_378_i0 child_envelope_sub_378_i0 envelope_origin_378_i0 +def checked_378_i0 : CheckedCard where + required := required_378_i0 + envelope := envelope_378_i0 + height := height_378_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_378_i0 +def height_378 : ℕ := 6 +def childrenH_378 : Fin 2 → ℕ := ![height_5, height_378_i0] +theorem height_exact_378 : height_378 = 1 + Finset.univ.sup childrenH_378 := by decide +kernel +theorem required_origin_378 : ∀ x ∈ required_378, + (∃ j, x ∈ childrenC_378 j) ∨ ∀ j, x ∈ childrenD_378 j := by decide +kernel +theorem required_exact_378 : required_378 = + ((Finset.univ.biUnion childrenC_378) ∪ commonEnvelope childrenD_378).erase (3, 1) := by + exact required_eq_combination childrenC_378 childrenD_378 (3, 1) required_378 + (by decide +kernel) child_required_sub_378 common_sub_378 required_origin_378 +theorem envelope_origin_378 : ∀ x ∈ envelope_378, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_378 j := by decide +kernel +theorem envelope_exact_378 : envelope_378 = + insert (3, 1) (Finset.univ.biUnion childrenD_378) := by + exact envelope_eq_combination childrenD_378 (3, 1) envelope_378 + pivot_mem_378 child_envelope_sub_378 envelope_origin_378 +def checked_378 : CheckedCard where + required := required_378 + envelope := envelope_378 + height := height_378 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_378 +def height_384 : ℕ := 6 +def childrenH_384 : Fin 2 → ℕ := ![height_8, height_383] +theorem height_exact_384 : height_384 = 1 + Finset.univ.sup childrenH_384 := by decide +kernel +theorem required_origin_384 : ∀ x ∈ required_384, + (∃ j, x ∈ childrenC_384 j) ∨ ∀ j, x ∈ childrenD_384 j := by decide +kernel +theorem required_exact_384 : required_384 = + ((Finset.univ.biUnion childrenC_384) ∪ commonEnvelope childrenD_384).erase (3, 3) := by + exact required_eq_combination childrenC_384 childrenD_384 (3, 3) required_384 + (by decide +kernel) child_required_sub_384 common_sub_384 required_origin_384 +theorem envelope_origin_384 : ∀ x ∈ envelope_384, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_384 j := by decide +kernel +theorem envelope_exact_384 : envelope_384 = + insert (3, 3) (Finset.univ.biUnion childrenD_384) := by + exact envelope_eq_combination childrenD_384 (3, 3) envelope_384 + pivot_mem_384 child_envelope_sub_384 envelope_origin_384 +def checked_384 : CheckedCard where + required := required_384 + envelope := envelope_384 + height := height_384 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_384 +def height_387 : ℕ := 6 +def childrenH_387 : Fin 3 → ℕ := ![height_200, height_376, height_386] +theorem height_exact_387 : height_387 = 1 + Finset.univ.sup childrenH_387 := by decide +kernel +theorem required_origin_387 : ∀ x ∈ required_387, + (∃ j, x ∈ childrenC_387 j) ∨ ∀ j, x ∈ childrenD_387 j := by decide +kernel +theorem required_exact_387 : required_387 = + ((Finset.univ.biUnion childrenC_387) ∪ commonEnvelope childrenD_387).erase (4, 2) := by + exact required_eq_combination childrenC_387 childrenD_387 (4, 2) required_387 + (by decide +kernel) child_required_sub_387 common_sub_387 required_origin_387 +theorem envelope_origin_387 : ∀ x ∈ envelope_387, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_387 j := by decide +kernel +theorem envelope_exact_387 : envelope_387 = + insert (4, 2) (Finset.univ.biUnion childrenD_387) := by + exact envelope_eq_combination childrenD_387 (4, 2) envelope_387 + pivot_mem_387 child_envelope_sub_387 envelope_origin_387 +def checked_387 : CheckedCard where + required := required_387 + envelope := envelope_387 + height := height_387 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_387 +def height_390 : ℕ := 6 +def childrenH_390 : Fin 3 → ℕ := ![height_11, height_17, height_389] +theorem height_exact_390 : height_390 = 1 + Finset.univ.sup childrenH_390 := by decide +kernel +theorem required_origin_390 : ∀ x ∈ required_390, + (∃ j, x ∈ childrenC_390 j) ∨ ∀ j, x ∈ childrenD_390 j := by decide +kernel +theorem required_exact_390 : required_390 = + ((Finset.univ.biUnion childrenC_390) ∪ commonEnvelope childrenD_390).erase (1, 7) := by + exact required_eq_combination childrenC_390 childrenD_390 (1, 7) required_390 + (by decide +kernel) child_required_sub_390 common_sub_390 required_origin_390 +theorem envelope_origin_390 : ∀ x ∈ envelope_390, + x = (1, 7) ∨ ∃ j, x ∈ childrenD_390 j := by decide +kernel +theorem envelope_exact_390 : envelope_390 = + insert (1, 7) (Finset.univ.biUnion childrenD_390) := by + exact envelope_eq_combination childrenD_390 (1, 7) envelope_390 + pivot_mem_390 child_envelope_sub_390 envelope_origin_390 +def checked_390 : CheckedCard where + required := required_390 + envelope := envelope_390 + height := height_390 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_390 +def height_392 : ℕ := 6 +def childrenH_392 : Fin 2 → ℕ := ![height_0, height_391] +theorem height_exact_392 : height_392 = 1 + Finset.univ.sup childrenH_392 := by decide +kernel +theorem required_origin_392 : ∀ x ∈ required_392, + (∃ j, x ∈ childrenC_392 j) ∨ ∀ j, x ∈ childrenD_392 j := by decide +kernel +theorem required_exact_392 : required_392 = + ((Finset.univ.biUnion childrenC_392) ∪ commonEnvelope childrenD_392).erase (3, 3) := by + exact required_eq_combination childrenC_392 childrenD_392 (3, 3) required_392 + (by decide +kernel) child_required_sub_392 common_sub_392 required_origin_392 +theorem envelope_origin_392 : ∀ x ∈ envelope_392, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_392 j := by decide +kernel +theorem envelope_exact_392 : envelope_392 = + insert (3, 3) (Finset.univ.biUnion childrenD_392) := by + exact envelope_eq_combination childrenD_392 (3, 3) envelope_392 + pivot_mem_392 child_envelope_sub_392 envelope_origin_392 +def checked_392 : CheckedCard where + required := required_392 + envelope := envelope_392 + height := height_392 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_392 +def height_393 : ℕ := 6 +def childrenH_393 : Fin 3 → ℕ := ![height_11, height_20, height_391] +theorem height_exact_393 : height_393 = 1 + Finset.univ.sup childrenH_393 := by decide +kernel +theorem required_origin_393 : ∀ x ∈ required_393, + (∃ j, x ∈ childrenC_393 j) ∨ ∀ j, x ∈ childrenD_393 j := by decide +kernel +theorem required_exact_393 : required_393 = + ((Finset.univ.biUnion childrenC_393) ∪ commonEnvelope childrenD_393).erase (1, 4) := by + exact required_eq_combination childrenC_393 childrenD_393 (1, 4) required_393 + (by decide +kernel) child_required_sub_393 common_sub_393 required_origin_393 +theorem envelope_origin_393 : ∀ x ∈ envelope_393, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_393 j := by decide +kernel +theorem envelope_exact_393 : envelope_393 = + insert (1, 4) (Finset.univ.biUnion childrenD_393) := by + exact envelope_eq_combination childrenD_393 (1, 4) envelope_393 + pivot_mem_393 child_envelope_sub_393 envelope_origin_393 +def checked_393 : CheckedCard where + required := required_393 + envelope := envelope_393 + height := height_393 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_393 +def height_403_i0 : ℕ := 5 +def childrenH_403_i0 : Fin 2 → ℕ := ![height_4, height_381] +theorem height_exact_403_i0 : height_403_i0 = 1 + Finset.univ.sup childrenH_403_i0 := by decide +kernel +theorem required_origin_403_i0 : ∀ x ∈ required_403_i0, + (∃ j, x ∈ childrenC_403_i0 j) ∨ ∀ j, x ∈ childrenD_403_i0 j := by decide +kernel +theorem required_exact_403_i0 : required_403_i0 = + ((Finset.univ.biUnion childrenC_403_i0) ∪ commonEnvelope childrenD_403_i0).erase (2, 5) := by + exact required_eq_combination childrenC_403_i0 childrenD_403_i0 (2, 5) required_403_i0 + (by decide +kernel) child_required_sub_403_i0 common_sub_403_i0 required_origin_403_i0 +theorem envelope_origin_403_i0 : ∀ x ∈ envelope_403_i0, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_403_i0 j := by decide +kernel +theorem envelope_exact_403_i0 : envelope_403_i0 = + insert (2, 5) (Finset.univ.biUnion childrenD_403_i0) := by + exact envelope_eq_combination childrenD_403_i0 (2, 5) envelope_403_i0 + pivot_mem_403_i0 child_envelope_sub_403_i0 envelope_origin_403_i0 +def checked_403_i0 : CheckedCard where + required := required_403_i0 + envelope := envelope_403_i0 + height := height_403_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_403_i0 +def height_403 : ℕ := 6 +def childrenH_403 : Fin 2 → ℕ := ![height_86, height_403_i0] +theorem height_exact_403 : height_403 = 1 + Finset.univ.sup childrenH_403 := by decide +kernel +theorem required_origin_403 : ∀ x ∈ required_403, + (∃ j, x ∈ childrenC_403 j) ∨ ∀ j, x ∈ childrenD_403 j := by decide +kernel +theorem required_exact_403 : required_403 = + ((Finset.univ.biUnion childrenC_403) ∪ commonEnvelope childrenD_403).erase (1, 5) := by + exact required_eq_combination childrenC_403 childrenD_403 (1, 5) required_403 + (by decide +kernel) child_required_sub_403 common_sub_403 required_origin_403 +theorem envelope_origin_403 : ∀ x ∈ envelope_403, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_403 j := by decide +kernel +theorem envelope_exact_403 : envelope_403 = + insert (1, 5) (Finset.univ.biUnion childrenD_403) := by + exact envelope_eq_combination childrenD_403 (1, 5) envelope_403 + pivot_mem_403 child_envelope_sub_403 envelope_origin_403 +def checked_403 : CheckedCard where + required := required_403 + envelope := envelope_403 + height := height_403 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_403 +def height_414 : ℕ := 6 +def childrenH_414 : Fin 2 → ℕ := ![height_0, height_413] +theorem height_exact_414 : height_414 = 1 + Finset.univ.sup childrenH_414 := by decide +kernel +theorem required_origin_414 : ∀ x ∈ required_414, + (∃ j, x ∈ childrenC_414 j) ∨ ∀ j, x ∈ childrenD_414 j := by decide +kernel +theorem required_exact_414 : required_414 = + ((Finset.univ.biUnion childrenC_414) ∪ commonEnvelope childrenD_414).erase (1, 4) := by + exact required_eq_combination childrenC_414 childrenD_414 (1, 4) required_414 + (by decide +kernel) child_required_sub_414 common_sub_414 required_origin_414 +theorem envelope_origin_414 : ∀ x ∈ envelope_414, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_414 j := by decide +kernel +theorem envelope_exact_414 : envelope_414 = + insert (1, 4) (Finset.univ.biUnion childrenD_414) := by + exact envelope_eq_combination childrenD_414 (1, 4) envelope_414 + pivot_mem_414 child_envelope_sub_414 envelope_origin_414 +def checked_414 : CheckedCard where + required := required_414 + envelope := envelope_414 + height := height_414 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_414 +def height_417 : ℕ := 6 +def childrenH_417 : Fin 2 → ℕ := ![height_0, height_416] +theorem height_exact_417 : height_417 = 1 + Finset.univ.sup childrenH_417 := by decide +kernel +theorem required_origin_417 : ∀ x ∈ required_417, + (∃ j, x ∈ childrenC_417 j) ∨ ∀ j, x ∈ childrenD_417 j := by decide +kernel +theorem required_exact_417 : required_417 = + ((Finset.univ.biUnion childrenC_417) ∪ commonEnvelope childrenD_417).erase (3, 2) := by + exact required_eq_combination childrenC_417 childrenD_417 (3, 2) required_417 + (by decide +kernel) child_required_sub_417 common_sub_417 required_origin_417 +theorem envelope_origin_417 : ∀ x ∈ envelope_417, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_417 j := by decide +kernel +theorem envelope_exact_417 : envelope_417 = + insert (3, 2) (Finset.univ.biUnion childrenD_417) := by + exact envelope_eq_combination childrenD_417 (3, 2) envelope_417 + pivot_mem_417 child_envelope_sub_417 envelope_origin_417 +def checked_417 : CheckedCard where + required := required_417 + envelope := envelope_417 + height := height_417 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_417 +def height_423_i0 : ℕ := 3 +def childrenH_423_i0 : Fin 2 → ℕ := ![height_5, height_244] +theorem height_exact_423_i0 : height_423_i0 = 1 + Finset.univ.sup childrenH_423_i0 := by decide +kernel +theorem required_origin_423_i0 : ∀ x ∈ required_423_i0, + (∃ j, x ∈ childrenC_423_i0 j) ∨ ∀ j, x ∈ childrenD_423_i0 j := by decide +kernel +theorem required_exact_423_i0 : required_423_i0 = + ((Finset.univ.biUnion childrenC_423_i0) ∪ commonEnvelope childrenD_423_i0).erase (1, 2) := by + exact required_eq_combination childrenC_423_i0 childrenD_423_i0 (1, 2) required_423_i0 + (by decide +kernel) child_required_sub_423_i0 common_sub_423_i0 required_origin_423_i0 +theorem envelope_origin_423_i0 : ∀ x ∈ envelope_423_i0, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_423_i0 j := by decide +kernel +theorem envelope_exact_423_i0 : envelope_423_i0 = + insert (1, 2) (Finset.univ.biUnion childrenD_423_i0) := by + exact envelope_eq_combination childrenD_423_i0 (1, 2) envelope_423_i0 + pivot_mem_423_i0 child_envelope_sub_423_i0 envelope_origin_423_i0 +def checked_423_i0 : CheckedCard where + required := required_423_i0 + envelope := envelope_423_i0 + height := height_423_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_423_i0 +def height_423 : ℕ := 6 +def childrenH_423 : Fin 2 → ℕ := ![height_383, height_423_i0] +theorem height_exact_423 : height_423 = 1 + Finset.univ.sup childrenH_423 := by decide +kernel +theorem required_origin_423 : ∀ x ∈ required_423, + (∃ j, x ∈ childrenC_423 j) ∨ ∀ j, x ∈ childrenD_423 j := by decide +kernel +theorem required_exact_423 : required_423 = + ((Finset.univ.biUnion childrenC_423) ∪ commonEnvelope childrenD_423).erase (2, 3) := by + exact required_eq_combination childrenC_423 childrenD_423 (2, 3) required_423 + (by decide +kernel) child_required_sub_423 common_sub_423 required_origin_423 +theorem envelope_origin_423 : ∀ x ∈ envelope_423, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_423 j := by decide +kernel +theorem envelope_exact_423 : envelope_423 = + insert (2, 3) (Finset.univ.biUnion childrenD_423) := by + exact envelope_eq_combination childrenD_423 (2, 3) envelope_423 + pivot_mem_423 child_envelope_sub_423 envelope_origin_423 +def checked_423 : CheckedCard where + required := required_423 + envelope := envelope_423 + height := height_423 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_423 +def height_429_i0 : ℕ := 5 +def childrenH_429_i0 : Fin 2 → ℕ := ![height_2, height_46] +theorem height_exact_429_i0 : height_429_i0 = 1 + Finset.univ.sup childrenH_429_i0 := by decide +kernel +theorem required_origin_429_i0 : ∀ x ∈ required_429_i0, + (∃ j, x ∈ childrenC_429_i0 j) ∨ ∀ j, x ∈ childrenD_429_i0 j := by decide +kernel +theorem required_exact_429_i0 : required_429_i0 = + ((Finset.univ.biUnion childrenC_429_i0) ∪ commonEnvelope childrenD_429_i0).erase (4, 3) := by + exact required_eq_combination childrenC_429_i0 childrenD_429_i0 (4, 3) required_429_i0 + (by decide +kernel) child_required_sub_429_i0 common_sub_429_i0 required_origin_429_i0 +theorem envelope_origin_429_i0 : ∀ x ∈ envelope_429_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_429_i0 j := by decide +kernel +theorem envelope_exact_429_i0 : envelope_429_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_429_i0) := by + exact envelope_eq_combination childrenD_429_i0 (4, 3) envelope_429_i0 + pivot_mem_429_i0 child_envelope_sub_429_i0 envelope_origin_429_i0 +def checked_429_i0 : CheckedCard where + required := required_429_i0 + envelope := envelope_429_i0 + height := height_429_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_429_i0 +def height_429 : ℕ := 6 +def childrenH_429 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_429_i0] +theorem height_exact_429 : height_429 = 1 + Finset.univ.sup childrenH_429 := by decide +kernel +theorem required_origin_429 : ∀ x ∈ required_429, + (∃ j, x ∈ childrenC_429 j) ∨ ∀ j, x ∈ childrenD_429 j := by decide +kernel +theorem required_exact_429 : required_429 = + ((Finset.univ.biUnion childrenC_429) ∪ commonEnvelope childrenD_429).erase (3, 4) := by + exact required_eq_combination childrenC_429 childrenD_429 (3, 4) required_429 + (by decide +kernel) child_required_sub_429 common_sub_429 required_origin_429 +theorem envelope_origin_429 : ∀ x ∈ envelope_429, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_429 j := by decide +kernel +theorem envelope_exact_429 : envelope_429 = + insert (3, 4) (Finset.univ.biUnion childrenD_429) := by + exact envelope_eq_combination childrenD_429 (3, 4) envelope_429 + pivot_mem_429 child_envelope_sub_429 envelope_origin_429 +def checked_429 : CheckedCard where + required := required_429 + envelope := envelope_429 + height := height_429 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_429 +def height_435_i1 : ℕ := 4 +def childrenH_435_i1 : Fin 2 → ℕ := ![height_0, height_212] +theorem height_exact_435_i1 : height_435_i1 = 1 + Finset.univ.sup childrenH_435_i1 := by decide +kernel +theorem required_origin_435_i1 : ∀ x ∈ required_435_i1, + (∃ j, x ∈ childrenC_435_i1 j) ∨ ∀ j, x ∈ childrenD_435_i1 j := by decide +kernel +theorem required_exact_435_i1 : required_435_i1 = + ((Finset.univ.biUnion childrenC_435_i1) ∪ commonEnvelope childrenD_435_i1).erase (3, 2) := by + exact required_eq_combination childrenC_435_i1 childrenD_435_i1 (3, 2) required_435_i1 + (by decide +kernel) child_required_sub_435_i1 common_sub_435_i1 required_origin_435_i1 +theorem envelope_origin_435_i1 : ∀ x ∈ envelope_435_i1, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_435_i1 j := by decide +kernel +theorem envelope_exact_435_i1 : envelope_435_i1 = + insert (3, 2) (Finset.univ.biUnion childrenD_435_i1) := by + exact envelope_eq_combination childrenD_435_i1 (3, 2) envelope_435_i1 + pivot_mem_435_i1 child_envelope_sub_435_i1 envelope_origin_435_i1 +def checked_435_i1 : CheckedCard where + required := required_435_i1 + envelope := envelope_435_i1 + height := height_435_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_435_i1 +def height_435_i3 : ℕ := 3 +def childrenH_435_i3 : Fin 2 → ℕ := ![height_5, height_11] +theorem height_exact_435_i3 : height_435_i3 = 1 + Finset.univ.sup childrenH_435_i3 := by decide +kernel +theorem required_origin_435_i3 : ∀ x ∈ required_435_i3, + (∃ j, x ∈ childrenC_435_i3 j) ∨ ∀ j, x ∈ childrenD_435_i3 j := by decide +kernel +theorem required_exact_435_i3 : required_435_i3 = + ((Finset.univ.biUnion childrenC_435_i3) ∪ commonEnvelope childrenD_435_i3).erase (3, 2) := by + exact required_eq_combination childrenC_435_i3 childrenD_435_i3 (3, 2) required_435_i3 + (by decide +kernel) child_required_sub_435_i3 common_sub_435_i3 required_origin_435_i3 +theorem envelope_origin_435_i3 : ∀ x ∈ envelope_435_i3, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_435_i3 j := by decide +kernel +theorem envelope_exact_435_i3 : envelope_435_i3 = + insert (3, 2) (Finset.univ.biUnion childrenD_435_i3) := by + exact envelope_eq_combination childrenD_435_i3 (3, 2) envelope_435_i3 + pivot_mem_435_i3 child_envelope_sub_435_i3 envelope_origin_435_i3 +def checked_435_i3 : CheckedCard where + required := required_435_i3 + envelope := envelope_435_i3 + height := height_435_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_435_i3 +def height_435_i2 : ℕ := 4 +def childrenH_435_i2 : Fin 3 → ℕ := ![height_76, height_130, height_435_i3] +theorem height_exact_435_i2 : height_435_i2 = 1 + Finset.univ.sup childrenH_435_i2 := by decide +kernel +theorem required_origin_435_i2 : ∀ x ∈ required_435_i2, + (∃ j, x ∈ childrenC_435_i2 j) ∨ ∀ j, x ∈ childrenD_435_i2 j := by decide +kernel +theorem required_exact_435_i2 : required_435_i2 = + ((Finset.univ.biUnion childrenC_435_i2) ∪ commonEnvelope childrenD_435_i2).erase (3, 5) := by + exact required_eq_combination childrenC_435_i2 childrenD_435_i2 (3, 5) required_435_i2 + (by decide +kernel) child_required_sub_435_i2 common_sub_435_i2 required_origin_435_i2 +theorem envelope_origin_435_i2 : ∀ x ∈ envelope_435_i2, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_435_i2 j := by decide +kernel +theorem envelope_exact_435_i2 : envelope_435_i2 = + insert (3, 5) (Finset.univ.biUnion childrenD_435_i2) := by + exact envelope_eq_combination childrenD_435_i2 (3, 5) envelope_435_i2 + pivot_mem_435_i2 child_envelope_sub_435_i2 envelope_origin_435_i2 +def checked_435_i2 : CheckedCard where + required := required_435_i2 + envelope := envelope_435_i2 + height := height_435_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_435_i2 +def height_435_i0 : ℕ := 5 +def childrenH_435_i0 : Fin 4 → ℕ := ![height_52, height_76, height_435_i1, height_435_i2] +theorem height_exact_435_i0 : height_435_i0 = 1 + Finset.univ.sup childrenH_435_i0 := by decide +kernel +theorem required_origin_435_i0 : ∀ x ∈ required_435_i0, + (∃ j, x ∈ childrenC_435_i0 j) ∨ ∀ j, x ∈ childrenD_435_i0 j := by decide +kernel +theorem required_exact_435_i0 : required_435_i0 = + ((Finset.univ.biUnion childrenC_435_i0) ∪ commonEnvelope childrenD_435_i0).erase (3, 4) := by + exact required_eq_combination childrenC_435_i0 childrenD_435_i0 (3, 4) required_435_i0 + (by decide +kernel) child_required_sub_435_i0 common_sub_435_i0 required_origin_435_i0 +theorem envelope_origin_435_i0 : ∀ x ∈ envelope_435_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_435_i0 j := by decide +kernel +theorem envelope_exact_435_i0 : envelope_435_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_435_i0) := by + exact envelope_eq_combination childrenD_435_i0 (3, 4) envelope_435_i0 + pivot_mem_435_i0 child_envelope_sub_435_i0 envelope_origin_435_i0 +def checked_435_i0 : CheckedCard where + required := required_435_i0 + envelope := envelope_435_i0 + height := height_435_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_435_i0 +def height_435 : ℕ := 6 +def childrenH_435 : Fin 4 → ℕ := ![height_130, height_140, height_183, height_435_i0] +theorem height_exact_435 : height_435 = 1 + Finset.univ.sup childrenH_435 := by decide +kernel +theorem required_origin_435 : ∀ x ∈ required_435, + (∃ j, x ∈ childrenC_435 j) ∨ ∀ j, x ∈ childrenD_435 j := by decide +kernel +theorem required_exact_435 : required_435 = + ((Finset.univ.biUnion childrenC_435) ∪ commonEnvelope childrenD_435).erase (4, 2) := by + exact required_eq_combination childrenC_435 childrenD_435 (4, 2) required_435 + (by decide +kernel) child_required_sub_435 common_sub_435 required_origin_435 +theorem envelope_origin_435 : ∀ x ∈ envelope_435, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_435 j := by decide +kernel +theorem envelope_exact_435 : envelope_435 = + insert (4, 2) (Finset.univ.biUnion childrenD_435) := by + exact envelope_eq_combination childrenD_435 (4, 2) envelope_435 + pivot_mem_435 child_envelope_sub_435 envelope_origin_435 +def checked_435 : CheckedCard where + required := required_435 + envelope := envelope_435 + height := height_435 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_435 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part05.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part05.lean new file mode 100644 index 0000000..c36c763 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part05.lean @@ -0,0 +1,932 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_439_i1 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (3, 2), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_439_i1 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 2), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_439_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_2), (placed21 3 (3, 5) required_5)] +def childrenD_439_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_2), (placed21 3 (3, 5) envelope_5)] +theorem common_sub_439_i1 : commonEnvelope childrenD_439_i1 ⊆ insert (4, 2) required_439_i1 := by decide +kernel +theorem child_required_sub_439_i1 : ∀ j, childrenC_439_i1 j ⊆ insert (4, 2) required_439_i1 := by decide +kernel +theorem child_envelope_sub_439_i1 : ∀ j, childrenD_439_i1 j ⊆ envelope_439_i1 := by decide +kernel +theorem pivot_mem_439_i1 : (4, 2) ∈ envelope_439_i1 := by decide +kernel +theorem children_work_439_i1 : ∀ j, Template HasSnaky 1 (childrenC_439_i1 j) (childrenD_439_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 6 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_5 3 (3, 5)).mono (by decide +kernel) +theorem row_works_439_i1 : Template HasSnaky 2 required_439_i1 envelope_439_i1 := by + refine compose HasSnaky 1 childrenC_439_i1 childrenD_439_i1 children_work_439_i1 (4, 2) + required_439_i1 envelope_439_i1 pivot_mem_439_i1 child_required_sub_439_i1 child_envelope_sub_439_i1 ?_ + intro b hb + exact common_sub_439_i1 (mem_commonEnvelope childrenD_439_i1 b hb) +def required_439_i4 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_439_i4 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_439_i4 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) required_5), (placed21 2 (4, 1) required_5)] +def childrenD_439_i4 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) envelope_5), (placed21 2 (4, 1) envelope_5)] +theorem common_sub_439_i4 : commonEnvelope childrenD_439_i4 ⊆ insert (4, 1) required_439_i4 := by decide +kernel +theorem child_required_sub_439_i4 : ∀ j, childrenC_439_i4 j ⊆ insert (4, 1) required_439_i4 := by decide +kernel +theorem child_envelope_sub_439_i4 : ∀ j, childrenD_439_i4 j ⊆ envelope_439_i4 := by decide +kernel +theorem pivot_mem_439_i4 : (4, 1) ∈ envelope_439_i4 := by decide +kernel +theorem children_work_439_i4 : ∀ j, Template HasSnaky 1 (childrenC_439_i4 j) (childrenD_439_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 2 (4, 1)).mono (by decide +kernel) +theorem row_works_439_i4 : Template HasSnaky 2 required_439_i4 envelope_439_i4 := by + refine compose HasSnaky 1 childrenC_439_i4 childrenD_439_i4 children_work_439_i4 (4, 1) + required_439_i4 envelope_439_i4 pivot_mem_439_i4 child_required_sub_439_i4 child_envelope_sub_439_i4 ?_ + intro b hb + exact common_sub_439_i4 (mem_commonEnvelope childrenD_439_i4 b hb) +def required_439_i3 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_439_i3 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_439_i3 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) required_5), required_439_i4] +def childrenD_439_i3 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) envelope_5), envelope_439_i4] +theorem common_sub_439_i3 : commonEnvelope childrenD_439_i3 ⊆ insert (3, 1) required_439_i3 := by decide +kernel +theorem child_required_sub_439_i3 : ∀ j, childrenC_439_i3 j ⊆ insert (3, 1) required_439_i3 := by decide +kernel +theorem child_envelope_sub_439_i3 : ∀ j, childrenD_439_i3 j ⊆ envelope_439_i3 := by decide +kernel +theorem pivot_mem_439_i3 : (3, 1) ∈ envelope_439_i3 := by decide +kernel +theorem children_work_439_i3 : ∀ j, Template HasSnaky 2 (childrenC_439_i3 j) (childrenD_439_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (3, 4)).mono (by decide +kernel) + · exact row_works_439_i4.mono (by decide +kernel) +theorem row_works_439_i3 : Template HasSnaky 3 required_439_i3 envelope_439_i3 := by + refine compose HasSnaky 2 childrenC_439_i3 childrenD_439_i3 children_work_439_i3 (3, 1) + required_439_i3 envelope_439_i3 pivot_mem_439_i3 child_required_sub_439_i3 child_envelope_sub_439_i3 ?_ + intro b hb + exact common_sub_439_i3 (mem_commonEnvelope childrenD_439_i3 b hb) +def required_439_i2 : Finset Cell := ⟨(([(1, 1), (1, 2), (3, 2), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_439_i2 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_439_i2 : Fin 2 → Finset Cell := ![(placed21 7 (3, 5) required_4), required_439_i3] +def childrenD_439_i2 : Fin 2 → Finset Cell := ![(placed21 7 (3, 5) envelope_4), envelope_439_i3] +theorem common_sub_439_i2 : commonEnvelope childrenD_439_i2 ⊆ insert (2, 1) required_439_i2 := by decide +kernel +theorem child_required_sub_439_i2 : ∀ j, childrenC_439_i2 j ⊆ insert (2, 1) required_439_i2 := by decide +kernel +theorem child_envelope_sub_439_i2 : ∀ j, childrenD_439_i2 j ⊆ envelope_439_i2 := by decide +kernel +theorem pivot_mem_439_i2 : (2, 1) ∈ envelope_439_i2 := by decide +kernel +theorem children_work_439_i2 : ∀ j, Template HasSnaky 3 (childrenC_439_i2 j) (childrenD_439_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (3, 5)).mono (by decide +kernel) + · exact row_works_439_i3.mono (by decide +kernel) +theorem row_works_439_i2 : Template HasSnaky 4 required_439_i2 envelope_439_i2 := by + refine compose HasSnaky 3 childrenC_439_i2 childrenD_439_i2 children_work_439_i2 (2, 1) + required_439_i2 envelope_439_i2 pivot_mem_439_i2 child_required_sub_439_i2 child_envelope_sub_439_i2 ?_ + intro b hb + exact common_sub_439_i2 (mem_commonEnvelope childrenD_439_i2 b hb) +def required_439_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_439_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_439_i0 : Fin 4 → Finset Cell := ![(placed21 7 (4, 5) required_251), (placed21 7 (4, 5) required_432), required_439_i1, required_439_i2] +def childrenD_439_i0 : Fin 4 → Finset Cell := ![(placed21 7 (4, 5) envelope_251), (placed21 7 (4, 5) envelope_432), envelope_439_i1, envelope_439_i2] +theorem common_sub_439_i0 : commonEnvelope childrenD_439_i0 ⊆ insert (3, 2) required_439_i0 := by decide +kernel +theorem child_required_sub_439_i0 : ∀ j, childrenC_439_i0 j ⊆ insert (3, 2) required_439_i0 := by decide +kernel +theorem child_envelope_sub_439_i0 : ∀ j, childrenD_439_i0 j ⊆ envelope_439_i0 := by decide +kernel +theorem pivot_mem_439_i0 : (3, 2) ∈ envelope_439_i0 := by decide +kernel +theorem children_work_439_i0 : ∀ j, Template HasSnaky 4 (childrenC_439_i0 j) (childrenD_439_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_251 7 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_432 7 (4, 5)).mono (by decide +kernel) + · exact row_works_439_i1.mono (by decide +kernel) + · exact row_works_439_i2.mono (by decide +kernel) +theorem row_works_439_i0 : Template HasSnaky 5 required_439_i0 envelope_439_i0 := by + refine compose HasSnaky 4 childrenC_439_i0 childrenD_439_i0 children_work_439_i0 (3, 2) + required_439_i0 envelope_439_i0 pivot_mem_439_i0 child_required_sub_439_i0 child_envelope_sub_439_i0 ?_ + intro b hb + exact common_sub_439_i0 (mem_commonEnvelope childrenD_439_i0 b hb) +def required_439 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 2), (1, 4), (2, 4), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_439 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_439 : Fin 2 → Finset Cell := ![(placed21 4 (0, 4) required_5), required_439_i0] +def childrenD_439 : Fin 2 → Finset Cell := ![(placed21 4 (0, 4) envelope_5), envelope_439_i0] +theorem common_sub_439 : commonEnvelope childrenD_439 ⊆ insert (3, 3) required_439 := by decide +kernel +theorem child_required_sub_439 : ∀ j, childrenC_439 j ⊆ insert (3, 3) required_439 := by decide +kernel +theorem child_envelope_sub_439 : ∀ j, childrenD_439 j ⊆ envelope_439 := by decide +kernel +theorem pivot_mem_439 : (3, 3) ∈ envelope_439 := by decide +kernel +theorem children_work_439 : ∀ j, Template HasSnaky 5 (childrenC_439 j) (childrenD_439 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 4)).mono (by decide +kernel) + · exact row_works_439_i0.mono (by decide +kernel) +theorem row_works_439 : Template HasSnaky 6 required_439 envelope_439 := by + refine compose HasSnaky 5 childrenC_439 childrenD_439 children_work_439 (3, 3) + required_439 envelope_439 pivot_mem_439 child_required_sub_439 child_envelope_sub_439 ?_ + intro b hb + exact common_sub_439 (mem_commonEnvelope childrenD_439 b hb) +def required_465_i3 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_465_i3 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (3, 3), (3, 4), (3, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_465_i3 : Fin 2 → Finset Cell := ![(placed21 4 (0, 4) required_4), (placed21 0 (0, 4) required_4)] +def childrenD_465_i3 : Fin 2 → Finset Cell := ![(placed21 4 (0, 4) envelope_4), (placed21 0 (0, 4) envelope_4)] +theorem common_sub_465_i3 : commonEnvelope childrenD_465_i3 ⊆ insert (3, 4) required_465_i3 := by decide +kernel +theorem child_required_sub_465_i3 : ∀ j, childrenC_465_i3 j ⊆ insert (3, 4) required_465_i3 := by decide +kernel +theorem child_envelope_sub_465_i3 : ∀ j, childrenD_465_i3 j ⊆ envelope_465_i3 := by decide +kernel +theorem pivot_mem_465_i3 : (3, 4) ∈ envelope_465_i3 := by decide +kernel +theorem children_work_465_i3 : ∀ j, Template HasSnaky 1 (childrenC_465_i3 j) (childrenD_465_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_4 0 (0, 4)).mono (by decide +kernel) +theorem row_works_465_i3 : Template HasSnaky 2 required_465_i3 envelope_465_i3 := by + refine compose HasSnaky 1 childrenC_465_i3 childrenD_465_i3 children_work_465_i3 (3, 4) + required_465_i3 envelope_465_i3 pivot_mem_465_i3 child_required_sub_465_i3 child_envelope_sub_465_i3 ?_ + intro b hb + exact common_sub_465_i3 (mem_commonEnvelope childrenD_465_i3 b hb) +def required_465_i2 : Finset Cell := ⟨(([(0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_465_i2 : Finset Cell := ⟨(([(0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_465_i2 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), required_465_i3] +def childrenD_465_i2 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), envelope_465_i3] +theorem common_sub_465_i2 : commonEnvelope childrenD_465_i2 ⊆ insert (2, 4) required_465_i2 := by decide +kernel +theorem child_required_sub_465_i2 : ∀ j, childrenC_465_i2 j ⊆ insert (2, 4) required_465_i2 := by decide +kernel +theorem child_envelope_sub_465_i2 : ∀ j, childrenD_465_i2 j ⊆ envelope_465_i2 := by decide +kernel +theorem pivot_mem_465_i2 : (2, 4) ∈ envelope_465_i2 := by decide +kernel +theorem children_work_465_i2 : ∀ j, Template HasSnaky 2 (childrenC_465_i2 j) (childrenD_465_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact row_works_465_i3.mono (by decide +kernel) +theorem row_works_465_i2 : Template HasSnaky 3 required_465_i2 envelope_465_i2 := by + refine compose HasSnaky 2 childrenC_465_i2 childrenD_465_i2 children_work_465_i2 (2, 4) + required_465_i2 envelope_465_i2 pivot_mem_465_i2 child_required_sub_465_i2 child_envelope_sub_465_i2 ?_ + intro b hb + exact common_sub_465_i2 (mem_commonEnvelope childrenD_465_i2 b hb) +def required_465_i1 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_465_i1 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_465_i1 : Fin 2 → Finset Cell := ![(placed21 5 (1, 1) required_5), required_465_i2] +def childrenD_465_i1 : Fin 2 → Finset Cell := ![(placed21 5 (1, 1) envelope_5), envelope_465_i2] +theorem common_sub_465_i1 : commonEnvelope childrenD_465_i1 ⊆ insert (0, 4) required_465_i1 := by decide +kernel +theorem child_required_sub_465_i1 : ∀ j, childrenC_465_i1 j ⊆ insert (0, 4) required_465_i1 := by decide +kernel +theorem child_envelope_sub_465_i1 : ∀ j, childrenD_465_i1 j ⊆ envelope_465_i1 := by decide +kernel +theorem pivot_mem_465_i1 : (0, 4) ∈ envelope_465_i1 := by decide +kernel +theorem children_work_465_i1 : ∀ j, Template HasSnaky 3 (childrenC_465_i1 j) (childrenD_465_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (1, 1)).mono (by decide +kernel) + · exact row_works_465_i2.mono (by decide +kernel) +theorem row_works_465_i1 : Template HasSnaky 4 required_465_i1 envelope_465_i1 := by + refine compose HasSnaky 3 childrenC_465_i1 childrenD_465_i1 children_work_465_i1 (0, 4) + required_465_i1 envelope_465_i1 pivot_mem_465_i1 child_required_sub_465_i1 child_envelope_sub_465_i1 ?_ + intro b hb + exact common_sub_465_i1 (mem_commonEnvelope childrenD_465_i1 b hb) +def required_465_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (3, 2), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_465_i0 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_465_i0 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) required_39), (placed21 0 (3, 1) required_42), required_465_i1] +def childrenD_465_i0 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) envelope_39), (placed21 0 (3, 1) envelope_42), envelope_465_i1] +theorem common_sub_465_i0 : commonEnvelope childrenD_465_i0 ⊆ insert (4, 5) required_465_i0 := by decide +kernel +theorem child_required_sub_465_i0 : ∀ j, childrenC_465_i0 j ⊆ insert (4, 5) required_465_i0 := by decide +kernel +theorem child_envelope_sub_465_i0 : ∀ j, childrenD_465_i0 j ⊆ envelope_465_i0 := by decide +kernel +theorem pivot_mem_465_i0 : (4, 5) ∈ envelope_465_i0 := by decide +kernel +theorem children_work_465_i0 : ∀ j, Template HasSnaky 4 (childrenC_465_i0 j) (childrenD_465_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_39 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_42 0 (3, 1)).mono (by decide +kernel) + · exact row_works_465_i1.mono (by decide +kernel) +theorem row_works_465_i0 : Template HasSnaky 5 required_465_i0 envelope_465_i0 := by + refine compose HasSnaky 4 childrenC_465_i0 childrenD_465_i0 children_work_465_i0 (4, 5) + required_465_i0 envelope_465_i0 pivot_mem_465_i0 child_required_sub_465_i0 child_envelope_sub_465_i0 ?_ + intro b hb + exact common_sub_465_i0 (mem_commonEnvelope childrenD_465_i0 b hb) +def required_465 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_465 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_465 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_25), required_465_i0] +def childrenD_465 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_25), envelope_465_i0] +theorem common_sub_465 : commonEnvelope childrenD_465 ⊆ insert (3, 2) required_465 := by decide +kernel +theorem child_required_sub_465 : ∀ j, childrenC_465 j ⊆ insert (3, 2) required_465 := by decide +kernel +theorem child_envelope_sub_465 : ∀ j, childrenD_465 j ⊆ envelope_465 := by decide +kernel +theorem pivot_mem_465 : (3, 2) ∈ envelope_465 := by decide +kernel +theorem children_work_465 : ∀ j, Template HasSnaky 5 (childrenC_465 j) (childrenD_465 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_25 3 (0, 4)).mono (by decide +kernel) + · exact row_works_465_i0.mono (by decide +kernel) +theorem row_works_465 : Template HasSnaky 6 required_465 envelope_465 := by + refine compose HasSnaky 5 childrenC_465 childrenD_465 children_work_465 (3, 2) + required_465 envelope_465 pivot_mem_465 child_required_sub_465 child_envelope_sub_465 ?_ + intro b hb + exact common_sub_465 (mem_commonEnvelope childrenD_465 b hb) +def required_471_i0 : Finset Cell := ⟨(([(0, 3), (2, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_471_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_471_i0 : Fin 2 → Finset Cell := ![(placed21 2 (3, 0) required_11), (placed21 5 (4, 1) required_354)] +def childrenD_471_i0 : Fin 2 → Finset Cell := ![(placed21 2 (3, 0) envelope_11), (placed21 5 (4, 1) envelope_354)] +theorem common_sub_471_i0 : commonEnvelope childrenD_471_i0 ⊆ insert (3, 4) required_471_i0 := by decide +kernel +theorem child_required_sub_471_i0 : ∀ j, childrenC_471_i0 j ⊆ insert (3, 4) required_471_i0 := by decide +kernel +theorem child_envelope_sub_471_i0 : ∀ j, childrenD_471_i0 j ⊆ envelope_471_i0 := by decide +kernel +theorem pivot_mem_471_i0 : (3, 4) ∈ envelope_471_i0 := by decide +kernel +theorem children_work_471_i0 : ∀ j, Template HasSnaky 4 (childrenC_471_i0 j) (childrenD_471_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 2 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_354 5 (4, 1)).mono (by decide +kernel) +theorem row_works_471_i0 : Template HasSnaky 5 required_471_i0 envelope_471_i0 := by + refine compose HasSnaky 4 childrenC_471_i0 childrenD_471_i0 children_work_471_i0 (3, 4) + required_471_i0 envelope_471_i0 pivot_mem_471_i0 child_required_sub_471_i0 child_envelope_sub_471_i0 ?_ + intro b hb + exact common_sub_471_i0 (mem_commonEnvelope childrenD_471_i0 b hb) +def required_471 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (2, 2), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_471 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_471 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), required_471_i0] +def childrenD_471 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), envelope_471_i0] +theorem common_sub_471 : commonEnvelope childrenD_471 ⊆ insert (3, 3) required_471 := by decide +kernel +theorem child_required_sub_471 : ∀ j, childrenC_471 j ⊆ insert (3, 3) required_471 := by decide +kernel +theorem child_envelope_sub_471 : ∀ j, childrenD_471 j ⊆ envelope_471 := by decide +kernel +theorem pivot_mem_471 : (3, 3) ∈ envelope_471 := by decide +kernel +theorem children_work_471 : ∀ j, Template HasSnaky 5 (childrenC_471 j) (childrenD_471 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact row_works_471_i0.mono (by decide +kernel) +theorem row_works_471 : Template HasSnaky 6 required_471 envelope_471 := by + refine compose HasSnaky 5 childrenC_471 childrenD_471 children_work_471 (3, 3) + required_471 envelope_471 pivot_mem_471 child_required_sub_471 child_envelope_sub_471 ?_ + intro b hb + exact common_sub_471 (mem_commonEnvelope childrenD_471 b hb) +def required_486_i2 : Finset Cell := ⟨(([(0, 1), (1, 2), (1, 3), (2, 3), (3, 2), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_486_i2 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (3, 2), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_486_i2 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) required_5), (placed21 3 (0, 4) required_156)] +def childrenD_486_i2 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) envelope_5), (placed21 3 (0, 4) envelope_156)] +theorem common_sub_486_i2 : commonEnvelope childrenD_486_i2 ⊆ insert (1, 4) required_486_i2 := by decide +kernel +theorem child_required_sub_486_i2 : ∀ j, childrenC_486_i2 j ⊆ insert (1, 4) required_486_i2 := by decide +kernel +theorem child_envelope_sub_486_i2 : ∀ j, childrenD_486_i2 j ⊆ envelope_486_i2 := by decide +kernel +theorem pivot_mem_486_i2 : (1, 4) ∈ envelope_486_i2 := by decide +kernel +theorem children_work_486_i2 : ∀ j, Template HasSnaky 2 (childrenC_486_i2 j) (childrenD_486_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_156 3 (0, 4)).mono (by decide +kernel) +theorem row_works_486_i2 : Template HasSnaky 3 required_486_i2 envelope_486_i2 := by + refine compose HasSnaky 2 childrenC_486_i2 childrenD_486_i2 children_work_486_i2 (1, 4) + required_486_i2 envelope_486_i2 pivot_mem_486_i2 child_required_sub_486_i2 child_envelope_sub_486_i2 ?_ + intro b hb + exact common_sub_486_i2 (mem_commonEnvelope childrenD_486_i2 b hb) +def required_486_i1 : Finset Cell := ⟨(([(0, 1), (1, 2), (1, 3), (2, 3), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_486_i1 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_486_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 3) required_5), required_486_i2] +def childrenD_486_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 3) envelope_5), envelope_486_i2] +theorem common_sub_486_i1 : commonEnvelope childrenD_486_i1 ⊆ insert (4, 2) required_486_i1 := by decide +kernel +theorem child_required_sub_486_i1 : ∀ j, childrenC_486_i1 j ⊆ insert (4, 2) required_486_i1 := by decide +kernel +theorem child_envelope_sub_486_i1 : ∀ j, childrenD_486_i1 j ⊆ envelope_486_i1 := by decide +kernel +theorem pivot_mem_486_i1 : (4, 2) ∈ envelope_486_i1 := by decide +kernel +theorem children_work_486_i1 : ∀ j, Template HasSnaky 3 (childrenC_486_i1 j) (childrenD_486_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (1, 3)).mono (by decide +kernel) + · exact row_works_486_i2.mono (by decide +kernel) +theorem row_works_486_i1 : Template HasSnaky 4 required_486_i1 envelope_486_i1 := by + refine compose HasSnaky 3 childrenC_486_i1 childrenD_486_i1 children_work_486_i1 (4, 2) + required_486_i1 envelope_486_i1 pivot_mem_486_i1 child_required_sub_486_i1 child_envelope_sub_486_i1 ?_ + intro b hb + exact common_sub_486_i1 (mem_commonEnvelope childrenD_486_i1 b hb) +def required_486_i0 : Finset Cell := ⟨(([(0, 1), (1, 3), (2, 3), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_486_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_486_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_5), required_486_i1] +def childrenD_486_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_5), envelope_486_i1] +theorem common_sub_486_i0 : commonEnvelope childrenD_486_i0 ⊆ insert (1, 2) required_486_i0 := by decide +kernel +theorem child_required_sub_486_i0 : ∀ j, childrenC_486_i0 j ⊆ insert (1, 2) required_486_i0 := by decide +kernel +theorem child_envelope_sub_486_i0 : ∀ j, childrenD_486_i0 j ⊆ envelope_486_i0 := by decide +kernel +theorem pivot_mem_486_i0 : (1, 2) ∈ envelope_486_i0 := by decide +kernel +theorem children_work_486_i0 : ∀ j, Template HasSnaky 4 (childrenC_486_i0 j) (childrenD_486_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 3)).mono (by decide +kernel) + · exact row_works_486_i1.mono (by decide +kernel) +theorem row_works_486_i0 : Template HasSnaky 5 required_486_i0 envelope_486_i0 := by + refine compose HasSnaky 4 childrenC_486_i0 childrenD_486_i0 children_work_486_i0 (1, 2) + required_486_i0 envelope_486_i0 pivot_mem_486_i0 child_required_sub_486_i0 child_envelope_sub_486_i0 ?_ + intro b hb + exact common_sub_486_i0 (mem_commonEnvelope childrenD_486_i0 b hb) +def required_486 : Finset Cell := ⟨(([(0, 1), (1, 3), (2, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_486 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_486 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) required_19), (placed21 1 (0, 2) required_84), (placed21 0 (1, 2) required_314), required_486_i0] +def childrenD_486 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) envelope_19), (placed21 1 (0, 2) envelope_84), (placed21 0 (1, 2) envelope_314), envelope_486_i0] +theorem common_sub_486 : commonEnvelope childrenD_486 ⊆ insert (4, 3) required_486 := by decide +kernel +theorem child_required_sub_486 : ∀ j, childrenC_486 j ⊆ insert (4, 3) required_486 := by decide +kernel +theorem child_envelope_sub_486 : ∀ j, childrenD_486 j ⊆ envelope_486 := by decide +kernel +theorem pivot_mem_486 : (4, 3) ∈ envelope_486 := by decide +kernel +theorem children_work_486 : ∀ j, Template HasSnaky 5 (childrenC_486 j) (childrenD_486 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_84 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_314 0 (1, 2)).mono (by decide +kernel) + · exact row_works_486_i0.mono (by decide +kernel) +theorem row_works_486 : Template HasSnaky 6 required_486 envelope_486 := by + refine compose HasSnaky 5 childrenC_486 childrenD_486 children_work_486 (4, 3) + required_486 envelope_486 pivot_mem_486 child_required_sub_486 child_envelope_sub_486 ?_ + intro b hb + exact common_sub_486 (mem_commonEnvelope childrenD_486 b hb) +def required_493 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (3, 1), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_493 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 3), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_493 : Fin 3 → Finset Cell := ![required_87, (placed21 5 (4, 1) required_197), required_492] +def childrenD_493 : Fin 3 → Finset Cell := ![envelope_87, (placed21 5 (4, 1) envelope_197), envelope_492] +theorem common_sub_493 : commonEnvelope childrenD_493 ⊆ insert (3, 3) required_493 := by decide +kernel +theorem child_required_sub_493 : ∀ j, childrenC_493 j ⊆ insert (3, 3) required_493 := by decide +kernel +theorem child_envelope_sub_493 : ∀ j, childrenD_493 j ⊆ envelope_493 := by decide +kernel +theorem pivot_mem_493 : (3, 3) ∈ envelope_493 := by decide +kernel +theorem children_work_493 : ∀ j, Template HasSnaky 5 (childrenC_493 j) (childrenD_493 j) := by + intro j + fin_cases j + · exact row_works_87.mono (by decide +kernel) + · exact (placed21_template row_works_197 5 (4, 1)).mono (by decide +kernel) + · exact row_works_492.mono (by decide +kernel) +theorem row_works_493 : Template HasSnaky 6 required_493 envelope_493 := by + refine compose HasSnaky 5 childrenC_493 childrenD_493 children_work_493 (3, 3) + required_493 envelope_493 pivot_mem_493 child_required_sub_493 child_envelope_sub_493 ?_ + intro b hb + exact common_sub_493 (mem_commonEnvelope childrenD_493 b hb) +def required_498 : Finset Cell := ⟨(([(1, 1), (1, 2), (3, 4), (4, 1), (4, 2), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_498 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (2, 1), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5), (8, 3), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_498 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_114), (placed21 2 (4, 0) required_496)] +def childrenD_498 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_114), (placed21 2 (4, 0) envelope_496)] +theorem common_sub_498 : commonEnvelope childrenD_498 ⊆ insert (4, 3) required_498 := by decide +kernel +theorem child_required_sub_498 : ∀ j, childrenC_498 j ⊆ insert (4, 3) required_498 := by decide +kernel +theorem child_envelope_sub_498 : ∀ j, childrenD_498 j ⊆ envelope_498 := by decide +kernel +theorem pivot_mem_498 : (4, 3) ∈ envelope_498 := by decide +kernel +theorem children_work_498 : ∀ j, Template HasSnaky 5 (childrenC_498 j) (childrenD_498 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_114 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_496 2 (4, 0)).mono (by decide +kernel) +theorem row_works_498 : Template HasSnaky 6 required_498 envelope_498 := by + refine compose HasSnaky 5 childrenC_498 childrenD_498 children_work_498 (4, 3) + required_498 envelope_498 pivot_mem_498 child_required_sub_498 child_envelope_sub_498 ?_ + intro b hb + exact common_sub_498 (mem_commonEnvelope childrenD_498 b hb) +def required_503 : Finset Cell := ⟨(([(1, 3), (3, 2), (3, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_503 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_503 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_0), required_502] +def childrenD_503 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_0), envelope_502] +theorem common_sub_503 : commonEnvelope childrenD_503 ⊆ insert (2, 3) required_503 := by decide +kernel +theorem child_required_sub_503 : ∀ j, childrenC_503 j ⊆ insert (2, 3) required_503 := by decide +kernel +theorem child_envelope_sub_503 : ∀ j, childrenD_503 j ⊆ envelope_503 := by decide +kernel +theorem pivot_mem_503 : (2, 3) ∈ envelope_503 := by decide +kernel +theorem children_work_503 : ∀ j, Template HasSnaky 5 (childrenC_503 j) (childrenD_503 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 4 (0, 3)).mono (by decide +kernel) + · exact row_works_502.mono (by decide +kernel) +theorem row_works_503 : Template HasSnaky 6 required_503 envelope_503 := by + refine compose HasSnaky 5 childrenC_503 childrenD_503 children_work_503 (2, 3) + required_503 envelope_503 pivot_mem_503 child_required_sub_503 child_envelope_sub_503 ?_ + intro b hb + exact common_sub_503 (mem_commonEnvelope childrenD_503 b hb) +def required_516_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_516_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_516_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_3), (placed21 6 (4, 4) required_83)] +def childrenD_516_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_3), (placed21 6 (4, 4) envelope_83)] +theorem common_sub_516_i0 : commonEnvelope childrenD_516_i0 ⊆ insert (2, 3) required_516_i0 := by decide +kernel +theorem child_required_sub_516_i0 : ∀ j, childrenC_516_i0 j ⊆ insert (2, 3) required_516_i0 := by decide +kernel +theorem child_envelope_sub_516_i0 : ∀ j, childrenD_516_i0 j ⊆ envelope_516_i0 := by decide +kernel +theorem pivot_mem_516_i0 : (2, 3) ∈ envelope_516_i0 := by decide +kernel +theorem children_work_516_i0 : ∀ j, Template HasSnaky 2 (childrenC_516_i0 j) (childrenD_516_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 6 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_83 6 (4, 4)).mono (by decide +kernel) +theorem row_works_516_i0 : Template HasSnaky 3 required_516_i0 envelope_516_i0 := by + refine compose HasSnaky 2 childrenC_516_i0 childrenD_516_i0 children_work_516_i0 (2, 3) + required_516_i0 envelope_516_i0 pivot_mem_516_i0 child_required_sub_516_i0 child_envelope_sub_516_i0 ?_ + intro b hb + exact common_sub_516_i0 (mem_commonEnvelope childrenD_516_i0 b hb) +def required_516 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_516 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_516 : Fin 3 → Finset Cell := ![(placed21 0 (3, 0) required_52), required_516_i0, (placed21 1 (0, 1) required_515)] +def childrenD_516 : Fin 3 → Finset Cell := ![(placed21 0 (3, 0) envelope_52), envelope_516_i0, (placed21 1 (0, 1) envelope_515)] +theorem common_sub_516 : commonEnvelope childrenD_516 ⊆ insert (4, 3) required_516 := by decide +kernel +theorem child_required_sub_516 : ∀ j, childrenC_516 j ⊆ insert (4, 3) required_516 := by decide +kernel +theorem child_envelope_sub_516 : ∀ j, childrenD_516 j ⊆ envelope_516 := by decide +kernel +theorem pivot_mem_516 : (4, 3) ∈ envelope_516 := by decide +kernel +theorem children_work_516 : ∀ j, Template HasSnaky 5 (childrenC_516 j) (childrenD_516 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 0 (3, 0)).mono (by decide +kernel) + · exact row_works_516_i0.mono (by decide +kernel) + · exact (placed21_template row_works_515 1 (0, 1)).mono (by decide +kernel) +theorem row_works_516 : Template HasSnaky 6 required_516 envelope_516 := by + refine compose HasSnaky 5 childrenC_516 childrenD_516 children_work_516 (4, 3) + required_516 envelope_516 pivot_mem_516 child_required_sub_516 child_envelope_sub_516 ?_ + intro b hb + exact common_sub_516 (mem_commonEnvelope childrenD_516 b hb) +def height_439_i1 : ℕ := 2 +def childrenH_439_i1 : Fin 2 → ℕ := ![height_2, height_5] +theorem height_exact_439_i1 : height_439_i1 = 1 + Finset.univ.sup childrenH_439_i1 := by decide +kernel +theorem required_origin_439_i1 : ∀ x ∈ required_439_i1, + (∃ j, x ∈ childrenC_439_i1 j) ∨ ∀ j, x ∈ childrenD_439_i1 j := by decide +kernel +theorem required_exact_439_i1 : required_439_i1 = + ((Finset.univ.biUnion childrenC_439_i1) ∪ commonEnvelope childrenD_439_i1).erase (4, 2) := by + exact required_eq_combination childrenC_439_i1 childrenD_439_i1 (4, 2) required_439_i1 + (by decide +kernel) child_required_sub_439_i1 common_sub_439_i1 required_origin_439_i1 +theorem envelope_origin_439_i1 : ∀ x ∈ envelope_439_i1, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_439_i1 j := by decide +kernel +theorem envelope_exact_439_i1 : envelope_439_i1 = + insert (4, 2) (Finset.univ.biUnion childrenD_439_i1) := by + exact envelope_eq_combination childrenD_439_i1 (4, 2) envelope_439_i1 + pivot_mem_439_i1 child_envelope_sub_439_i1 envelope_origin_439_i1 +def checked_439_i1 : CheckedCard where + required := required_439_i1 + envelope := envelope_439_i1 + height := height_439_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_439_i1 +def height_439_i4 : ℕ := 2 +def childrenH_439_i4 : Fin 2 → ℕ := ![height_5, height_5] +theorem height_exact_439_i4 : height_439_i4 = 1 + Finset.univ.sup childrenH_439_i4 := by decide +kernel +theorem required_origin_439_i4 : ∀ x ∈ required_439_i4, + (∃ j, x ∈ childrenC_439_i4 j) ∨ ∀ j, x ∈ childrenD_439_i4 j := by decide +kernel +theorem required_exact_439_i4 : required_439_i4 = + ((Finset.univ.biUnion childrenC_439_i4) ∪ commonEnvelope childrenD_439_i4).erase (4, 1) := by + exact required_eq_combination childrenC_439_i4 childrenD_439_i4 (4, 1) required_439_i4 + (by decide +kernel) child_required_sub_439_i4 common_sub_439_i4 required_origin_439_i4 +theorem envelope_origin_439_i4 : ∀ x ∈ envelope_439_i4, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_439_i4 j := by decide +kernel +theorem envelope_exact_439_i4 : envelope_439_i4 = + insert (4, 1) (Finset.univ.biUnion childrenD_439_i4) := by + exact envelope_eq_combination childrenD_439_i4 (4, 1) envelope_439_i4 + pivot_mem_439_i4 child_envelope_sub_439_i4 envelope_origin_439_i4 +def checked_439_i4 : CheckedCard where + required := required_439_i4 + envelope := envelope_439_i4 + height := height_439_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_439_i4 +def height_439_i3 : ℕ := 3 +def childrenH_439_i3 : Fin 2 → ℕ := ![height_5, height_439_i4] +theorem height_exact_439_i3 : height_439_i3 = 1 + Finset.univ.sup childrenH_439_i3 := by decide +kernel +theorem required_origin_439_i3 : ∀ x ∈ required_439_i3, + (∃ j, x ∈ childrenC_439_i3 j) ∨ ∀ j, x ∈ childrenD_439_i3 j := by decide +kernel +theorem required_exact_439_i3 : required_439_i3 = + ((Finset.univ.biUnion childrenC_439_i3) ∪ commonEnvelope childrenD_439_i3).erase (3, 1) := by + exact required_eq_combination childrenC_439_i3 childrenD_439_i3 (3, 1) required_439_i3 + (by decide +kernel) child_required_sub_439_i3 common_sub_439_i3 required_origin_439_i3 +theorem envelope_origin_439_i3 : ∀ x ∈ envelope_439_i3, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_439_i3 j := by decide +kernel +theorem envelope_exact_439_i3 : envelope_439_i3 = + insert (3, 1) (Finset.univ.biUnion childrenD_439_i3) := by + exact envelope_eq_combination childrenD_439_i3 (3, 1) envelope_439_i3 + pivot_mem_439_i3 child_envelope_sub_439_i3 envelope_origin_439_i3 +def checked_439_i3 : CheckedCard where + required := required_439_i3 + envelope := envelope_439_i3 + height := height_439_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_439_i3 +def height_439_i2 : ℕ := 4 +def childrenH_439_i2 : Fin 2 → ℕ := ![height_4, height_439_i3] +theorem height_exact_439_i2 : height_439_i2 = 1 + Finset.univ.sup childrenH_439_i2 := by decide +kernel +theorem required_origin_439_i2 : ∀ x ∈ required_439_i2, + (∃ j, x ∈ childrenC_439_i2 j) ∨ ∀ j, x ∈ childrenD_439_i2 j := by decide +kernel +theorem required_exact_439_i2 : required_439_i2 = + ((Finset.univ.biUnion childrenC_439_i2) ∪ commonEnvelope childrenD_439_i2).erase (2, 1) := by + exact required_eq_combination childrenC_439_i2 childrenD_439_i2 (2, 1) required_439_i2 + (by decide +kernel) child_required_sub_439_i2 common_sub_439_i2 required_origin_439_i2 +theorem envelope_origin_439_i2 : ∀ x ∈ envelope_439_i2, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_439_i2 j := by decide +kernel +theorem envelope_exact_439_i2 : envelope_439_i2 = + insert (2, 1) (Finset.univ.biUnion childrenD_439_i2) := by + exact envelope_eq_combination childrenD_439_i2 (2, 1) envelope_439_i2 + pivot_mem_439_i2 child_envelope_sub_439_i2 envelope_origin_439_i2 +def checked_439_i2 : CheckedCard where + required := required_439_i2 + envelope := envelope_439_i2 + height := height_439_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_439_i2 +def height_439_i0 : ℕ := 5 +def childrenH_439_i0 : Fin 4 → ℕ := ![height_251, height_432, height_439_i1, height_439_i2] +theorem height_exact_439_i0 : height_439_i0 = 1 + Finset.univ.sup childrenH_439_i0 := by decide +kernel +theorem required_origin_439_i0 : ∀ x ∈ required_439_i0, + (∃ j, x ∈ childrenC_439_i0 j) ∨ ∀ j, x ∈ childrenD_439_i0 j := by decide +kernel +theorem required_exact_439_i0 : required_439_i0 = + ((Finset.univ.biUnion childrenC_439_i0) ∪ commonEnvelope childrenD_439_i0).erase (3, 2) := by + exact required_eq_combination childrenC_439_i0 childrenD_439_i0 (3, 2) required_439_i0 + (by decide +kernel) child_required_sub_439_i0 common_sub_439_i0 required_origin_439_i0 +theorem envelope_origin_439_i0 : ∀ x ∈ envelope_439_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_439_i0 j := by decide +kernel +theorem envelope_exact_439_i0 : envelope_439_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_439_i0) := by + exact envelope_eq_combination childrenD_439_i0 (3, 2) envelope_439_i0 + pivot_mem_439_i0 child_envelope_sub_439_i0 envelope_origin_439_i0 +def checked_439_i0 : CheckedCard where + required := required_439_i0 + envelope := envelope_439_i0 + height := height_439_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_439_i0 +def height_439 : ℕ := 6 +def childrenH_439 : Fin 2 → ℕ := ![height_5, height_439_i0] +theorem height_exact_439 : height_439 = 1 + Finset.univ.sup childrenH_439 := by decide +kernel +theorem required_origin_439 : ∀ x ∈ required_439, + (∃ j, x ∈ childrenC_439 j) ∨ ∀ j, x ∈ childrenD_439 j := by decide +kernel +theorem required_exact_439 : required_439 = + ((Finset.univ.biUnion childrenC_439) ∪ commonEnvelope childrenD_439).erase (3, 3) := by + exact required_eq_combination childrenC_439 childrenD_439 (3, 3) required_439 + (by decide +kernel) child_required_sub_439 common_sub_439 required_origin_439 +theorem envelope_origin_439 : ∀ x ∈ envelope_439, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_439 j := by decide +kernel +theorem envelope_exact_439 : envelope_439 = + insert (3, 3) (Finset.univ.biUnion childrenD_439) := by + exact envelope_eq_combination childrenD_439 (3, 3) envelope_439 + pivot_mem_439 child_envelope_sub_439 envelope_origin_439 +def checked_439 : CheckedCard where + required := required_439 + envelope := envelope_439 + height := height_439 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_439 +def height_465_i3 : ℕ := 2 +def childrenH_465_i3 : Fin 2 → ℕ := ![height_4, height_4] +theorem height_exact_465_i3 : height_465_i3 = 1 + Finset.univ.sup childrenH_465_i3 := by decide +kernel +theorem required_origin_465_i3 : ∀ x ∈ required_465_i3, + (∃ j, x ∈ childrenC_465_i3 j) ∨ ∀ j, x ∈ childrenD_465_i3 j := by decide +kernel +theorem required_exact_465_i3 : required_465_i3 = + ((Finset.univ.biUnion childrenC_465_i3) ∪ commonEnvelope childrenD_465_i3).erase (3, 4) := by + exact required_eq_combination childrenC_465_i3 childrenD_465_i3 (3, 4) required_465_i3 + (by decide +kernel) child_required_sub_465_i3 common_sub_465_i3 required_origin_465_i3 +theorem envelope_origin_465_i3 : ∀ x ∈ envelope_465_i3, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_465_i3 j := by decide +kernel +theorem envelope_exact_465_i3 : envelope_465_i3 = + insert (3, 4) (Finset.univ.biUnion childrenD_465_i3) := by + exact envelope_eq_combination childrenD_465_i3 (3, 4) envelope_465_i3 + pivot_mem_465_i3 child_envelope_sub_465_i3 envelope_origin_465_i3 +def checked_465_i3 : CheckedCard where + required := required_465_i3 + envelope := envelope_465_i3 + height := height_465_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_465_i3 +def height_465_i2 : ℕ := 3 +def childrenH_465_i2 : Fin 2 → ℕ := ![height_5, height_465_i3] +theorem height_exact_465_i2 : height_465_i2 = 1 + Finset.univ.sup childrenH_465_i2 := by decide +kernel +theorem required_origin_465_i2 : ∀ x ∈ required_465_i2, + (∃ j, x ∈ childrenC_465_i2 j) ∨ ∀ j, x ∈ childrenD_465_i2 j := by decide +kernel +theorem required_exact_465_i2 : required_465_i2 = + ((Finset.univ.biUnion childrenC_465_i2) ∪ commonEnvelope childrenD_465_i2).erase (2, 4) := by + exact required_eq_combination childrenC_465_i2 childrenD_465_i2 (2, 4) required_465_i2 + (by decide +kernel) child_required_sub_465_i2 common_sub_465_i2 required_origin_465_i2 +theorem envelope_origin_465_i2 : ∀ x ∈ envelope_465_i2, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_465_i2 j := by decide +kernel +theorem envelope_exact_465_i2 : envelope_465_i2 = + insert (2, 4) (Finset.univ.biUnion childrenD_465_i2) := by + exact envelope_eq_combination childrenD_465_i2 (2, 4) envelope_465_i2 + pivot_mem_465_i2 child_envelope_sub_465_i2 envelope_origin_465_i2 +def checked_465_i2 : CheckedCard where + required := required_465_i2 + envelope := envelope_465_i2 + height := height_465_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_465_i2 +def height_465_i1 : ℕ := 4 +def childrenH_465_i1 : Fin 2 → ℕ := ![height_5, height_465_i2] +theorem height_exact_465_i1 : height_465_i1 = 1 + Finset.univ.sup childrenH_465_i1 := by decide +kernel +theorem required_origin_465_i1 : ∀ x ∈ required_465_i1, + (∃ j, x ∈ childrenC_465_i1 j) ∨ ∀ j, x ∈ childrenD_465_i1 j := by decide +kernel +theorem required_exact_465_i1 : required_465_i1 = + ((Finset.univ.biUnion childrenC_465_i1) ∪ commonEnvelope childrenD_465_i1).erase (0, 4) := by + exact required_eq_combination childrenC_465_i1 childrenD_465_i1 (0, 4) required_465_i1 + (by decide +kernel) child_required_sub_465_i1 common_sub_465_i1 required_origin_465_i1 +theorem envelope_origin_465_i1 : ∀ x ∈ envelope_465_i1, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_465_i1 j := by decide +kernel +theorem envelope_exact_465_i1 : envelope_465_i1 = + insert (0, 4) (Finset.univ.biUnion childrenD_465_i1) := by + exact envelope_eq_combination childrenD_465_i1 (0, 4) envelope_465_i1 + pivot_mem_465_i1 child_envelope_sub_465_i1 envelope_origin_465_i1 +def checked_465_i1 : CheckedCard where + required := required_465_i1 + envelope := envelope_465_i1 + height := height_465_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_465_i1 +def height_465_i0 : ℕ := 5 +def childrenH_465_i0 : Fin 3 → ℕ := ![height_39, height_42, height_465_i1] +theorem height_exact_465_i0 : height_465_i0 = 1 + Finset.univ.sup childrenH_465_i0 := by decide +kernel +theorem required_origin_465_i0 : ∀ x ∈ required_465_i0, + (∃ j, x ∈ childrenC_465_i0 j) ∨ ∀ j, x ∈ childrenD_465_i0 j := by decide +kernel +theorem required_exact_465_i0 : required_465_i0 = + ((Finset.univ.biUnion childrenC_465_i0) ∪ commonEnvelope childrenD_465_i0).erase (4, 5) := by + exact required_eq_combination childrenC_465_i0 childrenD_465_i0 (4, 5) required_465_i0 + (by decide +kernel) child_required_sub_465_i0 common_sub_465_i0 required_origin_465_i0 +theorem envelope_origin_465_i0 : ∀ x ∈ envelope_465_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_465_i0 j := by decide +kernel +theorem envelope_exact_465_i0 : envelope_465_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_465_i0) := by + exact envelope_eq_combination childrenD_465_i0 (4, 5) envelope_465_i0 + pivot_mem_465_i0 child_envelope_sub_465_i0 envelope_origin_465_i0 +def checked_465_i0 : CheckedCard where + required := required_465_i0 + envelope := envelope_465_i0 + height := height_465_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_465_i0 +def height_465 : ℕ := 6 +def childrenH_465 : Fin 2 → ℕ := ![height_25, height_465_i0] +theorem height_exact_465 : height_465 = 1 + Finset.univ.sup childrenH_465 := by decide +kernel +theorem required_origin_465 : ∀ x ∈ required_465, + (∃ j, x ∈ childrenC_465 j) ∨ ∀ j, x ∈ childrenD_465 j := by decide +kernel +theorem required_exact_465 : required_465 = + ((Finset.univ.biUnion childrenC_465) ∪ commonEnvelope childrenD_465).erase (3, 2) := by + exact required_eq_combination childrenC_465 childrenD_465 (3, 2) required_465 + (by decide +kernel) child_required_sub_465 common_sub_465 required_origin_465 +theorem envelope_origin_465 : ∀ x ∈ envelope_465, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_465 j := by decide +kernel +theorem envelope_exact_465 : envelope_465 = + insert (3, 2) (Finset.univ.biUnion childrenD_465) := by + exact envelope_eq_combination childrenD_465 (3, 2) envelope_465 + pivot_mem_465 child_envelope_sub_465 envelope_origin_465 +def checked_465 : CheckedCard where + required := required_465 + envelope := envelope_465 + height := height_465 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_465 +def height_471_i0 : ℕ := 5 +def childrenH_471_i0 : Fin 2 → ℕ := ![height_11, height_354] +theorem height_exact_471_i0 : height_471_i0 = 1 + Finset.univ.sup childrenH_471_i0 := by decide +kernel +theorem required_origin_471_i0 : ∀ x ∈ required_471_i0, + (∃ j, x ∈ childrenC_471_i0 j) ∨ ∀ j, x ∈ childrenD_471_i0 j := by decide +kernel +theorem required_exact_471_i0 : required_471_i0 = + ((Finset.univ.biUnion childrenC_471_i0) ∪ commonEnvelope childrenD_471_i0).erase (3, 4) := by + exact required_eq_combination childrenC_471_i0 childrenD_471_i0 (3, 4) required_471_i0 + (by decide +kernel) child_required_sub_471_i0 common_sub_471_i0 required_origin_471_i0 +theorem envelope_origin_471_i0 : ∀ x ∈ envelope_471_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_471_i0 j := by decide +kernel +theorem envelope_exact_471_i0 : envelope_471_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_471_i0) := by + exact envelope_eq_combination childrenD_471_i0 (3, 4) envelope_471_i0 + pivot_mem_471_i0 child_envelope_sub_471_i0 envelope_origin_471_i0 +def checked_471_i0 : CheckedCard where + required := required_471_i0 + envelope := envelope_471_i0 + height := height_471_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_471_i0 +def height_471 : ℕ := 6 +def childrenH_471 : Fin 2 → ℕ := ![height_5, height_471_i0] +theorem height_exact_471 : height_471 = 1 + Finset.univ.sup childrenH_471 := by decide +kernel +theorem required_origin_471 : ∀ x ∈ required_471, + (∃ j, x ∈ childrenC_471 j) ∨ ∀ j, x ∈ childrenD_471 j := by decide +kernel +theorem required_exact_471 : required_471 = + ((Finset.univ.biUnion childrenC_471) ∪ commonEnvelope childrenD_471).erase (3, 3) := by + exact required_eq_combination childrenC_471 childrenD_471 (3, 3) required_471 + (by decide +kernel) child_required_sub_471 common_sub_471 required_origin_471 +theorem envelope_origin_471 : ∀ x ∈ envelope_471, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_471 j := by decide +kernel +theorem envelope_exact_471 : envelope_471 = + insert (3, 3) (Finset.univ.biUnion childrenD_471) := by + exact envelope_eq_combination childrenD_471 (3, 3) envelope_471 + pivot_mem_471 child_envelope_sub_471 envelope_origin_471 +def checked_471 : CheckedCard where + required := required_471 + envelope := envelope_471 + height := height_471 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_471 +def height_486_i2 : ℕ := 3 +def childrenH_486_i2 : Fin 2 → ℕ := ![height_5, height_156] +theorem height_exact_486_i2 : height_486_i2 = 1 + Finset.univ.sup childrenH_486_i2 := by decide +kernel +theorem required_origin_486_i2 : ∀ x ∈ required_486_i2, + (∃ j, x ∈ childrenC_486_i2 j) ∨ ∀ j, x ∈ childrenD_486_i2 j := by decide +kernel +theorem required_exact_486_i2 : required_486_i2 = + ((Finset.univ.biUnion childrenC_486_i2) ∪ commonEnvelope childrenD_486_i2).erase (1, 4) := by + exact required_eq_combination childrenC_486_i2 childrenD_486_i2 (1, 4) required_486_i2 + (by decide +kernel) child_required_sub_486_i2 common_sub_486_i2 required_origin_486_i2 +theorem envelope_origin_486_i2 : ∀ x ∈ envelope_486_i2, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_486_i2 j := by decide +kernel +theorem envelope_exact_486_i2 : envelope_486_i2 = + insert (1, 4) (Finset.univ.biUnion childrenD_486_i2) := by + exact envelope_eq_combination childrenD_486_i2 (1, 4) envelope_486_i2 + pivot_mem_486_i2 child_envelope_sub_486_i2 envelope_origin_486_i2 +def checked_486_i2 : CheckedCard where + required := required_486_i2 + envelope := envelope_486_i2 + height := height_486_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_486_i2 +def height_486_i1 : ℕ := 4 +def childrenH_486_i1 : Fin 2 → ℕ := ![height_5, height_486_i2] +theorem height_exact_486_i1 : height_486_i1 = 1 + Finset.univ.sup childrenH_486_i1 := by decide +kernel +theorem required_origin_486_i1 : ∀ x ∈ required_486_i1, + (∃ j, x ∈ childrenC_486_i1 j) ∨ ∀ j, x ∈ childrenD_486_i1 j := by decide +kernel +theorem required_exact_486_i1 : required_486_i1 = + ((Finset.univ.biUnion childrenC_486_i1) ∪ commonEnvelope childrenD_486_i1).erase (4, 2) := by + exact required_eq_combination childrenC_486_i1 childrenD_486_i1 (4, 2) required_486_i1 + (by decide +kernel) child_required_sub_486_i1 common_sub_486_i1 required_origin_486_i1 +theorem envelope_origin_486_i1 : ∀ x ∈ envelope_486_i1, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_486_i1 j := by decide +kernel +theorem envelope_exact_486_i1 : envelope_486_i1 = + insert (4, 2) (Finset.univ.biUnion childrenD_486_i1) := by + exact envelope_eq_combination childrenD_486_i1 (4, 2) envelope_486_i1 + pivot_mem_486_i1 child_envelope_sub_486_i1 envelope_origin_486_i1 +def checked_486_i1 : CheckedCard where + required := required_486_i1 + envelope := envelope_486_i1 + height := height_486_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_486_i1 +def height_486_i0 : ℕ := 5 +def childrenH_486_i0 : Fin 2 → ℕ := ![height_5, height_486_i1] +theorem height_exact_486_i0 : height_486_i0 = 1 + Finset.univ.sup childrenH_486_i0 := by decide +kernel +theorem required_origin_486_i0 : ∀ x ∈ required_486_i0, + (∃ j, x ∈ childrenC_486_i0 j) ∨ ∀ j, x ∈ childrenD_486_i0 j := by decide +kernel +theorem required_exact_486_i0 : required_486_i0 = + ((Finset.univ.biUnion childrenC_486_i0) ∪ commonEnvelope childrenD_486_i0).erase (1, 2) := by + exact required_eq_combination childrenC_486_i0 childrenD_486_i0 (1, 2) required_486_i0 + (by decide +kernel) child_required_sub_486_i0 common_sub_486_i0 required_origin_486_i0 +theorem envelope_origin_486_i0 : ∀ x ∈ envelope_486_i0, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_486_i0 j := by decide +kernel +theorem envelope_exact_486_i0 : envelope_486_i0 = + insert (1, 2) (Finset.univ.biUnion childrenD_486_i0) := by + exact envelope_eq_combination childrenD_486_i0 (1, 2) envelope_486_i0 + pivot_mem_486_i0 child_envelope_sub_486_i0 envelope_origin_486_i0 +def checked_486_i0 : CheckedCard where + required := required_486_i0 + envelope := envelope_486_i0 + height := height_486_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_486_i0 +def height_486 : ℕ := 6 +def childrenH_486 : Fin 4 → ℕ := ![height_19, height_84, height_314, height_486_i0] +theorem height_exact_486 : height_486 = 1 + Finset.univ.sup childrenH_486 := by decide +kernel +theorem required_origin_486 : ∀ x ∈ required_486, + (∃ j, x ∈ childrenC_486 j) ∨ ∀ j, x ∈ childrenD_486 j := by decide +kernel +theorem required_exact_486 : required_486 = + ((Finset.univ.biUnion childrenC_486) ∪ commonEnvelope childrenD_486).erase (4, 3) := by + exact required_eq_combination childrenC_486 childrenD_486 (4, 3) required_486 + (by decide +kernel) child_required_sub_486 common_sub_486 required_origin_486 +theorem envelope_origin_486 : ∀ x ∈ envelope_486, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_486 j := by decide +kernel +theorem envelope_exact_486 : envelope_486 = + insert (4, 3) (Finset.univ.biUnion childrenD_486) := by + exact envelope_eq_combination childrenD_486 (4, 3) envelope_486 + pivot_mem_486 child_envelope_sub_486 envelope_origin_486 +def checked_486 : CheckedCard where + required := required_486 + envelope := envelope_486 + height := height_486 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_486 +def height_493 : ℕ := 6 +def childrenH_493 : Fin 3 → ℕ := ![height_87, height_197, height_492] +theorem height_exact_493 : height_493 = 1 + Finset.univ.sup childrenH_493 := by decide +kernel +theorem required_origin_493 : ∀ x ∈ required_493, + (∃ j, x ∈ childrenC_493 j) ∨ ∀ j, x ∈ childrenD_493 j := by decide +kernel +theorem required_exact_493 : required_493 = + ((Finset.univ.biUnion childrenC_493) ∪ commonEnvelope childrenD_493).erase (3, 3) := by + exact required_eq_combination childrenC_493 childrenD_493 (3, 3) required_493 + (by decide +kernel) child_required_sub_493 common_sub_493 required_origin_493 +theorem envelope_origin_493 : ∀ x ∈ envelope_493, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_493 j := by decide +kernel +theorem envelope_exact_493 : envelope_493 = + insert (3, 3) (Finset.univ.biUnion childrenD_493) := by + exact envelope_eq_combination childrenD_493 (3, 3) envelope_493 + pivot_mem_493 child_envelope_sub_493 envelope_origin_493 +def checked_493 : CheckedCard where + required := required_493 + envelope := envelope_493 + height := height_493 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_493 +def height_498 : ℕ := 6 +def childrenH_498 : Fin 2 → ℕ := ![height_114, height_496] +theorem height_exact_498 : height_498 = 1 + Finset.univ.sup childrenH_498 := by decide +kernel +theorem required_origin_498 : ∀ x ∈ required_498, + (∃ j, x ∈ childrenC_498 j) ∨ ∀ j, x ∈ childrenD_498 j := by decide +kernel +theorem required_exact_498 : required_498 = + ((Finset.univ.biUnion childrenC_498) ∪ commonEnvelope childrenD_498).erase (4, 3) := by + exact required_eq_combination childrenC_498 childrenD_498 (4, 3) required_498 + (by decide +kernel) child_required_sub_498 common_sub_498 required_origin_498 +theorem envelope_origin_498 : ∀ x ∈ envelope_498, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_498 j := by decide +kernel +theorem envelope_exact_498 : envelope_498 = + insert (4, 3) (Finset.univ.biUnion childrenD_498) := by + exact envelope_eq_combination childrenD_498 (4, 3) envelope_498 + pivot_mem_498 child_envelope_sub_498 envelope_origin_498 +def checked_498 : CheckedCard where + required := required_498 + envelope := envelope_498 + height := height_498 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_498 +def height_503 : ℕ := 6 +def childrenH_503 : Fin 2 → ℕ := ![height_0, height_502] +theorem height_exact_503 : height_503 = 1 + Finset.univ.sup childrenH_503 := by decide +kernel +theorem required_origin_503 : ∀ x ∈ required_503, + (∃ j, x ∈ childrenC_503 j) ∨ ∀ j, x ∈ childrenD_503 j := by decide +kernel +theorem required_exact_503 : required_503 = + ((Finset.univ.biUnion childrenC_503) ∪ commonEnvelope childrenD_503).erase (2, 3) := by + exact required_eq_combination childrenC_503 childrenD_503 (2, 3) required_503 + (by decide +kernel) child_required_sub_503 common_sub_503 required_origin_503 +theorem envelope_origin_503 : ∀ x ∈ envelope_503, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_503 j := by decide +kernel +theorem envelope_exact_503 : envelope_503 = + insert (2, 3) (Finset.univ.biUnion childrenD_503) := by + exact envelope_eq_combination childrenD_503 (2, 3) envelope_503 + pivot_mem_503 child_envelope_sub_503 envelope_origin_503 +def checked_503 : CheckedCard where + required := required_503 + envelope := envelope_503 + height := height_503 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_503 +def height_516_i0 : ℕ := 3 +def childrenH_516_i0 : Fin 2 → ℕ := ![height_3, height_83] +theorem height_exact_516_i0 : height_516_i0 = 1 + Finset.univ.sup childrenH_516_i0 := by decide +kernel +theorem required_origin_516_i0 : ∀ x ∈ required_516_i0, + (∃ j, x ∈ childrenC_516_i0 j) ∨ ∀ j, x ∈ childrenD_516_i0 j := by decide +kernel +theorem required_exact_516_i0 : required_516_i0 = + ((Finset.univ.biUnion childrenC_516_i0) ∪ commonEnvelope childrenD_516_i0).erase (2, 3) := by + exact required_eq_combination childrenC_516_i0 childrenD_516_i0 (2, 3) required_516_i0 + (by decide +kernel) child_required_sub_516_i0 common_sub_516_i0 required_origin_516_i0 +theorem envelope_origin_516_i0 : ∀ x ∈ envelope_516_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_516_i0 j := by decide +kernel +theorem envelope_exact_516_i0 : envelope_516_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_516_i0) := by + exact envelope_eq_combination childrenD_516_i0 (2, 3) envelope_516_i0 + pivot_mem_516_i0 child_envelope_sub_516_i0 envelope_origin_516_i0 +def checked_516_i0 : CheckedCard where + required := required_516_i0 + envelope := envelope_516_i0 + height := height_516_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_516_i0 +def height_516 : ℕ := 6 +def childrenH_516 : Fin 3 → ℕ := ![height_52, height_516_i0, height_515] +theorem height_exact_516 : height_516 = 1 + Finset.univ.sup childrenH_516 := by decide +kernel +theorem required_origin_516 : ∀ x ∈ required_516, + (∃ j, x ∈ childrenC_516 j) ∨ ∀ j, x ∈ childrenD_516 j := by decide +kernel +theorem required_exact_516 : required_516 = + ((Finset.univ.biUnion childrenC_516) ∪ commonEnvelope childrenD_516).erase (4, 3) := by + exact required_eq_combination childrenC_516 childrenD_516 (4, 3) required_516 + (by decide +kernel) child_required_sub_516 common_sub_516 required_origin_516 +theorem envelope_origin_516 : ∀ x ∈ envelope_516, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_516 j := by decide +kernel +theorem envelope_exact_516 : envelope_516 = + insert (4, 3) (Finset.univ.biUnion childrenD_516) := by + exact envelope_eq_combination childrenD_516 (4, 3) envelope_516 + pivot_mem_516 child_envelope_sub_516 envelope_origin_516 +def checked_516 : CheckedCard where + required := required_516 + envelope := envelope_516 + height := height_516 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_516 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part06.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part06.lean new file mode 100644 index 0000000..b49b045 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part06.lean @@ -0,0 +1,927 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_521_i1 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_521_i1 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 4), (3, 5), (4, 1), (4, 4), (5, 1), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_521_i1 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_45), (placed21 3 (0, 4) required_45)] +def childrenD_521_i1 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_45), (placed21 3 (0, 4) envelope_45)] +theorem common_sub_521_i1 : commonEnvelope childrenD_521_i1 ⊆ insert (2, 3) required_521_i1 := by decide +kernel +theorem child_required_sub_521_i1 : ∀ j, childrenC_521_i1 j ⊆ insert (2, 3) required_521_i1 := by decide +kernel +theorem child_envelope_sub_521_i1 : ∀ j, childrenD_521_i1 j ⊆ envelope_521_i1 := by decide +kernel +theorem pivot_mem_521_i1 : (2, 3) ∈ envelope_521_i1 := by decide +kernel +theorem children_work_521_i1 : ∀ j, Template HasSnaky 3 (childrenC_521_i1 j) (childrenD_521_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_45 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_45 3 (0, 4)).mono (by decide +kernel) +theorem row_works_521_i1 : Template HasSnaky 4 required_521_i1 envelope_521_i1 := by + refine compose HasSnaky 3 childrenC_521_i1 childrenD_521_i1 children_work_521_i1 (2, 3) + required_521_i1 envelope_521_i1 pivot_mem_521_i1 child_required_sub_521_i1 child_envelope_sub_521_i1 ?_ + intro b hb + exact common_sub_521_i1 (mem_commonEnvelope childrenD_521_i1 b hb) +def required_521_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_521_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 4), (3, 5), (4, 1), (4, 4), (5, 1), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_521_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), required_521_i1] +def childrenD_521_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), envelope_521_i1] +theorem common_sub_521_i0 : commonEnvelope childrenD_521_i0 ⊆ insert (2, 4) required_521_i0 := by decide +kernel +theorem child_required_sub_521_i0 : ∀ j, childrenC_521_i0 j ⊆ insert (2, 4) required_521_i0 := by decide +kernel +theorem child_envelope_sub_521_i0 : ∀ j, childrenD_521_i0 j ⊆ envelope_521_i0 := by decide +kernel +theorem pivot_mem_521_i0 : (2, 4) ∈ envelope_521_i0 := by decide +kernel +theorem children_work_521_i0 : ∀ j, Template HasSnaky 4 (childrenC_521_i0 j) (childrenD_521_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact row_works_521_i1.mono (by decide +kernel) +theorem row_works_521_i0 : Template HasSnaky 5 required_521_i0 envelope_521_i0 := by + refine compose HasSnaky 4 childrenC_521_i0 childrenD_521_i0 children_work_521_i0 (2, 4) + required_521_i0 envelope_521_i0 pivot_mem_521_i0 child_required_sub_521_i0 child_envelope_sub_521_i0 ?_ + intro b hb + exact common_sub_521_i0 (mem_commonEnvelope childrenD_521_i0 b hb) +def required_521 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_521 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 4), (3, 5), (4, 1), (4, 4), (5, 1), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_521 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), required_521_i0] +def childrenD_521 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), envelope_521_i0] +theorem common_sub_521 : commonEnvelope childrenD_521 ⊆ insert (2, 1) required_521 := by decide +kernel +theorem child_required_sub_521 : ∀ j, childrenC_521 j ⊆ insert (2, 1) required_521 := by decide +kernel +theorem child_envelope_sub_521 : ∀ j, childrenD_521 j ⊆ envelope_521 := by decide +kernel +theorem pivot_mem_521 : (2, 1) ∈ envelope_521 := by decide +kernel +theorem children_work_521 : ∀ j, Template HasSnaky 5 (childrenC_521 j) (childrenD_521 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact row_works_521_i0.mono (by decide +kernel) +theorem row_works_521 : Template HasSnaky 6 required_521 envelope_521 := by + refine compose HasSnaky 5 childrenC_521 childrenD_521 children_work_521 (2, 1) + required_521 envelope_521 pivot_mem_521 child_required_sub_521 child_envelope_sub_521 ?_ + intro b hb + exact common_sub_521 (mem_commonEnvelope childrenD_521 b hb) +def required_525_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (3, 0), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_525_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_525_i1 : Fin 3 → Finset Cell := ![(placed21 2 (3, 0) required_21), (placed21 0 (2, 0) required_37), (placed21 5 (4, 0) required_78)] +def childrenD_525_i1 : Fin 3 → Finset Cell := ![(placed21 2 (3, 0) envelope_21), (placed21 0 (2, 0) envelope_37), (placed21 5 (4, 0) envelope_78)] +theorem common_sub_525_i1 : commonEnvelope childrenD_525_i1 ⊆ insert (3, 3) required_525_i1 := by decide +kernel +theorem child_required_sub_525_i1 : ∀ j, childrenC_525_i1 j ⊆ insert (3, 3) required_525_i1 := by decide +kernel +theorem child_envelope_sub_525_i1 : ∀ j, childrenD_525_i1 j ⊆ envelope_525_i1 := by decide +kernel +theorem pivot_mem_525_i1 : (3, 3) ∈ envelope_525_i1 := by decide +kernel +theorem children_work_525_i1 : ∀ j, Template HasSnaky 3 (childrenC_525_i1 j) (childrenD_525_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 2 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_37 0 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_78 5 (4, 0)).mono (by decide +kernel) +theorem row_works_525_i1 : Template HasSnaky 4 required_525_i1 envelope_525_i1 := by + refine compose HasSnaky 3 childrenC_525_i1 childrenD_525_i1 children_work_525_i1 (3, 3) + required_525_i1 envelope_525_i1 pivot_mem_525_i1 child_required_sub_525_i1 child_envelope_sub_525_i1 ?_ + intro b hb + exact common_sub_525_i1 (mem_commonEnvelope childrenD_525_i1 b hb) +def required_525_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (3, 0), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_525_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_525_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), required_525_i1] +def childrenD_525_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), envelope_525_i1] +theorem common_sub_525_i0 : commonEnvelope childrenD_525_i0 ⊆ insert (3, 2) required_525_i0 := by decide +kernel +theorem child_required_sub_525_i0 : ∀ j, childrenC_525_i0 j ⊆ insert (3, 2) required_525_i0 := by decide +kernel +theorem child_envelope_sub_525_i0 : ∀ j, childrenD_525_i0 j ⊆ envelope_525_i0 := by decide +kernel +theorem pivot_mem_525_i0 : (3, 2) ∈ envelope_525_i0 := by decide +kernel +theorem children_work_525_i0 : ∀ j, Template HasSnaky 4 (childrenC_525_i0 j) (childrenD_525_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact row_works_525_i1.mono (by decide +kernel) +theorem row_works_525_i0 : Template HasSnaky 5 required_525_i0 envelope_525_i0 := by + refine compose HasSnaky 4 childrenC_525_i0 childrenD_525_i0 children_work_525_i0 (3, 2) + required_525_i0 envelope_525_i0 pivot_mem_525_i0 child_required_sub_525_i0 child_envelope_sub_525_i0 ?_ + intro b hb + exact common_sub_525_i0 (mem_commonEnvelope childrenD_525_i0 b hb) +def required_525 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_525 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_525 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), required_525_i0] +def childrenD_525 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), envelope_525_i0] +theorem common_sub_525 : commonEnvelope childrenD_525 ⊆ insert (3, 0) required_525 := by decide +kernel +theorem child_required_sub_525 : ∀ j, childrenC_525 j ⊆ insert (3, 0) required_525 := by decide +kernel +theorem child_envelope_sub_525 : ∀ j, childrenD_525 j ⊆ envelope_525 := by decide +kernel +theorem pivot_mem_525 : (3, 0) ∈ envelope_525 := by decide +kernel +theorem children_work_525 : ∀ j, Template HasSnaky 5 (childrenC_525 j) (childrenD_525 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact row_works_525_i0.mono (by decide +kernel) +theorem row_works_525 : Template HasSnaky 6 required_525 envelope_525 := by + refine compose HasSnaky 5 childrenC_525 childrenD_525 children_work_525 (3, 0) + required_525 envelope_525 pivot_mem_525 child_required_sub_525 child_envelope_sub_525 ?_ + intro b hb + exact common_sub_525 (mem_commonEnvelope childrenD_525 b hb) +def required_544_i1 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_544_i1 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_544_i1 : Fin 2 → Finset Cell := ![(placed21 2 (6, 3) required_0), (placed21 7 (6, 4) required_62)] +def childrenD_544_i1 : Fin 2 → Finset Cell := ![(placed21 2 (6, 3) envelope_0), (placed21 7 (6, 4) envelope_62)] +theorem common_sub_544_i1 : commonEnvelope childrenD_544_i1 ⊆ insert (5, 3) required_544_i1 := by decide +kernel +theorem child_required_sub_544_i1 : ∀ j, childrenC_544_i1 j ⊆ insert (5, 3) required_544_i1 := by decide +kernel +theorem child_envelope_sub_544_i1 : ∀ j, childrenD_544_i1 j ⊆ envelope_544_i1 := by decide +kernel +theorem pivot_mem_544_i1 : (5, 3) ∈ envelope_544_i1 := by decide +kernel +theorem children_work_544_i1 : ∀ j, Template HasSnaky 3 (childrenC_544_i1 j) (childrenD_544_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_62 7 (6, 4)).mono (by decide +kernel) +theorem row_works_544_i1 : Template HasSnaky 4 required_544_i1 envelope_544_i1 := by + refine compose HasSnaky 3 childrenC_544_i1 childrenD_544_i1 children_work_544_i1 (5, 3) + required_544_i1 envelope_544_i1 pivot_mem_544_i1 child_required_sub_544_i1 child_envelope_sub_544_i1 ?_ + intro b hb + exact common_sub_544_i1 (mem_commonEnvelope childrenD_544_i1 b hb) +def required_544_i0 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_544_i0 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (6, 2), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_544_i0 : Fin 3 → Finset Cell := ![(placed21 5 (5, 3) required_15), (placed21 1 (0, 2) required_259), required_544_i1] +def childrenD_544_i0 : Fin 3 → Finset Cell := ![(placed21 5 (5, 3) envelope_15), (placed21 1 (0, 2) envelope_259), envelope_544_i1] +theorem common_sub_544_i0 : commonEnvelope childrenD_544_i0 ⊆ insert (4, 3) required_544_i0 := by decide +kernel +theorem child_required_sub_544_i0 : ∀ j, childrenC_544_i0 j ⊆ insert (4, 3) required_544_i0 := by decide +kernel +theorem child_envelope_sub_544_i0 : ∀ j, childrenD_544_i0 j ⊆ envelope_544_i0 := by decide +kernel +theorem pivot_mem_544_i0 : (4, 3) ∈ envelope_544_i0 := by decide +kernel +theorem children_work_544_i0 : ∀ j, Template HasSnaky 4 (childrenC_544_i0 j) (childrenD_544_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 5 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_259 1 (0, 2)).mono (by decide +kernel) + · exact row_works_544_i1.mono (by decide +kernel) +theorem row_works_544_i0 : Template HasSnaky 5 required_544_i0 envelope_544_i0 := by + refine compose HasSnaky 4 childrenC_544_i0 childrenD_544_i0 children_work_544_i0 (4, 3) + required_544_i0 envelope_544_i0 pivot_mem_544_i0 child_required_sub_544_i0 child_envelope_sub_544_i0 ?_ + intro b hb + exact common_sub_544_i0 (mem_commonEnvelope childrenD_544_i0 b hb) +def required_544 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_544 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (6, 2), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_544 : Fin 2 → Finset Cell := ![(placed21 4 (2, 5) required_23), required_544_i0] +def childrenD_544 : Fin 2 → Finset Cell := ![(placed21 4 (2, 5) envelope_23), envelope_544_i0] +theorem common_sub_544 : commonEnvelope childrenD_544 ⊆ insert (3, 4) required_544 := by decide +kernel +theorem child_required_sub_544 : ∀ j, childrenC_544 j ⊆ insert (3, 4) required_544 := by decide +kernel +theorem child_envelope_sub_544 : ∀ j, childrenD_544 j ⊆ envelope_544 := by decide +kernel +theorem pivot_mem_544 : (3, 4) ∈ envelope_544 := by decide +kernel +theorem children_work_544 : ∀ j, Template HasSnaky 5 (childrenC_544 j) (childrenD_544 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_23 4 (2, 5)).mono (by decide +kernel) + · exact row_works_544_i0.mono (by decide +kernel) +theorem row_works_544 : Template HasSnaky 6 required_544 envelope_544 := by + refine compose HasSnaky 5 childrenC_544 childrenD_544 children_work_544 (3, 4) + required_544 envelope_544 pivot_mem_544 child_required_sub_544 child_envelope_sub_544 ?_ + intro b hb + exact common_sub_544 (mem_commonEnvelope childrenD_544 b hb) +def required_600_i0 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_600_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_600_i0 : Fin 2 → Finset Cell := ![(placed21 0 (2, 2) required_20), (placed21 3 (0, 5) required_55)] +def childrenD_600_i0 : Fin 2 → Finset Cell := ![(placed21 0 (2, 2) envelope_20), (placed21 3 (0, 5) envelope_55)] +theorem common_sub_600_i0 : commonEnvelope childrenD_600_i0 ⊆ insert (3, 5) required_600_i0 := by decide +kernel +theorem child_required_sub_600_i0 : ∀ j, childrenC_600_i0 j ⊆ insert (3, 5) required_600_i0 := by decide +kernel +theorem child_envelope_sub_600_i0 : ∀ j, childrenD_600_i0 j ⊆ envelope_600_i0 := by decide +kernel +theorem pivot_mem_600_i0 : (3, 5) ∈ envelope_600_i0 := by decide +kernel +theorem children_work_600_i0 : ∀ j, Template HasSnaky 4 (childrenC_600_i0 j) (childrenD_600_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_20 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_55 3 (0, 5)).mono (by decide +kernel) +theorem row_works_600_i0 : Template HasSnaky 5 required_600_i0 envelope_600_i0 := by + refine compose HasSnaky 4 childrenC_600_i0 childrenD_600_i0 children_work_600_i0 (3, 5) + required_600_i0 envelope_600_i0 pivot_mem_600_i0 child_required_sub_600_i0 child_envelope_sub_600_i0 ?_ + intro b hb + exact common_sub_600_i0 (mem_commonEnvelope childrenD_600_i0 b hb) +def required_600 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_600 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_600 : Fin 2 → Finset Cell := ![(placed21 6 (3, 5) required_23), required_600_i0] +def childrenD_600 : Fin 2 → Finset Cell := ![(placed21 6 (3, 5) envelope_23), envelope_600_i0] +theorem common_sub_600 : commonEnvelope childrenD_600 ⊆ insert (3, 2) required_600 := by decide +kernel +theorem child_required_sub_600 : ∀ j, childrenC_600 j ⊆ insert (3, 2) required_600 := by decide +kernel +theorem child_envelope_sub_600 : ∀ j, childrenD_600 j ⊆ envelope_600 := by decide +kernel +theorem pivot_mem_600 : (3, 2) ∈ envelope_600 := by decide +kernel +theorem children_work_600 : ∀ j, Template HasSnaky 5 (childrenC_600 j) (childrenD_600 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_23 6 (3, 5)).mono (by decide +kernel) + · exact row_works_600_i0.mono (by decide +kernel) +theorem row_works_600 : Template HasSnaky 6 required_600 envelope_600 := by + refine compose HasSnaky 5 childrenC_600 childrenD_600 children_work_600 (3, 2) + required_600 envelope_600 pivot_mem_600 child_required_sub_600 child_envelope_sub_600 ?_ + intro b hb + exact common_sub_600 (mem_commonEnvelope childrenD_600 b hb) +def required_606_i0 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_606_i0 : Finset Cell := ⟨(([(0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_606_i0 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) required_53), (placed21 2 (4, 1) required_240)] +def childrenD_606_i0 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) envelope_53), (placed21 2 (4, 1) envelope_240)] +theorem common_sub_606_i0 : commonEnvelope childrenD_606_i0 ⊆ insert (3, 4) required_606_i0 := by decide +kernel +theorem child_required_sub_606_i0 : ∀ j, childrenC_606_i0 j ⊆ insert (3, 4) required_606_i0 := by decide +kernel +theorem child_envelope_sub_606_i0 : ∀ j, childrenD_606_i0 j ⊆ envelope_606_i0 := by decide +kernel +theorem pivot_mem_606_i0 : (3, 4) ∈ envelope_606_i0 := by decide +kernel +theorem children_work_606_i0 : ∀ j, Template HasSnaky 4 (childrenC_606_i0 j) (childrenD_606_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_240 2 (4, 1)).mono (by decide +kernel) +theorem row_works_606_i0 : Template HasSnaky 5 required_606_i0 envelope_606_i0 := by + refine compose HasSnaky 4 childrenC_606_i0 childrenD_606_i0 children_work_606_i0 (3, 4) + required_606_i0 envelope_606_i0 pivot_mem_606_i0 child_required_sub_606_i0 child_envelope_sub_606_i0 ?_ + intro b hb + exact common_sub_606_i0 (mem_commonEnvelope childrenD_606_i0 b hb) +def required_606 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_606 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_606 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) required_28), (placed21 0 (0, 1) required_168), required_606_i0] +def childrenD_606 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) envelope_28), (placed21 0 (0, 1) envelope_168), envelope_606_i0] +theorem common_sub_606 : commonEnvelope childrenD_606 ⊆ insert (3, 3) required_606 := by decide +kernel +theorem child_required_sub_606 : ∀ j, childrenC_606 j ⊆ insert (3, 3) required_606 := by decide +kernel +theorem child_envelope_sub_606 : ∀ j, childrenD_606 j ⊆ envelope_606 := by decide +kernel +theorem pivot_mem_606 : (3, 3) ∈ envelope_606 := by decide +kernel +theorem children_work_606 : ∀ j, Template HasSnaky 5 (childrenC_606 j) (childrenD_606 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_28 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_168 0 (0, 1)).mono (by decide +kernel) + · exact row_works_606_i0.mono (by decide +kernel) +theorem row_works_606 : Template HasSnaky 6 required_606 envelope_606 := by + refine compose HasSnaky 5 childrenC_606 childrenD_606 children_work_606 (3, 3) + required_606 envelope_606 pivot_mem_606 child_required_sub_606 child_envelope_sub_606 ?_ + intro b hb + exact common_sub_606 (mem_commonEnvelope childrenD_606 b hb) +def required_609_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_609_i0 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (3, 1), (4, 0), (4, 1), (5, 0), (5, 1), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_609_i0 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 3 (0, 2) required_48)] +def childrenD_609_i0 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 3 (0, 2) envelope_48)] +theorem common_sub_609_i0 : commonEnvelope childrenD_609_i0 ⊆ insert (2, 1) required_609_i0 := by decide +kernel +theorem child_required_sub_609_i0 : ∀ j, childrenC_609_i0 j ⊆ insert (2, 1) required_609_i0 := by decide +kernel +theorem child_envelope_sub_609_i0 : ∀ j, childrenD_609_i0 j ⊆ envelope_609_i0 := by decide +kernel +theorem pivot_mem_609_i0 : (2, 1) ∈ envelope_609_i0 := by decide +kernel +theorem children_work_609_i0 : ∀ j, Template HasSnaky 4 (childrenC_609_i0 j) (childrenD_609_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_48 3 (0, 2)).mono (by decide +kernel) +theorem row_works_609_i0 : Template HasSnaky 5 required_609_i0 envelope_609_i0 := by + refine compose HasSnaky 4 childrenC_609_i0 childrenD_609_i0 children_work_609_i0 (2, 1) + required_609_i0 envelope_609_i0 pivot_mem_609_i0 child_required_sub_609_i0 child_envelope_sub_609_i0 ?_ + intro b hb + exact common_sub_609_i0 (mem_commonEnvelope childrenD_609_i0 b hb) +def required_609_i1 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (3, 1), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_609_i1 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_609_i1 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_25), (placed21 0 (3, 0) required_54)] +def childrenD_609_i1 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_25), (placed21 0 (3, 0) envelope_54)] +theorem common_sub_609_i1 : commonEnvelope childrenD_609_i1 ⊆ insert (3, 3) required_609_i1 := by decide +kernel +theorem child_required_sub_609_i1 : ∀ j, childrenC_609_i1 j ⊆ insert (3, 3) required_609_i1 := by decide +kernel +theorem child_envelope_sub_609_i1 : ∀ j, childrenD_609_i1 j ⊆ envelope_609_i1 := by decide +kernel +theorem pivot_mem_609_i1 : (3, 3) ∈ envelope_609_i1 := by decide +kernel +theorem children_work_609_i1 : ∀ j, Template HasSnaky 3 (childrenC_609_i1 j) (childrenD_609_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_25 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_54 0 (3, 0)).mono (by decide +kernel) +theorem row_works_609_i1 : Template HasSnaky 4 required_609_i1 envelope_609_i1 := by + refine compose HasSnaky 3 childrenC_609_i1 childrenD_609_i1 children_work_609_i1 (3, 3) + required_609_i1 envelope_609_i1 pivot_mem_609_i1 child_required_sub_609_i1 child_envelope_sub_609_i1 ?_ + intro b hb + exact common_sub_609_i1 (mem_commonEnvelope childrenD_609_i1 b hb) +def required_609 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_609 : Finset Cell := ⟨(([(0, 2), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_609 : Fin 2 → Finset Cell := ![required_609_i0, required_609_i1] +def childrenD_609 : Fin 2 → Finset Cell := ![envelope_609_i0, envelope_609_i1] +theorem common_sub_609 : commonEnvelope childrenD_609 ⊆ insert (3, 1) required_609 := by decide +kernel +theorem child_required_sub_609 : ∀ j, childrenC_609 j ⊆ insert (3, 1) required_609 := by decide +kernel +theorem child_envelope_sub_609 : ∀ j, childrenD_609 j ⊆ envelope_609 := by decide +kernel +theorem pivot_mem_609 : (3, 1) ∈ envelope_609 := by decide +kernel +theorem children_work_609 : ∀ j, Template HasSnaky 5 (childrenC_609 j) (childrenD_609 j) := by + intro j + fin_cases j + · exact row_works_609_i0.mono (by decide +kernel) + · exact row_works_609_i1.mono (by decide +kernel) +theorem row_works_609 : Template HasSnaky 6 required_609 envelope_609 := by + refine compose HasSnaky 5 childrenC_609 childrenD_609 children_work_609 (3, 1) + required_609 envelope_609 pivot_mem_609 child_required_sub_609 child_envelope_sub_609 ?_ + intro b hb + exact common_sub_609 (mem_commonEnvelope childrenD_609 b hb) +def required_611_i0 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_611_i0 : Finset Cell := ⟨(([(1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (1, 7), (1, 8), (1, 9), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_611_i0 : Fin 3 → Finset Cell := ![(placed21 4 (2, 7) required_7), (placed21 0 (1, 3) required_17), (placed21 3 (1, 6) required_93)] +def childrenD_611_i0 : Fin 3 → Finset Cell := ![(placed21 4 (2, 7) envelope_7), (placed21 0 (1, 3) envelope_17), (placed21 3 (1, 6) envelope_93)] +theorem common_sub_611_i0 : commonEnvelope childrenD_611_i0 ⊆ insert (2, 3) required_611_i0 := by decide +kernel +theorem child_required_sub_611_i0 : ∀ j, childrenC_611_i0 j ⊆ insert (2, 3) required_611_i0 := by decide +kernel +theorem child_envelope_sub_611_i0 : ∀ j, childrenD_611_i0 j ⊆ envelope_611_i0 := by decide +kernel +theorem pivot_mem_611_i0 : (2, 3) ∈ envelope_611_i0 := by decide +kernel +theorem children_work_611_i0 : ∀ j, Template HasSnaky 4 (childrenC_611_i0 j) (childrenD_611_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_17 0 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_93 3 (1, 6)).mono (by decide +kernel) +theorem row_works_611_i0 : Template HasSnaky 5 required_611_i0 envelope_611_i0 := by + refine compose HasSnaky 4 childrenC_611_i0 childrenD_611_i0 children_work_611_i0 (2, 3) + required_611_i0 envelope_611_i0 pivot_mem_611_i0 child_required_sub_611_i0 child_envelope_sub_611_i0 ?_ + intro b hb + exact common_sub_611_i0 (mem_commonEnvelope childrenD_611_i0 b hb) +def required_611 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_611 : Finset Cell := ⟨(([(0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 7), (1, 8), (1, 9), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_611 : Fin 3 → Finset Cell := ![(placed21 2 (2, 3) required_27), (placed21 3 (0, 7) required_47), required_611_i0] +def childrenD_611 : Fin 3 → Finset Cell := ![(placed21 2 (2, 3) envelope_27), (placed21 3 (0, 7) envelope_47), envelope_611_i0] +theorem common_sub_611 : commonEnvelope childrenD_611 ⊆ insert (2, 5) required_611 := by decide +kernel +theorem child_required_sub_611 : ∀ j, childrenC_611 j ⊆ insert (2, 5) required_611 := by decide +kernel +theorem child_envelope_sub_611 : ∀ j, childrenD_611 j ⊆ envelope_611 := by decide +kernel +theorem pivot_mem_611 : (2, 5) ∈ envelope_611 := by decide +kernel +theorem children_work_611 : ∀ j, Template HasSnaky 5 (childrenC_611 j) (childrenD_611 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_27 2 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_47 3 (0, 7)).mono (by decide +kernel) + · exact row_works_611_i0.mono (by decide +kernel) +theorem row_works_611 : Template HasSnaky 6 required_611 envelope_611 := by + refine compose HasSnaky 5 childrenC_611 childrenD_611 children_work_611 (2, 5) + required_611 envelope_611 pivot_mem_611 child_required_sub_611 child_envelope_sub_611 ?_ + intro b hb + exact common_sub_611 (mem_commonEnvelope childrenD_611 b hb) +def required_641_i0 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_641_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_641_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 0) required_14), (placed21 1 (0, 3) required_44), (placed21 2 (4, 1) required_60)] +def childrenD_641_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 0) envelope_14), (placed21 1 (0, 3) envelope_44), (placed21 2 (4, 1) envelope_60)] +theorem common_sub_641_i0 : commonEnvelope childrenD_641_i0 ⊆ insert (3, 4) required_641_i0 := by decide +kernel +theorem child_required_sub_641_i0 : ∀ j, childrenC_641_i0 j ⊆ insert (3, 4) required_641_i0 := by decide +kernel +theorem child_envelope_sub_641_i0 : ∀ j, childrenD_641_i0 j ⊆ envelope_641_i0 := by decide +kernel +theorem pivot_mem_641_i0 : (3, 4) ∈ envelope_641_i0 := by decide +kernel +theorem children_work_641_i0 : ∀ j, Template HasSnaky 4 (childrenC_641_i0 j) (childrenD_641_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 0 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_44 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_60 2 (4, 1)).mono (by decide +kernel) +theorem row_works_641_i0 : Template HasSnaky 5 required_641_i0 envelope_641_i0 := by + refine compose HasSnaky 4 childrenC_641_i0 childrenD_641_i0 children_work_641_i0 (3, 4) + required_641_i0 envelope_641_i0 pivot_mem_641_i0 child_required_sub_641_i0 child_envelope_sub_641_i0 ?_ + intro b hb + exact common_sub_641_i0 (mem_commonEnvelope childrenD_641_i0 b hb) +def required_641 : Finset Cell := ⟨(([(1, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_641 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_641 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) required_52), (placed21 0 (1, 1) required_144), required_641_i0] +def childrenD_641 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) envelope_52), (placed21 0 (1, 1) envelope_144), envelope_641_i0] +theorem common_sub_641 : commonEnvelope childrenD_641 ⊆ insert (2, 3) required_641 := by decide +kernel +theorem child_required_sub_641 : ∀ j, childrenC_641 j ⊆ insert (2, 3) required_641 := by decide +kernel +theorem child_envelope_sub_641 : ∀ j, childrenD_641 j ⊆ envelope_641 := by decide +kernel +theorem pivot_mem_641 : (2, 3) ∈ envelope_641 := by decide +kernel +theorem children_work_641 : ∀ j, Template HasSnaky 5 (childrenC_641 j) (childrenD_641 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_144 0 (1, 1)).mono (by decide +kernel) + · exact row_works_641_i0.mono (by decide +kernel) +theorem row_works_641 : Template HasSnaky 6 required_641 envelope_641 := by + refine compose HasSnaky 5 childrenC_641 childrenD_641 children_work_641 (2, 3) + required_641 envelope_641 pivot_mem_641 child_required_sub_641 child_envelope_sub_641 ?_ + intro b hb + exact common_sub_641 (mem_commonEnvelope childrenD_641 b hb) +def required_714_i0 : Finset Cell := ⟨(([(2, 4), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_714_i0 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 7), (4, 8), (4, 9), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_714_i0 : Fin 2 → Finset Cell := ![(placed21 0 (2, 3) required_41), (placed21 3 (0, 6) required_55)] +def childrenD_714_i0 : Fin 2 → Finset Cell := ![(placed21 0 (2, 3) envelope_41), (placed21 3 (0, 6) envelope_55)] +theorem common_sub_714_i0 : commonEnvelope childrenD_714_i0 ⊆ insert (3, 6) required_714_i0 := by decide +kernel +theorem child_required_sub_714_i0 : ∀ j, childrenC_714_i0 j ⊆ insert (3, 6) required_714_i0 := by decide +kernel +theorem child_envelope_sub_714_i0 : ∀ j, childrenD_714_i0 j ⊆ envelope_714_i0 := by decide +kernel +theorem pivot_mem_714_i0 : (3, 6) ∈ envelope_714_i0 := by decide +kernel +theorem children_work_714_i0 : ∀ j, Template HasSnaky 4 (childrenC_714_i0 j) (childrenD_714_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_41 0 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_55 3 (0, 6)).mono (by decide +kernel) +theorem row_works_714_i0 : Template HasSnaky 5 required_714_i0 envelope_714_i0 := by + refine compose HasSnaky 4 childrenC_714_i0 childrenD_714_i0 children_work_714_i0 (3, 6) + required_714_i0 envelope_714_i0 pivot_mem_714_i0 child_required_sub_714_i0 child_envelope_sub_714_i0 ?_ + intro b hb + exact common_sub_714_i0 (mem_commonEnvelope childrenD_714_i0 b hb) +def required_714 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_714 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 7), (4, 8), (4, 9), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_714 : Fin 3 → Finset Cell := ![(placed21 2 (3, 2) required_15), (placed21 3 (0, 6) required_88), required_714_i0] +def childrenD_714 : Fin 3 → Finset Cell := ![(placed21 2 (3, 2) envelope_15), (placed21 3 (0, 6) envelope_88), envelope_714_i0] +theorem common_sub_714 : commonEnvelope childrenD_714 ⊆ insert (3, 3) required_714 := by decide +kernel +theorem child_required_sub_714 : ∀ j, childrenC_714 j ⊆ insert (3, 3) required_714 := by decide +kernel +theorem child_envelope_sub_714 : ∀ j, childrenD_714 j ⊆ envelope_714 := by decide +kernel +theorem pivot_mem_714 : (3, 3) ∈ envelope_714 := by decide +kernel +theorem children_work_714 : ∀ j, Template HasSnaky 5 (childrenC_714 j) (childrenD_714 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 2 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_88 3 (0, 6)).mono (by decide +kernel) + · exact row_works_714_i0.mono (by decide +kernel) +theorem row_works_714 : Template HasSnaky 6 required_714 envelope_714 := by + refine compose HasSnaky 5 childrenC_714 childrenD_714 children_work_714 (3, 3) + required_714 envelope_714 pivot_mem_714 child_required_sub_714 child_envelope_sub_714 ?_ + intro b hb + exact common_sub_714 (mem_commonEnvelope childrenD_714 b hb) +def height_521_i1 : ℕ := 4 +def childrenH_521_i1 : Fin 2 → ℕ := ![height_45, height_45] +theorem height_exact_521_i1 : height_521_i1 = 1 + Finset.univ.sup childrenH_521_i1 := by decide +kernel +theorem required_origin_521_i1 : ∀ x ∈ required_521_i1, + (∃ j, x ∈ childrenC_521_i1 j) ∨ ∀ j, x ∈ childrenD_521_i1 j := by decide +kernel +theorem required_exact_521_i1 : required_521_i1 = + ((Finset.univ.biUnion childrenC_521_i1) ∪ commonEnvelope childrenD_521_i1).erase (2, 3) := by + exact required_eq_combination childrenC_521_i1 childrenD_521_i1 (2, 3) required_521_i1 + (by decide +kernel) child_required_sub_521_i1 common_sub_521_i1 required_origin_521_i1 +theorem envelope_origin_521_i1 : ∀ x ∈ envelope_521_i1, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_521_i1 j := by decide +kernel +theorem envelope_exact_521_i1 : envelope_521_i1 = + insert (2, 3) (Finset.univ.biUnion childrenD_521_i1) := by + exact envelope_eq_combination childrenD_521_i1 (2, 3) envelope_521_i1 + pivot_mem_521_i1 child_envelope_sub_521_i1 envelope_origin_521_i1 +def checked_521_i1 : CheckedCard where + required := required_521_i1 + envelope := envelope_521_i1 + height := height_521_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_521_i1 +def height_521_i0 : ℕ := 5 +def childrenH_521_i0 : Fin 2 → ℕ := ![height_5, height_521_i1] +theorem height_exact_521_i0 : height_521_i0 = 1 + Finset.univ.sup childrenH_521_i0 := by decide +kernel +theorem required_origin_521_i0 : ∀ x ∈ required_521_i0, + (∃ j, x ∈ childrenC_521_i0 j) ∨ ∀ j, x ∈ childrenD_521_i0 j := by decide +kernel +theorem required_exact_521_i0 : required_521_i0 = + ((Finset.univ.biUnion childrenC_521_i0) ∪ commonEnvelope childrenD_521_i0).erase (2, 4) := by + exact required_eq_combination childrenC_521_i0 childrenD_521_i0 (2, 4) required_521_i0 + (by decide +kernel) child_required_sub_521_i0 common_sub_521_i0 required_origin_521_i0 +theorem envelope_origin_521_i0 : ∀ x ∈ envelope_521_i0, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_521_i0 j := by decide +kernel +theorem envelope_exact_521_i0 : envelope_521_i0 = + insert (2, 4) (Finset.univ.biUnion childrenD_521_i0) := by + exact envelope_eq_combination childrenD_521_i0 (2, 4) envelope_521_i0 + pivot_mem_521_i0 child_envelope_sub_521_i0 envelope_origin_521_i0 +def checked_521_i0 : CheckedCard where + required := required_521_i0 + envelope := envelope_521_i0 + height := height_521_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_521_i0 +def height_521 : ℕ := 6 +def childrenH_521 : Fin 2 → ℕ := ![height_5, height_521_i0] +theorem height_exact_521 : height_521 = 1 + Finset.univ.sup childrenH_521 := by decide +kernel +theorem required_origin_521 : ∀ x ∈ required_521, + (∃ j, x ∈ childrenC_521 j) ∨ ∀ j, x ∈ childrenD_521 j := by decide +kernel +theorem required_exact_521 : required_521 = + ((Finset.univ.biUnion childrenC_521) ∪ commonEnvelope childrenD_521).erase (2, 1) := by + exact required_eq_combination childrenC_521 childrenD_521 (2, 1) required_521 + (by decide +kernel) child_required_sub_521 common_sub_521 required_origin_521 +theorem envelope_origin_521 : ∀ x ∈ envelope_521, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_521 j := by decide +kernel +theorem envelope_exact_521 : envelope_521 = + insert (2, 1) (Finset.univ.biUnion childrenD_521) := by + exact envelope_eq_combination childrenD_521 (2, 1) envelope_521 + pivot_mem_521 child_envelope_sub_521 envelope_origin_521 +def checked_521 : CheckedCard where + required := required_521 + envelope := envelope_521 + height := height_521 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_521 +def height_525_i1 : ℕ := 4 +def childrenH_525_i1 : Fin 3 → ℕ := ![height_21, height_37, height_78] +theorem height_exact_525_i1 : height_525_i1 = 1 + Finset.univ.sup childrenH_525_i1 := by decide +kernel +theorem required_origin_525_i1 : ∀ x ∈ required_525_i1, + (∃ j, x ∈ childrenC_525_i1 j) ∨ ∀ j, x ∈ childrenD_525_i1 j := by decide +kernel +theorem required_exact_525_i1 : required_525_i1 = + ((Finset.univ.biUnion childrenC_525_i1) ∪ commonEnvelope childrenD_525_i1).erase (3, 3) := by + exact required_eq_combination childrenC_525_i1 childrenD_525_i1 (3, 3) required_525_i1 + (by decide +kernel) child_required_sub_525_i1 common_sub_525_i1 required_origin_525_i1 +theorem envelope_origin_525_i1 : ∀ x ∈ envelope_525_i1, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_525_i1 j := by decide +kernel +theorem envelope_exact_525_i1 : envelope_525_i1 = + insert (3, 3) (Finset.univ.biUnion childrenD_525_i1) := by + exact envelope_eq_combination childrenD_525_i1 (3, 3) envelope_525_i1 + pivot_mem_525_i1 child_envelope_sub_525_i1 envelope_origin_525_i1 +def checked_525_i1 : CheckedCard where + required := required_525_i1 + envelope := envelope_525_i1 + height := height_525_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_525_i1 +def height_525_i0 : ℕ := 5 +def childrenH_525_i0 : Fin 2 → ℕ := ![height_5, height_525_i1] +theorem height_exact_525_i0 : height_525_i0 = 1 + Finset.univ.sup childrenH_525_i0 := by decide +kernel +theorem required_origin_525_i0 : ∀ x ∈ required_525_i0, + (∃ j, x ∈ childrenC_525_i0 j) ∨ ∀ j, x ∈ childrenD_525_i0 j := by decide +kernel +theorem required_exact_525_i0 : required_525_i0 = + ((Finset.univ.biUnion childrenC_525_i0) ∪ commonEnvelope childrenD_525_i0).erase (3, 2) := by + exact required_eq_combination childrenC_525_i0 childrenD_525_i0 (3, 2) required_525_i0 + (by decide +kernel) child_required_sub_525_i0 common_sub_525_i0 required_origin_525_i0 +theorem envelope_origin_525_i0 : ∀ x ∈ envelope_525_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_525_i0 j := by decide +kernel +theorem envelope_exact_525_i0 : envelope_525_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_525_i0) := by + exact envelope_eq_combination childrenD_525_i0 (3, 2) envelope_525_i0 + pivot_mem_525_i0 child_envelope_sub_525_i0 envelope_origin_525_i0 +def checked_525_i0 : CheckedCard where + required := required_525_i0 + envelope := envelope_525_i0 + height := height_525_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_525_i0 +def height_525 : ℕ := 6 +def childrenH_525 : Fin 2 → ℕ := ![height_5, height_525_i0] +theorem height_exact_525 : height_525 = 1 + Finset.univ.sup childrenH_525 := by decide +kernel +theorem required_origin_525 : ∀ x ∈ required_525, + (∃ j, x ∈ childrenC_525 j) ∨ ∀ j, x ∈ childrenD_525 j := by decide +kernel +theorem required_exact_525 : required_525 = + ((Finset.univ.biUnion childrenC_525) ∪ commonEnvelope childrenD_525).erase (3, 0) := by + exact required_eq_combination childrenC_525 childrenD_525 (3, 0) required_525 + (by decide +kernel) child_required_sub_525 common_sub_525 required_origin_525 +theorem envelope_origin_525 : ∀ x ∈ envelope_525, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_525 j := by decide +kernel +theorem envelope_exact_525 : envelope_525 = + insert (3, 0) (Finset.univ.biUnion childrenD_525) := by + exact envelope_eq_combination childrenD_525 (3, 0) envelope_525 + pivot_mem_525 child_envelope_sub_525 envelope_origin_525 +def checked_525 : CheckedCard where + required := required_525 + envelope := envelope_525 + height := height_525 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_525 +def height_544_i1 : ℕ := 4 +def childrenH_544_i1 : Fin 2 → ℕ := ![height_0, height_62] +theorem height_exact_544_i1 : height_544_i1 = 1 + Finset.univ.sup childrenH_544_i1 := by decide +kernel +theorem required_origin_544_i1 : ∀ x ∈ required_544_i1, + (∃ j, x ∈ childrenC_544_i1 j) ∨ ∀ j, x ∈ childrenD_544_i1 j := by decide +kernel +theorem required_exact_544_i1 : required_544_i1 = + ((Finset.univ.biUnion childrenC_544_i1) ∪ commonEnvelope childrenD_544_i1).erase (5, 3) := by + exact required_eq_combination childrenC_544_i1 childrenD_544_i1 (5, 3) required_544_i1 + (by decide +kernel) child_required_sub_544_i1 common_sub_544_i1 required_origin_544_i1 +theorem envelope_origin_544_i1 : ∀ x ∈ envelope_544_i1, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_544_i1 j := by decide +kernel +theorem envelope_exact_544_i1 : envelope_544_i1 = + insert (5, 3) (Finset.univ.biUnion childrenD_544_i1) := by + exact envelope_eq_combination childrenD_544_i1 (5, 3) envelope_544_i1 + pivot_mem_544_i1 child_envelope_sub_544_i1 envelope_origin_544_i1 +def checked_544_i1 : CheckedCard where + required := required_544_i1 + envelope := envelope_544_i1 + height := height_544_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_544_i1 +def height_544_i0 : ℕ := 5 +def childrenH_544_i0 : Fin 3 → ℕ := ![height_15, height_259, height_544_i1] +theorem height_exact_544_i0 : height_544_i0 = 1 + Finset.univ.sup childrenH_544_i0 := by decide +kernel +theorem required_origin_544_i0 : ∀ x ∈ required_544_i0, + (∃ j, x ∈ childrenC_544_i0 j) ∨ ∀ j, x ∈ childrenD_544_i0 j := by decide +kernel +theorem required_exact_544_i0 : required_544_i0 = + ((Finset.univ.biUnion childrenC_544_i0) ∪ commonEnvelope childrenD_544_i0).erase (4, 3) := by + exact required_eq_combination childrenC_544_i0 childrenD_544_i0 (4, 3) required_544_i0 + (by decide +kernel) child_required_sub_544_i0 common_sub_544_i0 required_origin_544_i0 +theorem envelope_origin_544_i0 : ∀ x ∈ envelope_544_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_544_i0 j := by decide +kernel +theorem envelope_exact_544_i0 : envelope_544_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_544_i0) := by + exact envelope_eq_combination childrenD_544_i0 (4, 3) envelope_544_i0 + pivot_mem_544_i0 child_envelope_sub_544_i0 envelope_origin_544_i0 +def checked_544_i0 : CheckedCard where + required := required_544_i0 + envelope := envelope_544_i0 + height := height_544_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_544_i0 +def height_544 : ℕ := 6 +def childrenH_544 : Fin 2 → ℕ := ![height_23, height_544_i0] +theorem height_exact_544 : height_544 = 1 + Finset.univ.sup childrenH_544 := by decide +kernel +theorem required_origin_544 : ∀ x ∈ required_544, + (∃ j, x ∈ childrenC_544 j) ∨ ∀ j, x ∈ childrenD_544 j := by decide +kernel +theorem required_exact_544 : required_544 = + ((Finset.univ.biUnion childrenC_544) ∪ commonEnvelope childrenD_544).erase (3, 4) := by + exact required_eq_combination childrenC_544 childrenD_544 (3, 4) required_544 + (by decide +kernel) child_required_sub_544 common_sub_544 required_origin_544 +theorem envelope_origin_544 : ∀ x ∈ envelope_544, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_544 j := by decide +kernel +theorem envelope_exact_544 : envelope_544 = + insert (3, 4) (Finset.univ.biUnion childrenD_544) := by + exact envelope_eq_combination childrenD_544 (3, 4) envelope_544 + pivot_mem_544 child_envelope_sub_544 envelope_origin_544 +def checked_544 : CheckedCard where + required := required_544 + envelope := envelope_544 + height := height_544 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_544 +def height_600_i0 : ℕ := 5 +def childrenH_600_i0 : Fin 2 → ℕ := ![height_20, height_55] +theorem height_exact_600_i0 : height_600_i0 = 1 + Finset.univ.sup childrenH_600_i0 := by decide +kernel +theorem required_origin_600_i0 : ∀ x ∈ required_600_i0, + (∃ j, x ∈ childrenC_600_i0 j) ∨ ∀ j, x ∈ childrenD_600_i0 j := by decide +kernel +theorem required_exact_600_i0 : required_600_i0 = + ((Finset.univ.biUnion childrenC_600_i0) ∪ commonEnvelope childrenD_600_i0).erase (3, 5) := by + exact required_eq_combination childrenC_600_i0 childrenD_600_i0 (3, 5) required_600_i0 + (by decide +kernel) child_required_sub_600_i0 common_sub_600_i0 required_origin_600_i0 +theorem envelope_origin_600_i0 : ∀ x ∈ envelope_600_i0, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_600_i0 j := by decide +kernel +theorem envelope_exact_600_i0 : envelope_600_i0 = + insert (3, 5) (Finset.univ.biUnion childrenD_600_i0) := by + exact envelope_eq_combination childrenD_600_i0 (3, 5) envelope_600_i0 + pivot_mem_600_i0 child_envelope_sub_600_i0 envelope_origin_600_i0 +def checked_600_i0 : CheckedCard where + required := required_600_i0 + envelope := envelope_600_i0 + height := height_600_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_600_i0 +def height_600 : ℕ := 6 +def childrenH_600 : Fin 2 → ℕ := ![height_23, height_600_i0] +theorem height_exact_600 : height_600 = 1 + Finset.univ.sup childrenH_600 := by decide +kernel +theorem required_origin_600 : ∀ x ∈ required_600, + (∃ j, x ∈ childrenC_600 j) ∨ ∀ j, x ∈ childrenD_600 j := by decide +kernel +theorem required_exact_600 : required_600 = + ((Finset.univ.biUnion childrenC_600) ∪ commonEnvelope childrenD_600).erase (3, 2) := by + exact required_eq_combination childrenC_600 childrenD_600 (3, 2) required_600 + (by decide +kernel) child_required_sub_600 common_sub_600 required_origin_600 +theorem envelope_origin_600 : ∀ x ∈ envelope_600, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_600 j := by decide +kernel +theorem envelope_exact_600 : envelope_600 = + insert (3, 2) (Finset.univ.biUnion childrenD_600) := by + exact envelope_eq_combination childrenD_600 (3, 2) envelope_600 + pivot_mem_600 child_envelope_sub_600 envelope_origin_600 +def checked_600 : CheckedCard where + required := required_600 + envelope := envelope_600 + height := height_600 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_600 +def height_606_i0 : ℕ := 5 +def childrenH_606_i0 : Fin 2 → ℕ := ![height_53, height_240] +theorem height_exact_606_i0 : height_606_i0 = 1 + Finset.univ.sup childrenH_606_i0 := by decide +kernel +theorem required_origin_606_i0 : ∀ x ∈ required_606_i0, + (∃ j, x ∈ childrenC_606_i0 j) ∨ ∀ j, x ∈ childrenD_606_i0 j := by decide +kernel +theorem required_exact_606_i0 : required_606_i0 = + ((Finset.univ.biUnion childrenC_606_i0) ∪ commonEnvelope childrenD_606_i0).erase (3, 4) := by + exact required_eq_combination childrenC_606_i0 childrenD_606_i0 (3, 4) required_606_i0 + (by decide +kernel) child_required_sub_606_i0 common_sub_606_i0 required_origin_606_i0 +theorem envelope_origin_606_i0 : ∀ x ∈ envelope_606_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_606_i0 j := by decide +kernel +theorem envelope_exact_606_i0 : envelope_606_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_606_i0) := by + exact envelope_eq_combination childrenD_606_i0 (3, 4) envelope_606_i0 + pivot_mem_606_i0 child_envelope_sub_606_i0 envelope_origin_606_i0 +def checked_606_i0 : CheckedCard where + required := required_606_i0 + envelope := envelope_606_i0 + height := height_606_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_606_i0 +def height_606 : ℕ := 6 +def childrenH_606 : Fin 3 → ℕ := ![height_28, height_168, height_606_i0] +theorem height_exact_606 : height_606 = 1 + Finset.univ.sup childrenH_606 := by decide +kernel +theorem required_origin_606 : ∀ x ∈ required_606, + (∃ j, x ∈ childrenC_606 j) ∨ ∀ j, x ∈ childrenD_606 j := by decide +kernel +theorem required_exact_606 : required_606 = + ((Finset.univ.biUnion childrenC_606) ∪ commonEnvelope childrenD_606).erase (3, 3) := by + exact required_eq_combination childrenC_606 childrenD_606 (3, 3) required_606 + (by decide +kernel) child_required_sub_606 common_sub_606 required_origin_606 +theorem envelope_origin_606 : ∀ x ∈ envelope_606, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_606 j := by decide +kernel +theorem envelope_exact_606 : envelope_606 = + insert (3, 3) (Finset.univ.biUnion childrenD_606) := by + exact envelope_eq_combination childrenD_606 (3, 3) envelope_606 + pivot_mem_606 child_envelope_sub_606 envelope_origin_606 +def checked_606 : CheckedCard where + required := required_606 + envelope := envelope_606 + height := height_606 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_606 +def height_609_i0 : ℕ := 5 +def childrenH_609_i0 : Fin 2 → ℕ := ![height_5, height_48] +theorem height_exact_609_i0 : height_609_i0 = 1 + Finset.univ.sup childrenH_609_i0 := by decide +kernel +theorem required_origin_609_i0 : ∀ x ∈ required_609_i0, + (∃ j, x ∈ childrenC_609_i0 j) ∨ ∀ j, x ∈ childrenD_609_i0 j := by decide +kernel +theorem required_exact_609_i0 : required_609_i0 = + ((Finset.univ.biUnion childrenC_609_i0) ∪ commonEnvelope childrenD_609_i0).erase (2, 1) := by + exact required_eq_combination childrenC_609_i0 childrenD_609_i0 (2, 1) required_609_i0 + (by decide +kernel) child_required_sub_609_i0 common_sub_609_i0 required_origin_609_i0 +theorem envelope_origin_609_i0 : ∀ x ∈ envelope_609_i0, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_609_i0 j := by decide +kernel +theorem envelope_exact_609_i0 : envelope_609_i0 = + insert (2, 1) (Finset.univ.biUnion childrenD_609_i0) := by + exact envelope_eq_combination childrenD_609_i0 (2, 1) envelope_609_i0 + pivot_mem_609_i0 child_envelope_sub_609_i0 envelope_origin_609_i0 +def checked_609_i0 : CheckedCard where + required := required_609_i0 + envelope := envelope_609_i0 + height := height_609_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_609_i0 +def height_609_i1 : ℕ := 4 +def childrenH_609_i1 : Fin 2 → ℕ := ![height_25, height_54] +theorem height_exact_609_i1 : height_609_i1 = 1 + Finset.univ.sup childrenH_609_i1 := by decide +kernel +theorem required_origin_609_i1 : ∀ x ∈ required_609_i1, + (∃ j, x ∈ childrenC_609_i1 j) ∨ ∀ j, x ∈ childrenD_609_i1 j := by decide +kernel +theorem required_exact_609_i1 : required_609_i1 = + ((Finset.univ.biUnion childrenC_609_i1) ∪ commonEnvelope childrenD_609_i1).erase (3, 3) := by + exact required_eq_combination childrenC_609_i1 childrenD_609_i1 (3, 3) required_609_i1 + (by decide +kernel) child_required_sub_609_i1 common_sub_609_i1 required_origin_609_i1 +theorem envelope_origin_609_i1 : ∀ x ∈ envelope_609_i1, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_609_i1 j := by decide +kernel +theorem envelope_exact_609_i1 : envelope_609_i1 = + insert (3, 3) (Finset.univ.biUnion childrenD_609_i1) := by + exact envelope_eq_combination childrenD_609_i1 (3, 3) envelope_609_i1 + pivot_mem_609_i1 child_envelope_sub_609_i1 envelope_origin_609_i1 +def checked_609_i1 : CheckedCard where + required := required_609_i1 + envelope := envelope_609_i1 + height := height_609_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_609_i1 +def height_609 : ℕ := 6 +def childrenH_609 : Fin 2 → ℕ := ![height_609_i0, height_609_i1] +theorem height_exact_609 : height_609 = 1 + Finset.univ.sup childrenH_609 := by decide +kernel +theorem required_origin_609 : ∀ x ∈ required_609, + (∃ j, x ∈ childrenC_609 j) ∨ ∀ j, x ∈ childrenD_609 j := by decide +kernel +theorem required_exact_609 : required_609 = + ((Finset.univ.biUnion childrenC_609) ∪ commonEnvelope childrenD_609).erase (3, 1) := by + exact required_eq_combination childrenC_609 childrenD_609 (3, 1) required_609 + (by decide +kernel) child_required_sub_609 common_sub_609 required_origin_609 +theorem envelope_origin_609 : ∀ x ∈ envelope_609, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_609 j := by decide +kernel +theorem envelope_exact_609 : envelope_609 = + insert (3, 1) (Finset.univ.biUnion childrenD_609) := by + exact envelope_eq_combination childrenD_609 (3, 1) envelope_609 + pivot_mem_609 child_envelope_sub_609 envelope_origin_609 +def checked_609 : CheckedCard where + required := required_609 + envelope := envelope_609 + height := height_609 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_609 +def height_611_i0 : ℕ := 5 +def childrenH_611_i0 : Fin 3 → ℕ := ![height_7, height_17, height_93] +theorem height_exact_611_i0 : height_611_i0 = 1 + Finset.univ.sup childrenH_611_i0 := by decide +kernel +theorem required_origin_611_i0 : ∀ x ∈ required_611_i0, + (∃ j, x ∈ childrenC_611_i0 j) ∨ ∀ j, x ∈ childrenD_611_i0 j := by decide +kernel +theorem required_exact_611_i0 : required_611_i0 = + ((Finset.univ.biUnion childrenC_611_i0) ∪ commonEnvelope childrenD_611_i0).erase (2, 3) := by + exact required_eq_combination childrenC_611_i0 childrenD_611_i0 (2, 3) required_611_i0 + (by decide +kernel) child_required_sub_611_i0 common_sub_611_i0 required_origin_611_i0 +theorem envelope_origin_611_i0 : ∀ x ∈ envelope_611_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_611_i0 j := by decide +kernel +theorem envelope_exact_611_i0 : envelope_611_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_611_i0) := by + exact envelope_eq_combination childrenD_611_i0 (2, 3) envelope_611_i0 + pivot_mem_611_i0 child_envelope_sub_611_i0 envelope_origin_611_i0 +def checked_611_i0 : CheckedCard where + required := required_611_i0 + envelope := envelope_611_i0 + height := height_611_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_611_i0 +def height_611 : ℕ := 6 +def childrenH_611 : Fin 3 → ℕ := ![height_27, height_47, height_611_i0] +theorem height_exact_611 : height_611 = 1 + Finset.univ.sup childrenH_611 := by decide +kernel +theorem required_origin_611 : ∀ x ∈ required_611, + (∃ j, x ∈ childrenC_611 j) ∨ ∀ j, x ∈ childrenD_611 j := by decide +kernel +theorem required_exact_611 : required_611 = + ((Finset.univ.biUnion childrenC_611) ∪ commonEnvelope childrenD_611).erase (2, 5) := by + exact required_eq_combination childrenC_611 childrenD_611 (2, 5) required_611 + (by decide +kernel) child_required_sub_611 common_sub_611 required_origin_611 +theorem envelope_origin_611 : ∀ x ∈ envelope_611, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_611 j := by decide +kernel +theorem envelope_exact_611 : envelope_611 = + insert (2, 5) (Finset.univ.biUnion childrenD_611) := by + exact envelope_eq_combination childrenD_611 (2, 5) envelope_611 + pivot_mem_611 child_envelope_sub_611 envelope_origin_611 +def checked_611 : CheckedCard where + required := required_611 + envelope := envelope_611 + height := height_611 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_611 +def height_641_i0 : ℕ := 5 +def childrenH_641_i0 : Fin 3 → ℕ := ![height_14, height_44, height_60] +theorem height_exact_641_i0 : height_641_i0 = 1 + Finset.univ.sup childrenH_641_i0 := by decide +kernel +theorem required_origin_641_i0 : ∀ x ∈ required_641_i0, + (∃ j, x ∈ childrenC_641_i0 j) ∨ ∀ j, x ∈ childrenD_641_i0 j := by decide +kernel +theorem required_exact_641_i0 : required_641_i0 = + ((Finset.univ.biUnion childrenC_641_i0) ∪ commonEnvelope childrenD_641_i0).erase (3, 4) := by + exact required_eq_combination childrenC_641_i0 childrenD_641_i0 (3, 4) required_641_i0 + (by decide +kernel) child_required_sub_641_i0 common_sub_641_i0 required_origin_641_i0 +theorem envelope_origin_641_i0 : ∀ x ∈ envelope_641_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_641_i0 j := by decide +kernel +theorem envelope_exact_641_i0 : envelope_641_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_641_i0) := by + exact envelope_eq_combination childrenD_641_i0 (3, 4) envelope_641_i0 + pivot_mem_641_i0 child_envelope_sub_641_i0 envelope_origin_641_i0 +def checked_641_i0 : CheckedCard where + required := required_641_i0 + envelope := envelope_641_i0 + height := height_641_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_641_i0 +def height_641 : ℕ := 6 +def childrenH_641 : Fin 3 → ℕ := ![height_52, height_144, height_641_i0] +theorem height_exact_641 : height_641 = 1 + Finset.univ.sup childrenH_641 := by decide +kernel +theorem required_origin_641 : ∀ x ∈ required_641, + (∃ j, x ∈ childrenC_641 j) ∨ ∀ j, x ∈ childrenD_641 j := by decide +kernel +theorem required_exact_641 : required_641 = + ((Finset.univ.biUnion childrenC_641) ∪ commonEnvelope childrenD_641).erase (2, 3) := by + exact required_eq_combination childrenC_641 childrenD_641 (2, 3) required_641 + (by decide +kernel) child_required_sub_641 common_sub_641 required_origin_641 +theorem envelope_origin_641 : ∀ x ∈ envelope_641, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_641 j := by decide +kernel +theorem envelope_exact_641 : envelope_641 = + insert (2, 3) (Finset.univ.biUnion childrenD_641) := by + exact envelope_eq_combination childrenD_641 (2, 3) envelope_641 + pivot_mem_641 child_envelope_sub_641 envelope_origin_641 +def checked_641 : CheckedCard where + required := required_641 + envelope := envelope_641 + height := height_641 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_641 +def height_714_i0 : ℕ := 5 +def childrenH_714_i0 : Fin 2 → ℕ := ![height_41, height_55] +theorem height_exact_714_i0 : height_714_i0 = 1 + Finset.univ.sup childrenH_714_i0 := by decide +kernel +theorem required_origin_714_i0 : ∀ x ∈ required_714_i0, + (∃ j, x ∈ childrenC_714_i0 j) ∨ ∀ j, x ∈ childrenD_714_i0 j := by decide +kernel +theorem required_exact_714_i0 : required_714_i0 = + ((Finset.univ.biUnion childrenC_714_i0) ∪ commonEnvelope childrenD_714_i0).erase (3, 6) := by + exact required_eq_combination childrenC_714_i0 childrenD_714_i0 (3, 6) required_714_i0 + (by decide +kernel) child_required_sub_714_i0 common_sub_714_i0 required_origin_714_i0 +theorem envelope_origin_714_i0 : ∀ x ∈ envelope_714_i0, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_714_i0 j := by decide +kernel +theorem envelope_exact_714_i0 : envelope_714_i0 = + insert (3, 6) (Finset.univ.biUnion childrenD_714_i0) := by + exact envelope_eq_combination childrenD_714_i0 (3, 6) envelope_714_i0 + pivot_mem_714_i0 child_envelope_sub_714_i0 envelope_origin_714_i0 +def checked_714_i0 : CheckedCard where + required := required_714_i0 + envelope := envelope_714_i0 + height := height_714_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_714_i0 +def height_714 : ℕ := 6 +def childrenH_714 : Fin 3 → ℕ := ![height_15, height_88, height_714_i0] +theorem height_exact_714 : height_714 = 1 + Finset.univ.sup childrenH_714 := by decide +kernel +theorem required_origin_714 : ∀ x ∈ required_714, + (∃ j, x ∈ childrenC_714 j) ∨ ∀ j, x ∈ childrenD_714 j := by decide +kernel +theorem required_exact_714 : required_714 = + ((Finset.univ.biUnion childrenC_714) ∪ commonEnvelope childrenD_714).erase (3, 3) := by + exact required_eq_combination childrenC_714 childrenD_714 (3, 3) required_714 + (by decide +kernel) child_required_sub_714 common_sub_714 required_origin_714 +theorem envelope_origin_714 : ∀ x ∈ envelope_714, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_714 j := by decide +kernel +theorem envelope_exact_714 : envelope_714 = + insert (3, 3) (Finset.univ.biUnion childrenD_714) := by + exact envelope_eq_combination childrenD_714 (3, 3) envelope_714 + pivot_mem_714 child_envelope_sub_714 envelope_origin_714 +def checked_714 : CheckedCard where + required := required_714 + envelope := envelope_714 + height := height_714 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_714 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part01.lean new file mode 100644 index 0000000..b6dabd2 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part01.lean @@ -0,0 +1,983 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_116 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_116 : Finset Cell := ⟨(([(0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (4, 3), (4, 4), (5, 3), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_116 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) required_7), (placed21 1 (0, 2) required_9), (placed21 2 (4, 0) required_115)] +def childrenD_116 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) envelope_7), (placed21 1 (0, 2) envelope_9), (placed21 2 (4, 0) envelope_115)] +theorem common_sub_116 : commonEnvelope childrenD_116 ⊆ insert (4, 3) required_116 := by decide +kernel +theorem child_required_sub_116 : ∀ j, childrenC_116 j ⊆ insert (4, 3) required_116 := by decide +kernel +theorem child_envelope_sub_116 : ∀ j, childrenD_116 j ⊆ envelope_116 := by decide +kernel +theorem pivot_mem_116 : (4, 3) ∈ envelope_116 := by decide +kernel +theorem children_work_116 : ∀ j, Template HasSnaky 6 (childrenC_116 j) (childrenD_116 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_115 2 (4, 0)).mono (by decide +kernel) +theorem row_works_116 : Template HasSnaky 7 required_116 envelope_116 := by + refine compose HasSnaky 6 childrenC_116 childrenD_116 children_work_116 (4, 3) + required_116 envelope_116 pivot_mem_116 child_required_sub_116 child_envelope_sub_116 ?_ + intro b hb + exact common_sub_116 (mem_commonEnvelope childrenD_116 b hb) +def required_117 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_117 : Finset Cell := ⟨(([(0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_117 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) required_7), (placed21 3 (0, 4) required_9), (placed21 2 (4, 0) required_115)] +def childrenD_117 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) envelope_7), (placed21 3 (0, 4) envelope_9), (placed21 2 (4, 0) envelope_115)] +theorem common_sub_117 : commonEnvelope childrenD_117 ⊆ insert (4, 3) required_117 := by decide +kernel +theorem child_required_sub_117 : ∀ j, childrenC_117 j ⊆ insert (4, 3) required_117 := by decide +kernel +theorem child_envelope_sub_117 : ∀ j, childrenD_117 j ⊆ envelope_117 := by decide +kernel +theorem pivot_mem_117 : (4, 3) ∈ envelope_117 := by decide +kernel +theorem children_work_117 : ∀ j, Template HasSnaky 6 (childrenC_117 j) (childrenD_117 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_115 2 (4, 0)).mono (by decide +kernel) +theorem row_works_117 : Template HasSnaky 7 required_117 envelope_117 := by + refine compose HasSnaky 6 childrenC_117 childrenD_117 children_work_117 (4, 3) + required_117 envelope_117 pivot_mem_117 child_required_sub_117 child_envelope_sub_117 ?_ + intro b hb + exact common_sub_117 (mem_commonEnvelope childrenD_117 b hb) +def required_118 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_118 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_118 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) required_7), (placed21 1 (0, 2) required_9), (placed21 0 (1, 0) required_115)] +def childrenD_118 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) envelope_7), (placed21 1 (0, 2) envelope_9), (placed21 0 (1, 0) envelope_115)] +theorem common_sub_118 : commonEnvelope childrenD_118 ⊆ insert (4, 3) required_118 := by decide +kernel +theorem child_required_sub_118 : ∀ j, childrenC_118 j ⊆ insert (4, 3) required_118 := by decide +kernel +theorem child_envelope_sub_118 : ∀ j, childrenD_118 j ⊆ envelope_118 := by decide +kernel +theorem pivot_mem_118 : (4, 3) ∈ envelope_118 := by decide +kernel +theorem children_work_118 : ∀ j, Template HasSnaky 6 (childrenC_118 j) (childrenD_118 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_115 0 (1, 0)).mono (by decide +kernel) +theorem row_works_118 : Template HasSnaky 7 required_118 envelope_118 := by + refine compose HasSnaky 6 childrenC_118 childrenD_118 children_work_118 (4, 3) + required_118 envelope_118 pivot_mem_118 child_required_sub_118 child_envelope_sub_118 ?_ + intro b hb + exact common_sub_118 (mem_commonEnvelope childrenD_118 b hb) +def required_204 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_204 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_204 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) required_52), (placed21 1 (0, 2) required_203)] +def childrenD_204 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) envelope_52), (placed21 1 (0, 2) envelope_203)] +theorem common_sub_204 : commonEnvelope childrenD_204 ⊆ insert (2, 3) required_204 := by decide +kernel +theorem child_required_sub_204 : ∀ j, childrenC_204 j ⊆ insert (2, 3) required_204 := by decide +kernel +theorem child_envelope_sub_204 : ∀ j, childrenD_204 j ⊆ envelope_204 := by decide +kernel +theorem pivot_mem_204 : (2, 3) ∈ envelope_204 := by decide +kernel +theorem children_work_204 : ∀ j, Template HasSnaky 6 (childrenC_204 j) (childrenD_204 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_203 1 (0, 2)).mono (by decide +kernel) +theorem row_works_204 : Template HasSnaky 7 required_204 envelope_204 := by + refine compose HasSnaky 6 childrenC_204 childrenD_204 children_work_204 (2, 3) + required_204 envelope_204 pivot_mem_204 child_required_sub_204 child_envelope_sub_204 ?_ + intro b hb + exact common_sub_204 (mem_commonEnvelope childrenD_204 b hb) +def required_256 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_256 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_256 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_5), required_255] +def childrenD_256 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_5), envelope_255] +theorem common_sub_256 : commonEnvelope childrenD_256 ⊆ insert (3, 4) required_256 := by decide +kernel +theorem child_required_sub_256 : ∀ j, childrenC_256 j ⊆ insert (3, 4) required_256 := by decide +kernel +theorem child_envelope_sub_256 : ∀ j, childrenD_256 j ⊆ envelope_256 := by decide +kernel +theorem pivot_mem_256 : (3, 4) ∈ envelope_256 := by decide +kernel +theorem children_work_256 : ∀ j, Template HasSnaky 6 (childrenC_256 j) (childrenD_256 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact row_works_255.mono (by decide +kernel) +theorem row_works_256 : Template HasSnaky 7 required_256 envelope_256 := by + refine compose HasSnaky 6 childrenC_256 childrenD_256 children_work_256 (3, 4) + required_256 envelope_256 pivot_mem_256 child_required_sub_256 child_envelope_sub_256 ?_ + intro b hb + exact common_sub_256 (mem_commonEnvelope childrenD_256 b hb) +def required_276 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_276 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 6), (3, 7), (3, 8), (4, 2), (4, 6), (5, 2), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_276 : Fin 4 → Finset Cell := ![(placed21 6 (2, 6) required_44), (placed21 6 (2, 6) required_52), (placed21 3 (0, 6) required_155), (placed21 1 (0, 2) required_275)] +def childrenD_276 : Fin 4 → Finset Cell := ![(placed21 6 (2, 6) envelope_44), (placed21 6 (2, 6) envelope_52), (placed21 3 (0, 6) envelope_155), (placed21 1 (0, 2) envelope_275)] +theorem common_sub_276 : commonEnvelope childrenD_276 ⊆ insert (2, 4) required_276 := by decide +kernel +theorem child_required_sub_276 : ∀ j, childrenC_276 j ⊆ insert (2, 4) required_276 := by decide +kernel +theorem child_envelope_sub_276 : ∀ j, childrenD_276 j ⊆ envelope_276 := by decide +kernel +theorem pivot_mem_276 : (2, 4) ∈ envelope_276 := by decide +kernel +theorem children_work_276 : ∀ j, Template HasSnaky 6 (childrenC_276 j) (childrenD_276 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_155 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_275 1 (0, 2)).mono (by decide +kernel) +theorem row_works_276 : Template HasSnaky 7 required_276 envelope_276 := by + refine compose HasSnaky 6 childrenC_276 childrenD_276 children_work_276 (2, 4) + required_276 envelope_276 pivot_mem_276 child_required_sub_276 child_envelope_sub_276 ?_ + intro b hb + exact common_sub_276 (mem_commonEnvelope childrenD_276 b hb) +def required_286 : Finset Cell := ⟨(([(0, 1), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_286 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 3), (2, 0), (2, 1), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_286 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) required_35), (placed21 5 (6, 1) required_253)] +def childrenD_286 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) envelope_35), (placed21 5 (6, 1) envelope_253)] +theorem common_sub_286 : commonEnvelope childrenD_286 ⊆ insert (4, 2) required_286 := by decide +kernel +theorem child_required_sub_286 : ∀ j, childrenC_286 j ⊆ insert (4, 2) required_286 := by decide +kernel +theorem child_envelope_sub_286 : ∀ j, childrenD_286 j ⊆ envelope_286 := by decide +kernel +theorem pivot_mem_286 : (4, 2) ∈ envelope_286 := by decide +kernel +theorem children_work_286 : ∀ j, Template HasSnaky 6 (childrenC_286 j) (childrenD_286 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_35 7 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_253 5 (6, 1)).mono (by decide +kernel) +theorem row_works_286 : Template HasSnaky 7 required_286 envelope_286 := by + refine compose HasSnaky 6 childrenC_286 childrenD_286 children_work_286 (4, 2) + required_286 envelope_286 pivot_mem_286 child_required_sub_286 child_envelope_sub_286 ?_ + intro b hb + exact common_sub_286 (mem_commonEnvelope childrenD_286 b hb) +def required_290 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 4), (3, 1), (3, 4), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_290 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 1), (3, 4), (4, 1), (4, 3), (4, 4), (5, 3), (5, 4), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_290 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_5), required_203] +def childrenD_290 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_5), envelope_203] +theorem common_sub_290 : commonEnvelope childrenD_290 ⊆ insert (2, 1) required_290 := by decide +kernel +theorem child_required_sub_290 : ∀ j, childrenC_290 j ⊆ insert (2, 1) required_290 := by decide +kernel +theorem child_envelope_sub_290 : ∀ j, childrenD_290 j ⊆ envelope_290 := by decide +kernel +theorem pivot_mem_290 : (2, 1) ∈ envelope_290 := by decide +kernel +theorem children_work_290 : ∀ j, Template HasSnaky 6 (childrenC_290 j) (childrenD_290 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 1)).mono (by decide +kernel) + · exact row_works_203.mono (by decide +kernel) +theorem row_works_290 : Template HasSnaky 7 required_290 envelope_290 := by + refine compose HasSnaky 6 childrenC_290 childrenD_290 children_work_290 (2, 1) + required_290 envelope_290 pivot_mem_290 child_required_sub_290 child_envelope_sub_290 ?_ + intro b hb + exact common_sub_290 (mem_commonEnvelope childrenD_290 b hb) +def required_295 : Finset Cell := ⟨(([(1, 1), (1, 2), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_295 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 4), (2, 1), (2, 4), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_295 : Fin 2 → Finset Cell := ![(placed21 5 (5, 1) required_34), (placed21 5 (6, 0) required_180)] +def childrenD_295 : Fin 2 → Finset Cell := ![(placed21 5 (5, 1) envelope_34), (placed21 5 (6, 0) envelope_180)] +theorem common_sub_295 : commonEnvelope childrenD_295 ⊆ insert (3, 1) required_295 := by decide +kernel +theorem child_required_sub_295 : ∀ j, childrenC_295 j ⊆ insert (3, 1) required_295 := by decide +kernel +theorem child_envelope_sub_295 : ∀ j, childrenD_295 j ⊆ envelope_295 := by decide +kernel +theorem pivot_mem_295 : (3, 1) ∈ envelope_295 := by decide +kernel +theorem children_work_295 : ∀ j, Template HasSnaky 6 (childrenC_295 j) (childrenD_295 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_34 5 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_180 5 (6, 0)).mono (by decide +kernel) +theorem row_works_295 : Template HasSnaky 7 required_295 envelope_295 := by + refine compose HasSnaky 6 childrenC_295 childrenD_295 children_work_295 (3, 1) + required_295 envelope_295 pivot_mem_295 child_required_sub_295 child_envelope_sub_295 ?_ + intro b hb + exact common_sub_295 (mem_commonEnvelope childrenD_295 b hb) +def required_297 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_297 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 3), (5, 4), (6, 3), (6, 4), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_297 : Fin 3 → Finset Cell := ![(placed21 7 (6, 4) required_9), (placed21 0 (1, 0) required_142), (placed21 4 (2, 6) required_162)] +def childrenD_297 : Fin 3 → Finset Cell := ![(placed21 7 (6, 4) envelope_9), (placed21 0 (1, 0) envelope_142), (placed21 4 (2, 6) envelope_162)] +theorem common_sub_297 : commonEnvelope childrenD_297 ⊆ insert (5, 3) required_297 := by decide +kernel +theorem child_required_sub_297 : ∀ j, childrenC_297 j ⊆ insert (5, 3) required_297 := by decide +kernel +theorem child_envelope_sub_297 : ∀ j, childrenD_297 j ⊆ envelope_297 := by decide +kernel +theorem pivot_mem_297 : (5, 3) ∈ envelope_297 := by decide +kernel +theorem children_work_297 : ∀ j, Template HasSnaky 6 (childrenC_297 j) (childrenD_297 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 7 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_142 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_162 4 (2, 6)).mono (by decide +kernel) +theorem row_works_297 : Template HasSnaky 7 required_297 envelope_297 := by + refine compose HasSnaky 6 childrenC_297 childrenD_297 children_work_297 (5, 3) + required_297 envelope_297 pivot_mem_297 child_required_sub_297 child_envelope_sub_297 ?_ + intro b hb + exact common_sub_297 (mem_commonEnvelope childrenD_297 b hb) +def required_298 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_298 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_298 : Fin 3 → Finset Cell := ![(placed21 7 (6, 3) required_7), (placed21 0 (1, 0) required_142), (placed21 4 (2, 6) required_161)] +def childrenD_298 : Fin 3 → Finset Cell := ![(placed21 7 (6, 3) envelope_7), (placed21 0 (1, 0) envelope_142), (placed21 4 (2, 6) envelope_161)] +theorem common_sub_298 : commonEnvelope childrenD_298 ⊆ insert (5, 3) required_298 := by decide +kernel +theorem child_required_sub_298 : ∀ j, childrenC_298 j ⊆ insert (5, 3) required_298 := by decide +kernel +theorem child_envelope_sub_298 : ∀ j, childrenD_298 j ⊆ envelope_298 := by decide +kernel +theorem pivot_mem_298 : (5, 3) ∈ envelope_298 := by decide +kernel +theorem children_work_298 : ∀ j, Template HasSnaky 6 (childrenC_298 j) (childrenD_298 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 7 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_142 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_161 4 (2, 6)).mono (by decide +kernel) +theorem row_works_298 : Template HasSnaky 7 required_298 envelope_298 := by + refine compose HasSnaky 6 childrenC_298 childrenD_298 children_work_298 (5, 3) + required_298 envelope_298 pivot_mem_298 child_required_sub_298 child_envelope_sub_298 ?_ + intro b hb + exact common_sub_298 (mem_commonEnvelope childrenD_298 b hb) +def required_309 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_309 : Finset Cell := ⟨(([(0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (4, 3), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_309 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) required_19), (placed21 3 (0, 4) required_19), (placed21 2 (4, 0) required_115)] +def childrenD_309 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) envelope_19), (placed21 3 (0, 4) envelope_19), (placed21 2 (4, 0) envelope_115)] +theorem common_sub_309 : commonEnvelope childrenD_309 ⊆ insert (4, 3) required_309 := by decide +kernel +theorem child_required_sub_309 : ∀ j, childrenC_309 j ⊆ insert (4, 3) required_309 := by decide +kernel +theorem child_envelope_sub_309 : ∀ j, childrenD_309 j ⊆ envelope_309 := by decide +kernel +theorem pivot_mem_309 : (4, 3) ∈ envelope_309 := by decide +kernel +theorem children_work_309 : ∀ j, Template HasSnaky 6 (childrenC_309 j) (childrenD_309 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_19 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_115 2 (4, 0)).mono (by decide +kernel) +theorem row_works_309 : Template HasSnaky 7 required_309 envelope_309 := by + refine compose HasSnaky 6 childrenC_309 childrenD_309 children_work_309 (4, 3) + required_309 envelope_309 pivot_mem_309 child_required_sub_309 child_envelope_sub_309 ?_ + intro b hb + exact common_sub_309 (mem_commonEnvelope childrenD_309 b hb) +def required_317 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_317 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_317 : Fin 3 → Finset Cell := ![(placed21 1 (0, 4) required_44), (placed21 2 (4, 2) required_60), (placed21 0 (2, 0) required_316)] +def childrenD_317 : Fin 3 → Finset Cell := ![(placed21 1 (0, 4) envelope_44), (placed21 2 (4, 2) envelope_60), (placed21 0 (2, 0) envelope_316)] +theorem common_sub_317 : commonEnvelope childrenD_317 ⊆ insert (3, 5) required_317 := by decide +kernel +theorem child_required_sub_317 : ∀ j, childrenC_317 j ⊆ insert (3, 5) required_317 := by decide +kernel +theorem child_envelope_sub_317 : ∀ j, childrenD_317 j ⊆ envelope_317 := by decide +kernel +theorem pivot_mem_317 : (3, 5) ∈ envelope_317 := by decide +kernel +theorem children_work_317 : ∀ j, Template HasSnaky 6 (childrenC_317 j) (childrenD_317 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_60 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_316 0 (2, 0)).mono (by decide +kernel) +theorem row_works_317 : Template HasSnaky 7 required_317 envelope_317 := by + refine compose HasSnaky 6 childrenC_317 childrenD_317 children_work_317 (3, 5) + required_317 envelope_317 pivot_mem_317 child_required_sub_317 child_envelope_sub_317 ?_ + intro b hb + exact common_sub_317 (mem_commonEnvelope childrenD_317 b hb) +def required_318 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_318 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 7), (2, 8), (2, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_318 : Fin 4 → Finset Cell := ![(placed21 4 (0, 6) required_10), (placed21 2 (1, 2) required_52), (placed21 6 (1, 6) required_52), (placed21 0 (0, 2) required_315)] +def childrenD_318 : Fin 4 → Finset Cell := ![(placed21 4 (0, 6) envelope_10), (placed21 2 (1, 2) envelope_52), (placed21 6 (1, 6) envelope_52), (placed21 0 (0, 2) envelope_315)] +theorem common_sub_318 : commonEnvelope childrenD_318 ⊆ insert (1, 3) required_318 := by decide +kernel +theorem child_required_sub_318 : ∀ j, childrenC_318 j ⊆ insert (1, 3) required_318 := by decide +kernel +theorem child_envelope_sub_318 : ∀ j, childrenD_318 j ⊆ envelope_318 := by decide +kernel +theorem pivot_mem_318 : (1, 3) ∈ envelope_318 := by decide +kernel +theorem children_work_318 : ∀ j, Template HasSnaky 6 (childrenC_318 j) (childrenD_318 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_315 0 (0, 2)).mono (by decide +kernel) +theorem row_works_318 : Template HasSnaky 7 required_318 envelope_318 := by + refine compose HasSnaky 6 childrenC_318 childrenD_318 children_work_318 (1, 3) + required_318 envelope_318 pivot_mem_318 child_required_sub_318 child_envelope_sub_318 ?_ + intro b hb + exact common_sub_318 (mem_commonEnvelope childrenD_318 b hb) +def required_320 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_320 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 5), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_320 : Fin 2 → Finset Cell := ![(placed21 0 (0, 4) required_5), (placed21 0 (2, 0) required_316)] +def childrenD_320 : Fin 2 → Finset Cell := ![(placed21 0 (0, 4) envelope_5), (placed21 0 (2, 0) envelope_316)] +theorem common_sub_320 : commonEnvelope childrenD_320 ⊆ insert (3, 5) required_320 := by decide +kernel +theorem child_required_sub_320 : ∀ j, childrenC_320 j ⊆ insert (3, 5) required_320 := by decide +kernel +theorem child_envelope_sub_320 : ∀ j, childrenD_320 j ⊆ envelope_320 := by decide +kernel +theorem pivot_mem_320 : (3, 5) ∈ envelope_320 := by decide +kernel +theorem children_work_320 : ∀ j, Template HasSnaky 6 (childrenC_320 j) (childrenD_320 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_316 0 (2, 0)).mono (by decide +kernel) +theorem row_works_320 : Template HasSnaky 7 required_320 envelope_320 := by + refine compose HasSnaky 6 childrenC_320 childrenD_320 children_work_320 (3, 5) + required_320 envelope_320 pivot_mem_320 child_required_sub_320 child_envelope_sub_320 ?_ + intro b hb + exact common_sub_320 (mem_commonEnvelope childrenD_320 b hb) +def required_324 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_324 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_324 : Fin 4 → Finset Cell := ![(placed21 4 (0, 6) required_60), (placed21 0 (0, 2) required_237), (placed21 0 (0, 2) required_307), (placed21 2 (2, 0) required_316)] +def childrenD_324 : Fin 4 → Finset Cell := ![(placed21 4 (0, 6) envelope_60), (placed21 0 (0, 2) envelope_237), (placed21 0 (0, 2) envelope_307), (placed21 2 (2, 0) envelope_316)] +theorem common_sub_324 : commonEnvelope childrenD_324 ⊆ insert (1, 3) required_324 := by decide +kernel +theorem child_required_sub_324 : ∀ j, childrenC_324 j ⊆ insert (1, 3) required_324 := by decide +kernel +theorem child_envelope_sub_324 : ∀ j, childrenD_324 j ⊆ envelope_324 := by decide +kernel +theorem pivot_mem_324 : (1, 3) ∈ envelope_324 := by decide +kernel +theorem children_work_324 : ∀ j, Template HasSnaky 6 (childrenC_324 j) (childrenD_324 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_60 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_237 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_307 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_316 2 (2, 0)).mono (by decide +kernel) +theorem row_works_324 : Template HasSnaky 7 required_324 envelope_324 := by + refine compose HasSnaky 6 childrenC_324 childrenD_324 children_work_324 (1, 3) + required_324 envelope_324 pivot_mem_324 child_required_sub_324 child_envelope_sub_324 ?_ + intro b hb + exact common_sub_324 (mem_commonEnvelope childrenD_324 b hb) +def required_329 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_329 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 7), (2, 8), (2, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_329 : Fin 4 → Finset Cell := ![(placed21 4 (0, 6) required_10), (placed21 2 (1, 2) required_52), (placed21 6 (1, 6) required_52), (placed21 0 (0, 2) required_315)] +def childrenD_329 : Fin 4 → Finset Cell := ![(placed21 4 (0, 6) envelope_10), (placed21 2 (1, 2) envelope_52), (placed21 6 (1, 6) envelope_52), (placed21 0 (0, 2) envelope_315)] +theorem common_sub_329 : commonEnvelope childrenD_329 ⊆ insert (1, 4) required_329 := by decide +kernel +theorem child_required_sub_329 : ∀ j, childrenC_329 j ⊆ insert (1, 4) required_329 := by decide +kernel +theorem child_envelope_sub_329 : ∀ j, childrenD_329 j ⊆ envelope_329 := by decide +kernel +theorem pivot_mem_329 : (1, 4) ∈ envelope_329 := by decide +kernel +theorem children_work_329 : ∀ j, Template HasSnaky 6 (childrenC_329 j) (childrenD_329 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_315 0 (0, 2)).mono (by decide +kernel) +theorem row_works_329 : Template HasSnaky 7 required_329 envelope_329 := by + refine compose HasSnaky 6 childrenC_329 childrenD_329 children_work_329 (1, 4) + required_329 envelope_329 pivot_mem_329 child_required_sub_329 child_envelope_sub_329 ?_ + intro b hb + exact common_sub_329 (mem_commonEnvelope childrenD_329 b hb) +def required_332 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_332 : Finset Cell := ⟨(([(0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (4, 3), (4, 4), (5, 3), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_332 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) required_9), (placed21 1 (0, 3) required_11), (placed21 2 (4, 0) required_331)] +def childrenD_332 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) envelope_9), (placed21 1 (0, 3) envelope_11), (placed21 2 (4, 0) envelope_331)] +theorem common_sub_332 : commonEnvelope childrenD_332 ⊆ insert (4, 3) required_332 := by decide +kernel +theorem child_required_sub_332 : ∀ j, childrenC_332 j ⊆ insert (4, 3) required_332 := by decide +kernel +theorem child_envelope_sub_332 : ∀ j, childrenD_332 j ⊆ envelope_332 := by decide +kernel +theorem pivot_mem_332 : (4, 3) ∈ envelope_332 := by decide +kernel +theorem children_work_332 : ∀ j, Template HasSnaky 6 (childrenC_332 j) (childrenD_332 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_11 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_331 2 (4, 0)).mono (by decide +kernel) +theorem row_works_332 : Template HasSnaky 7 required_332 envelope_332 := by + refine compose HasSnaky 6 childrenC_332 childrenD_332 children_work_332 (4, 3) + required_332 envelope_332 pivot_mem_332 child_required_sub_332 child_envelope_sub_332 ?_ + intro b hb + exact common_sub_332 (mem_commonEnvelope childrenD_332 b hb) +def required_337 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_337 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 7), (0, 8), (0, 9), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_337 : Fin 3 → Finset Cell := ![(placed21 4 (1, 6) required_7), (placed21 3 (0, 5) required_143), (placed21 0 (0, 2) required_336)] +def childrenD_337 : Fin 3 → Finset Cell := ![(placed21 4 (1, 6) envelope_7), (placed21 3 (0, 5) envelope_143), (placed21 0 (0, 2) envelope_336)] +theorem common_sub_337 : commonEnvelope childrenD_337 ⊆ insert (1, 2) required_337 := by decide +kernel +theorem child_required_sub_337 : ∀ j, childrenC_337 j ⊆ insert (1, 2) required_337 := by decide +kernel +theorem child_envelope_sub_337 : ∀ j, childrenD_337 j ⊆ envelope_337 := by decide +kernel +theorem pivot_mem_337 : (1, 2) ∈ envelope_337 := by decide +kernel +theorem children_work_337 : ∀ j, Template HasSnaky 6 (childrenC_337 j) (childrenD_337 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_143 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_336 0 (0, 2)).mono (by decide +kernel) +theorem row_works_337 : Template HasSnaky 7 required_337 envelope_337 := by + refine compose HasSnaky 6 childrenC_337 childrenD_337 children_work_337 (1, 2) + required_337 envelope_337 pivot_mem_337 child_required_sub_337 child_envelope_sub_337 ?_ + intro b hb + exact common_sub_337 (mem_commonEnvelope childrenD_337 b hb) +def required_339 : Finset Cell := ⟨(([(0, 1), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_339 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_339 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) required_35), (placed21 2 (4, 1) required_336)] +def childrenD_339 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) envelope_35), (placed21 2 (4, 1) envelope_336)] +theorem common_sub_339 : commonEnvelope childrenD_339 ⊆ insert (4, 2) required_339 := by decide +kernel +theorem child_required_sub_339 : ∀ j, childrenC_339 j ⊆ insert (4, 2) required_339 := by decide +kernel +theorem child_envelope_sub_339 : ∀ j, childrenD_339 j ⊆ envelope_339 := by decide +kernel +theorem pivot_mem_339 : (4, 2) ∈ envelope_339 := by decide +kernel +theorem children_work_339 : ∀ j, Template HasSnaky 6 (childrenC_339 j) (childrenD_339 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_35 7 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_336 2 (4, 1)).mono (by decide +kernel) +theorem row_works_339 : Template HasSnaky 7 required_339 envelope_339 := by + refine compose HasSnaky 6 childrenC_339 childrenD_339 children_work_339 (4, 2) + required_339 envelope_339 pivot_mem_339 child_required_sub_339 child_envelope_sub_339 ?_ + intro b hb + exact common_sub_339 (mem_commonEnvelope childrenD_339 b hb) +def required_341 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_341 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 5), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_341 : Fin 3 → Finset Cell := ![(placed21 7 (6, 4) required_53), (placed21 5 (6, 2) required_57), (placed21 0 (2, 0) required_340)] +def childrenD_341 : Fin 3 → Finset Cell := ![(placed21 7 (6, 4) envelope_53), (placed21 5 (6, 2) envelope_57), (placed21 0 (2, 0) envelope_340)] +theorem common_sub_341 : commonEnvelope childrenD_341 ⊆ insert (4, 4) required_341 := by decide +kernel +theorem child_required_sub_341 : ∀ j, childrenC_341 j ⊆ insert (4, 4) required_341 := by decide +kernel +theorem child_envelope_sub_341 : ∀ j, childrenD_341 j ⊆ envelope_341 := by decide +kernel +theorem pivot_mem_341 : (4, 4) ∈ envelope_341 := by decide +kernel +theorem children_work_341 : ∀ j, Template HasSnaky 6 (childrenC_341 j) (childrenD_341 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 7 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_57 5 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_340 0 (2, 0)).mono (by decide +kernel) +theorem row_works_341 : Template HasSnaky 7 required_341 envelope_341 := by + refine compose HasSnaky 6 childrenC_341 childrenD_341 children_work_341 (4, 4) + required_341 envelope_341 pivot_mem_341 child_required_sub_341 child_envelope_sub_341 ?_ + intro b hb + exact common_sub_341 (mem_commonEnvelope childrenD_341 b hb) +def required_344 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_344 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_344 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_5), (placed21 0 (1, 0) required_343)] +def childrenD_344 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_5), (placed21 0 (1, 0) envelope_343)] +theorem common_sub_344 : commonEnvelope childrenD_344 ⊆ insert (1, 3) required_344 := by decide +kernel +theorem child_required_sub_344 : ∀ j, childrenC_344 j ⊆ insert (1, 3) required_344 := by decide +kernel +theorem child_envelope_sub_344 : ∀ j, childrenD_344 j ⊆ envelope_344 := by decide +kernel +theorem pivot_mem_344 : (1, 3) ∈ envelope_344 := by decide +kernel +theorem children_work_344 : ∀ j, Template HasSnaky 6 (childrenC_344 j) (childrenD_344 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_343 0 (1, 0)).mono (by decide +kernel) +theorem row_works_344 : Template HasSnaky 7 required_344 envelope_344 := by + refine compose HasSnaky 6 childrenC_344 childrenD_344 children_work_344 (1, 3) + required_344 envelope_344 pivot_mem_344 child_required_sub_344 child_envelope_sub_344 ?_ + intro b hb + exact common_sub_344 (mem_commonEnvelope childrenD_344 b hb) +def required_353 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_353 : Finset Cell := ⟨(([(0, 6), (0, 7), (0, 8), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_353 : Fin 2 → Finset Cell := ![(placed21 6 (5, 9) required_95), (placed21 1 (0, 2) required_352)] +def childrenD_353 : Fin 2 → Finset Cell := ![(placed21 6 (5, 9) envelope_95), (placed21 1 (0, 2) envelope_352)] +theorem common_sub_353 : commonEnvelope childrenD_353 ⊆ insert (4, 6) required_353 := by decide +kernel +theorem child_required_sub_353 : ∀ j, childrenC_353 j ⊆ insert (4, 6) required_353 := by decide +kernel +theorem child_envelope_sub_353 : ∀ j, childrenD_353 j ⊆ envelope_353 := by decide +kernel +theorem pivot_mem_353 : (4, 6) ∈ envelope_353 := by decide +kernel +theorem children_work_353 : ∀ j, Template HasSnaky 6 (childrenC_353 j) (childrenD_353 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_95 6 (5, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_352 1 (0, 2)).mono (by decide +kernel) +theorem row_works_353 : Template HasSnaky 7 required_353 envelope_353 := by + refine compose HasSnaky 6 childrenC_353 childrenD_353 children_work_353 (4, 6) + required_353 envelope_353 pivot_mem_353 child_required_sub_353 child_envelope_sub_353 ?_ + intro b hb + exact common_sub_353 (mem_commonEnvelope childrenD_353 b hb) +def height_116 : ℕ := 7 +def childrenH_116 : Fin 3 → ℕ := ![height_7, height_9, height_115] +theorem height_exact_116 : height_116 = 1 + Finset.univ.sup childrenH_116 := by decide +kernel +theorem required_origin_116 : ∀ x ∈ required_116, + (∃ j, x ∈ childrenC_116 j) ∨ ∀ j, x ∈ childrenD_116 j := by decide +kernel +theorem required_exact_116 : required_116 = + ((Finset.univ.biUnion childrenC_116) ∪ commonEnvelope childrenD_116).erase (4, 3) := by + exact required_eq_combination childrenC_116 childrenD_116 (4, 3) required_116 + (by decide +kernel) child_required_sub_116 common_sub_116 required_origin_116 +theorem envelope_origin_116 : ∀ x ∈ envelope_116, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_116 j := by decide +kernel +theorem envelope_exact_116 : envelope_116 = + insert (4, 3) (Finset.univ.biUnion childrenD_116) := by + exact envelope_eq_combination childrenD_116 (4, 3) envelope_116 + pivot_mem_116 child_envelope_sub_116 envelope_origin_116 +def checked_116 : CheckedCard where + required := required_116 + envelope := envelope_116 + height := height_116 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_116 +def height_117 : ℕ := 7 +def childrenH_117 : Fin 3 → ℕ := ![height_7, height_9, height_115] +theorem height_exact_117 : height_117 = 1 + Finset.univ.sup childrenH_117 := by decide +kernel +theorem required_origin_117 : ∀ x ∈ required_117, + (∃ j, x ∈ childrenC_117 j) ∨ ∀ j, x ∈ childrenD_117 j := by decide +kernel +theorem required_exact_117 : required_117 = + ((Finset.univ.biUnion childrenC_117) ∪ commonEnvelope childrenD_117).erase (4, 3) := by + exact required_eq_combination childrenC_117 childrenD_117 (4, 3) required_117 + (by decide +kernel) child_required_sub_117 common_sub_117 required_origin_117 +theorem envelope_origin_117 : ∀ x ∈ envelope_117, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_117 j := by decide +kernel +theorem envelope_exact_117 : envelope_117 = + insert (4, 3) (Finset.univ.biUnion childrenD_117) := by + exact envelope_eq_combination childrenD_117 (4, 3) envelope_117 + pivot_mem_117 child_envelope_sub_117 envelope_origin_117 +def checked_117 : CheckedCard where + required := required_117 + envelope := envelope_117 + height := height_117 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_117 +def height_118 : ℕ := 7 +def childrenH_118 : Fin 3 → ℕ := ![height_7, height_9, height_115] +theorem height_exact_118 : height_118 = 1 + Finset.univ.sup childrenH_118 := by decide +kernel +theorem required_origin_118 : ∀ x ∈ required_118, + (∃ j, x ∈ childrenC_118 j) ∨ ∀ j, x ∈ childrenD_118 j := by decide +kernel +theorem required_exact_118 : required_118 = + ((Finset.univ.biUnion childrenC_118) ∪ commonEnvelope childrenD_118).erase (4, 3) := by + exact required_eq_combination childrenC_118 childrenD_118 (4, 3) required_118 + (by decide +kernel) child_required_sub_118 common_sub_118 required_origin_118 +theorem envelope_origin_118 : ∀ x ∈ envelope_118, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_118 j := by decide +kernel +theorem envelope_exact_118 : envelope_118 = + insert (4, 3) (Finset.univ.biUnion childrenD_118) := by + exact envelope_eq_combination childrenD_118 (4, 3) envelope_118 + pivot_mem_118 child_envelope_sub_118 envelope_origin_118 +def checked_118 : CheckedCard where + required := required_118 + envelope := envelope_118 + height := height_118 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_118 +def height_204 : ℕ := 7 +def childrenH_204 : Fin 2 → ℕ := ![height_52, height_203] +theorem height_exact_204 : height_204 = 1 + Finset.univ.sup childrenH_204 := by decide +kernel +theorem required_origin_204 : ∀ x ∈ required_204, + (∃ j, x ∈ childrenC_204 j) ∨ ∀ j, x ∈ childrenD_204 j := by decide +kernel +theorem required_exact_204 : required_204 = + ((Finset.univ.biUnion childrenC_204) ∪ commonEnvelope childrenD_204).erase (2, 3) := by + exact required_eq_combination childrenC_204 childrenD_204 (2, 3) required_204 + (by decide +kernel) child_required_sub_204 common_sub_204 required_origin_204 +theorem envelope_origin_204 : ∀ x ∈ envelope_204, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_204 j := by decide +kernel +theorem envelope_exact_204 : envelope_204 = + insert (2, 3) (Finset.univ.biUnion childrenD_204) := by + exact envelope_eq_combination childrenD_204 (2, 3) envelope_204 + pivot_mem_204 child_envelope_sub_204 envelope_origin_204 +def checked_204 : CheckedCard where + required := required_204 + envelope := envelope_204 + height := height_204 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_204 +def height_256 : ℕ := 7 +def childrenH_256 : Fin 2 → ℕ := ![height_5, height_255] +theorem height_exact_256 : height_256 = 1 + Finset.univ.sup childrenH_256 := by decide +kernel +theorem required_origin_256 : ∀ x ∈ required_256, + (∃ j, x ∈ childrenC_256 j) ∨ ∀ j, x ∈ childrenD_256 j := by decide +kernel +theorem required_exact_256 : required_256 = + ((Finset.univ.biUnion childrenC_256) ∪ commonEnvelope childrenD_256).erase (3, 4) := by + exact required_eq_combination childrenC_256 childrenD_256 (3, 4) required_256 + (by decide +kernel) child_required_sub_256 common_sub_256 required_origin_256 +theorem envelope_origin_256 : ∀ x ∈ envelope_256, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_256 j := by decide +kernel +theorem envelope_exact_256 : envelope_256 = + insert (3, 4) (Finset.univ.biUnion childrenD_256) := by + exact envelope_eq_combination childrenD_256 (3, 4) envelope_256 + pivot_mem_256 child_envelope_sub_256 envelope_origin_256 +def checked_256 : CheckedCard where + required := required_256 + envelope := envelope_256 + height := height_256 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_256 +def height_276 : ℕ := 7 +def childrenH_276 : Fin 4 → ℕ := ![height_44, height_52, height_155, height_275] +theorem height_exact_276 : height_276 = 1 + Finset.univ.sup childrenH_276 := by decide +kernel +theorem required_origin_276 : ∀ x ∈ required_276, + (∃ j, x ∈ childrenC_276 j) ∨ ∀ j, x ∈ childrenD_276 j := by decide +kernel +theorem required_exact_276 : required_276 = + ((Finset.univ.biUnion childrenC_276) ∪ commonEnvelope childrenD_276).erase (2, 4) := by + exact required_eq_combination childrenC_276 childrenD_276 (2, 4) required_276 + (by decide +kernel) child_required_sub_276 common_sub_276 required_origin_276 +theorem envelope_origin_276 : ∀ x ∈ envelope_276, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_276 j := by decide +kernel +theorem envelope_exact_276 : envelope_276 = + insert (2, 4) (Finset.univ.biUnion childrenD_276) := by + exact envelope_eq_combination childrenD_276 (2, 4) envelope_276 + pivot_mem_276 child_envelope_sub_276 envelope_origin_276 +def checked_276 : CheckedCard where + required := required_276 + envelope := envelope_276 + height := height_276 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_276 +def height_286 : ℕ := 7 +def childrenH_286 : Fin 2 → ℕ := ![height_35, height_253] +theorem height_exact_286 : height_286 = 1 + Finset.univ.sup childrenH_286 := by decide +kernel +theorem required_origin_286 : ∀ x ∈ required_286, + (∃ j, x ∈ childrenC_286 j) ∨ ∀ j, x ∈ childrenD_286 j := by decide +kernel +theorem required_exact_286 : required_286 = + ((Finset.univ.biUnion childrenC_286) ∪ commonEnvelope childrenD_286).erase (4, 2) := by + exact required_eq_combination childrenC_286 childrenD_286 (4, 2) required_286 + (by decide +kernel) child_required_sub_286 common_sub_286 required_origin_286 +theorem envelope_origin_286 : ∀ x ∈ envelope_286, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_286 j := by decide +kernel +theorem envelope_exact_286 : envelope_286 = + insert (4, 2) (Finset.univ.biUnion childrenD_286) := by + exact envelope_eq_combination childrenD_286 (4, 2) envelope_286 + pivot_mem_286 child_envelope_sub_286 envelope_origin_286 +def checked_286 : CheckedCard where + required := required_286 + envelope := envelope_286 + height := height_286 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_286 +def height_290 : ℕ := 7 +def childrenH_290 : Fin 2 → ℕ := ![height_5, height_203] +theorem height_exact_290 : height_290 = 1 + Finset.univ.sup childrenH_290 := by decide +kernel +theorem required_origin_290 : ∀ x ∈ required_290, + (∃ j, x ∈ childrenC_290 j) ∨ ∀ j, x ∈ childrenD_290 j := by decide +kernel +theorem required_exact_290 : required_290 = + ((Finset.univ.biUnion childrenC_290) ∪ commonEnvelope childrenD_290).erase (2, 1) := by + exact required_eq_combination childrenC_290 childrenD_290 (2, 1) required_290 + (by decide +kernel) child_required_sub_290 common_sub_290 required_origin_290 +theorem envelope_origin_290 : ∀ x ∈ envelope_290, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_290 j := by decide +kernel +theorem envelope_exact_290 : envelope_290 = + insert (2, 1) (Finset.univ.biUnion childrenD_290) := by + exact envelope_eq_combination childrenD_290 (2, 1) envelope_290 + pivot_mem_290 child_envelope_sub_290 envelope_origin_290 +def checked_290 : CheckedCard where + required := required_290 + envelope := envelope_290 + height := height_290 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_290 +def height_295 : ℕ := 7 +def childrenH_295 : Fin 2 → ℕ := ![height_34, height_180] +theorem height_exact_295 : height_295 = 1 + Finset.univ.sup childrenH_295 := by decide +kernel +theorem required_origin_295 : ∀ x ∈ required_295, + (∃ j, x ∈ childrenC_295 j) ∨ ∀ j, x ∈ childrenD_295 j := by decide +kernel +theorem required_exact_295 : required_295 = + ((Finset.univ.biUnion childrenC_295) ∪ commonEnvelope childrenD_295).erase (3, 1) := by + exact required_eq_combination childrenC_295 childrenD_295 (3, 1) required_295 + (by decide +kernel) child_required_sub_295 common_sub_295 required_origin_295 +theorem envelope_origin_295 : ∀ x ∈ envelope_295, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_295 j := by decide +kernel +theorem envelope_exact_295 : envelope_295 = + insert (3, 1) (Finset.univ.biUnion childrenD_295) := by + exact envelope_eq_combination childrenD_295 (3, 1) envelope_295 + pivot_mem_295 child_envelope_sub_295 envelope_origin_295 +def checked_295 : CheckedCard where + required := required_295 + envelope := envelope_295 + height := height_295 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_295 +def height_297 : ℕ := 7 +def childrenH_297 : Fin 3 → ℕ := ![height_9, height_142, height_162] +theorem height_exact_297 : height_297 = 1 + Finset.univ.sup childrenH_297 := by decide +kernel +theorem required_origin_297 : ∀ x ∈ required_297, + (∃ j, x ∈ childrenC_297 j) ∨ ∀ j, x ∈ childrenD_297 j := by decide +kernel +theorem required_exact_297 : required_297 = + ((Finset.univ.biUnion childrenC_297) ∪ commonEnvelope childrenD_297).erase (5, 3) := by + exact required_eq_combination childrenC_297 childrenD_297 (5, 3) required_297 + (by decide +kernel) child_required_sub_297 common_sub_297 required_origin_297 +theorem envelope_origin_297 : ∀ x ∈ envelope_297, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_297 j := by decide +kernel +theorem envelope_exact_297 : envelope_297 = + insert (5, 3) (Finset.univ.biUnion childrenD_297) := by + exact envelope_eq_combination childrenD_297 (5, 3) envelope_297 + pivot_mem_297 child_envelope_sub_297 envelope_origin_297 +def checked_297 : CheckedCard where + required := required_297 + envelope := envelope_297 + height := height_297 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_297 +def height_298 : ℕ := 7 +def childrenH_298 : Fin 3 → ℕ := ![height_7, height_142, height_161] +theorem height_exact_298 : height_298 = 1 + Finset.univ.sup childrenH_298 := by decide +kernel +theorem required_origin_298 : ∀ x ∈ required_298, + (∃ j, x ∈ childrenC_298 j) ∨ ∀ j, x ∈ childrenD_298 j := by decide +kernel +theorem required_exact_298 : required_298 = + ((Finset.univ.biUnion childrenC_298) ∪ commonEnvelope childrenD_298).erase (5, 3) := by + exact required_eq_combination childrenC_298 childrenD_298 (5, 3) required_298 + (by decide +kernel) child_required_sub_298 common_sub_298 required_origin_298 +theorem envelope_origin_298 : ∀ x ∈ envelope_298, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_298 j := by decide +kernel +theorem envelope_exact_298 : envelope_298 = + insert (5, 3) (Finset.univ.biUnion childrenD_298) := by + exact envelope_eq_combination childrenD_298 (5, 3) envelope_298 + pivot_mem_298 child_envelope_sub_298 envelope_origin_298 +def checked_298 : CheckedCard where + required := required_298 + envelope := envelope_298 + height := height_298 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_298 +def height_309 : ℕ := 7 +def childrenH_309 : Fin 3 → ℕ := ![height_19, height_19, height_115] +theorem height_exact_309 : height_309 = 1 + Finset.univ.sup childrenH_309 := by decide +kernel +theorem required_origin_309 : ∀ x ∈ required_309, + (∃ j, x ∈ childrenC_309 j) ∨ ∀ j, x ∈ childrenD_309 j := by decide +kernel +theorem required_exact_309 : required_309 = + ((Finset.univ.biUnion childrenC_309) ∪ commonEnvelope childrenD_309).erase (4, 3) := by + exact required_eq_combination childrenC_309 childrenD_309 (4, 3) required_309 + (by decide +kernel) child_required_sub_309 common_sub_309 required_origin_309 +theorem envelope_origin_309 : ∀ x ∈ envelope_309, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_309 j := by decide +kernel +theorem envelope_exact_309 : envelope_309 = + insert (4, 3) (Finset.univ.biUnion childrenD_309) := by + exact envelope_eq_combination childrenD_309 (4, 3) envelope_309 + pivot_mem_309 child_envelope_sub_309 envelope_origin_309 +def checked_309 : CheckedCard where + required := required_309 + envelope := envelope_309 + height := height_309 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_309 +def height_317 : ℕ := 7 +def childrenH_317 : Fin 3 → ℕ := ![height_44, height_60, height_316] +theorem height_exact_317 : height_317 = 1 + Finset.univ.sup childrenH_317 := by decide +kernel +theorem required_origin_317 : ∀ x ∈ required_317, + (∃ j, x ∈ childrenC_317 j) ∨ ∀ j, x ∈ childrenD_317 j := by decide +kernel +theorem required_exact_317 : required_317 = + ((Finset.univ.biUnion childrenC_317) ∪ commonEnvelope childrenD_317).erase (3, 5) := by + exact required_eq_combination childrenC_317 childrenD_317 (3, 5) required_317 + (by decide +kernel) child_required_sub_317 common_sub_317 required_origin_317 +theorem envelope_origin_317 : ∀ x ∈ envelope_317, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_317 j := by decide +kernel +theorem envelope_exact_317 : envelope_317 = + insert (3, 5) (Finset.univ.biUnion childrenD_317) := by + exact envelope_eq_combination childrenD_317 (3, 5) envelope_317 + pivot_mem_317 child_envelope_sub_317 envelope_origin_317 +def checked_317 : CheckedCard where + required := required_317 + envelope := envelope_317 + height := height_317 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_317 +def height_318 : ℕ := 7 +def childrenH_318 : Fin 4 → ℕ := ![height_10, height_52, height_52, height_315] +theorem height_exact_318 : height_318 = 1 + Finset.univ.sup childrenH_318 := by decide +kernel +theorem required_origin_318 : ∀ x ∈ required_318, + (∃ j, x ∈ childrenC_318 j) ∨ ∀ j, x ∈ childrenD_318 j := by decide +kernel +theorem required_exact_318 : required_318 = + ((Finset.univ.biUnion childrenC_318) ∪ commonEnvelope childrenD_318).erase (1, 3) := by + exact required_eq_combination childrenC_318 childrenD_318 (1, 3) required_318 + (by decide +kernel) child_required_sub_318 common_sub_318 required_origin_318 +theorem envelope_origin_318 : ∀ x ∈ envelope_318, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_318 j := by decide +kernel +theorem envelope_exact_318 : envelope_318 = + insert (1, 3) (Finset.univ.biUnion childrenD_318) := by + exact envelope_eq_combination childrenD_318 (1, 3) envelope_318 + pivot_mem_318 child_envelope_sub_318 envelope_origin_318 +def checked_318 : CheckedCard where + required := required_318 + envelope := envelope_318 + height := height_318 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_318 +def height_320 : ℕ := 7 +def childrenH_320 : Fin 2 → ℕ := ![height_5, height_316] +theorem height_exact_320 : height_320 = 1 + Finset.univ.sup childrenH_320 := by decide +kernel +theorem required_origin_320 : ∀ x ∈ required_320, + (∃ j, x ∈ childrenC_320 j) ∨ ∀ j, x ∈ childrenD_320 j := by decide +kernel +theorem required_exact_320 : required_320 = + ((Finset.univ.biUnion childrenC_320) ∪ commonEnvelope childrenD_320).erase (3, 5) := by + exact required_eq_combination childrenC_320 childrenD_320 (3, 5) required_320 + (by decide +kernel) child_required_sub_320 common_sub_320 required_origin_320 +theorem envelope_origin_320 : ∀ x ∈ envelope_320, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_320 j := by decide +kernel +theorem envelope_exact_320 : envelope_320 = + insert (3, 5) (Finset.univ.biUnion childrenD_320) := by + exact envelope_eq_combination childrenD_320 (3, 5) envelope_320 + pivot_mem_320 child_envelope_sub_320 envelope_origin_320 +def checked_320 : CheckedCard where + required := required_320 + envelope := envelope_320 + height := height_320 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_320 +def height_324 : ℕ := 7 +def childrenH_324 : Fin 4 → ℕ := ![height_60, height_237, height_307, height_316] +theorem height_exact_324 : height_324 = 1 + Finset.univ.sup childrenH_324 := by decide +kernel +theorem required_origin_324 : ∀ x ∈ required_324, + (∃ j, x ∈ childrenC_324 j) ∨ ∀ j, x ∈ childrenD_324 j := by decide +kernel +theorem required_exact_324 : required_324 = + ((Finset.univ.biUnion childrenC_324) ∪ commonEnvelope childrenD_324).erase (1, 3) := by + exact required_eq_combination childrenC_324 childrenD_324 (1, 3) required_324 + (by decide +kernel) child_required_sub_324 common_sub_324 required_origin_324 +theorem envelope_origin_324 : ∀ x ∈ envelope_324, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_324 j := by decide +kernel +theorem envelope_exact_324 : envelope_324 = + insert (1, 3) (Finset.univ.biUnion childrenD_324) := by + exact envelope_eq_combination childrenD_324 (1, 3) envelope_324 + pivot_mem_324 child_envelope_sub_324 envelope_origin_324 +def checked_324 : CheckedCard where + required := required_324 + envelope := envelope_324 + height := height_324 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_324 +def height_329 : ℕ := 7 +def childrenH_329 : Fin 4 → ℕ := ![height_10, height_52, height_52, height_315] +theorem height_exact_329 : height_329 = 1 + Finset.univ.sup childrenH_329 := by decide +kernel +theorem required_origin_329 : ∀ x ∈ required_329, + (∃ j, x ∈ childrenC_329 j) ∨ ∀ j, x ∈ childrenD_329 j := by decide +kernel +theorem required_exact_329 : required_329 = + ((Finset.univ.biUnion childrenC_329) ∪ commonEnvelope childrenD_329).erase (1, 4) := by + exact required_eq_combination childrenC_329 childrenD_329 (1, 4) required_329 + (by decide +kernel) child_required_sub_329 common_sub_329 required_origin_329 +theorem envelope_origin_329 : ∀ x ∈ envelope_329, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_329 j := by decide +kernel +theorem envelope_exact_329 : envelope_329 = + insert (1, 4) (Finset.univ.biUnion childrenD_329) := by + exact envelope_eq_combination childrenD_329 (1, 4) envelope_329 + pivot_mem_329 child_envelope_sub_329 envelope_origin_329 +def checked_329 : CheckedCard where + required := required_329 + envelope := envelope_329 + height := height_329 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_329 +def height_332 : ℕ := 7 +def childrenH_332 : Fin 3 → ℕ := ![height_9, height_11, height_331] +theorem height_exact_332 : height_332 = 1 + Finset.univ.sup childrenH_332 := by decide +kernel +theorem required_origin_332 : ∀ x ∈ required_332, + (∃ j, x ∈ childrenC_332 j) ∨ ∀ j, x ∈ childrenD_332 j := by decide +kernel +theorem required_exact_332 : required_332 = + ((Finset.univ.biUnion childrenC_332) ∪ commonEnvelope childrenD_332).erase (4, 3) := by + exact required_eq_combination childrenC_332 childrenD_332 (4, 3) required_332 + (by decide +kernel) child_required_sub_332 common_sub_332 required_origin_332 +theorem envelope_origin_332 : ∀ x ∈ envelope_332, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_332 j := by decide +kernel +theorem envelope_exact_332 : envelope_332 = + insert (4, 3) (Finset.univ.biUnion childrenD_332) := by + exact envelope_eq_combination childrenD_332 (4, 3) envelope_332 + pivot_mem_332 child_envelope_sub_332 envelope_origin_332 +def checked_332 : CheckedCard where + required := required_332 + envelope := envelope_332 + height := height_332 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_332 +def height_337 : ℕ := 7 +def childrenH_337 : Fin 3 → ℕ := ![height_7, height_143, height_336] +theorem height_exact_337 : height_337 = 1 + Finset.univ.sup childrenH_337 := by decide +kernel +theorem required_origin_337 : ∀ x ∈ required_337, + (∃ j, x ∈ childrenC_337 j) ∨ ∀ j, x ∈ childrenD_337 j := by decide +kernel +theorem required_exact_337 : required_337 = + ((Finset.univ.biUnion childrenC_337) ∪ commonEnvelope childrenD_337).erase (1, 2) := by + exact required_eq_combination childrenC_337 childrenD_337 (1, 2) required_337 + (by decide +kernel) child_required_sub_337 common_sub_337 required_origin_337 +theorem envelope_origin_337 : ∀ x ∈ envelope_337, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_337 j := by decide +kernel +theorem envelope_exact_337 : envelope_337 = + insert (1, 2) (Finset.univ.biUnion childrenD_337) := by + exact envelope_eq_combination childrenD_337 (1, 2) envelope_337 + pivot_mem_337 child_envelope_sub_337 envelope_origin_337 +def checked_337 : CheckedCard where + required := required_337 + envelope := envelope_337 + height := height_337 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_337 +def height_339 : ℕ := 7 +def childrenH_339 : Fin 2 → ℕ := ![height_35, height_336] +theorem height_exact_339 : height_339 = 1 + Finset.univ.sup childrenH_339 := by decide +kernel +theorem required_origin_339 : ∀ x ∈ required_339, + (∃ j, x ∈ childrenC_339 j) ∨ ∀ j, x ∈ childrenD_339 j := by decide +kernel +theorem required_exact_339 : required_339 = + ((Finset.univ.biUnion childrenC_339) ∪ commonEnvelope childrenD_339).erase (4, 2) := by + exact required_eq_combination childrenC_339 childrenD_339 (4, 2) required_339 + (by decide +kernel) child_required_sub_339 common_sub_339 required_origin_339 +theorem envelope_origin_339 : ∀ x ∈ envelope_339, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_339 j := by decide +kernel +theorem envelope_exact_339 : envelope_339 = + insert (4, 2) (Finset.univ.biUnion childrenD_339) := by + exact envelope_eq_combination childrenD_339 (4, 2) envelope_339 + pivot_mem_339 child_envelope_sub_339 envelope_origin_339 +def checked_339 : CheckedCard where + required := required_339 + envelope := envelope_339 + height := height_339 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_339 +def height_341 : ℕ := 7 +def childrenH_341 : Fin 3 → ℕ := ![height_53, height_57, height_340] +theorem height_exact_341 : height_341 = 1 + Finset.univ.sup childrenH_341 := by decide +kernel +theorem required_origin_341 : ∀ x ∈ required_341, + (∃ j, x ∈ childrenC_341 j) ∨ ∀ j, x ∈ childrenD_341 j := by decide +kernel +theorem required_exact_341 : required_341 = + ((Finset.univ.biUnion childrenC_341) ∪ commonEnvelope childrenD_341).erase (4, 4) := by + exact required_eq_combination childrenC_341 childrenD_341 (4, 4) required_341 + (by decide +kernel) child_required_sub_341 common_sub_341 required_origin_341 +theorem envelope_origin_341 : ∀ x ∈ envelope_341, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_341 j := by decide +kernel +theorem envelope_exact_341 : envelope_341 = + insert (4, 4) (Finset.univ.biUnion childrenD_341) := by + exact envelope_eq_combination childrenD_341 (4, 4) envelope_341 + pivot_mem_341 child_envelope_sub_341 envelope_origin_341 +def checked_341 : CheckedCard where + required := required_341 + envelope := envelope_341 + height := height_341 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_341 +def height_344 : ℕ := 7 +def childrenH_344 : Fin 2 → ℕ := ![height_5, height_343] +theorem height_exact_344 : height_344 = 1 + Finset.univ.sup childrenH_344 := by decide +kernel +theorem required_origin_344 : ∀ x ∈ required_344, + (∃ j, x ∈ childrenC_344 j) ∨ ∀ j, x ∈ childrenD_344 j := by decide +kernel +theorem required_exact_344 : required_344 = + ((Finset.univ.biUnion childrenC_344) ∪ commonEnvelope childrenD_344).erase (1, 3) := by + exact required_eq_combination childrenC_344 childrenD_344 (1, 3) required_344 + (by decide +kernel) child_required_sub_344 common_sub_344 required_origin_344 +theorem envelope_origin_344 : ∀ x ∈ envelope_344, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_344 j := by decide +kernel +theorem envelope_exact_344 : envelope_344 = + insert (1, 3) (Finset.univ.biUnion childrenD_344) := by + exact envelope_eq_combination childrenD_344 (1, 3) envelope_344 + pivot_mem_344 child_envelope_sub_344 envelope_origin_344 +def checked_344 : CheckedCard where + required := required_344 + envelope := envelope_344 + height := height_344 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_344 +def height_353 : ℕ := 7 +def childrenH_353 : Fin 2 → ℕ := ![height_95, height_352] +theorem height_exact_353 : height_353 = 1 + Finset.univ.sup childrenH_353 := by decide +kernel +theorem required_origin_353 : ∀ x ∈ required_353, + (∃ j, x ∈ childrenC_353 j) ∨ ∀ j, x ∈ childrenD_353 j := by decide +kernel +theorem required_exact_353 : required_353 = + ((Finset.univ.biUnion childrenC_353) ∪ commonEnvelope childrenD_353).erase (4, 6) := by + exact required_eq_combination childrenC_353 childrenD_353 (4, 6) required_353 + (by decide +kernel) child_required_sub_353 common_sub_353 required_origin_353 +theorem envelope_origin_353 : ∀ x ∈ envelope_353, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_353 j := by decide +kernel +theorem envelope_exact_353 : envelope_353 = + insert (4, 6) (Finset.univ.biUnion childrenD_353) := by + exact envelope_eq_combination childrenD_353 (4, 6) envelope_353 + pivot_mem_353 child_envelope_sub_353 envelope_origin_353 +def checked_353 : CheckedCard where + required := required_353 + envelope := envelope_353 + height := height_353 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_353 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part02.lean new file mode 100644 index 0000000..87f96a8 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part02.lean @@ -0,0 +1,980 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_361 : Finset Cell := ⟨(([(2, 2), (2, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_361 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (5, 4), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_361 : Fin 3 → Finset Cell := ![(placed21 2 (3, 0) required_15), (placed21 1 (0, 0) required_57), (placed21 1 (1, 1) required_360)] +def childrenD_361 : Fin 3 → Finset Cell := ![(placed21 2 (3, 0) envelope_15), (placed21 1 (0, 0) envelope_57), (placed21 1 (1, 1) envelope_360)] +theorem common_sub_361 : commonEnvelope childrenD_361 ⊆ insert (3, 1) required_361 := by decide +kernel +theorem child_required_sub_361 : ∀ j, childrenC_361 j ⊆ insert (3, 1) required_361 := by decide +kernel +theorem child_envelope_sub_361 : ∀ j, childrenD_361 j ⊆ envelope_361 := by decide +kernel +theorem pivot_mem_361 : (3, 1) ∈ envelope_361 := by decide +kernel +theorem children_work_361 : ∀ j, Template HasSnaky 6 (childrenC_361 j) (childrenD_361 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 2 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_57 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_360 1 (1, 1)).mono (by decide +kernel) +theorem row_works_361 : Template HasSnaky 7 required_361 envelope_361 := by + refine compose HasSnaky 6 childrenC_361 childrenD_361 children_work_361 (3, 1) + required_361 envelope_361 pivot_mem_361 child_required_sub_361 child_envelope_sub_361 ?_ + intro b hb + exact common_sub_361 (mem_commonEnvelope childrenD_361 b hb) +def required_372_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (3, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_372_i0 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (2, 5), (3, 1), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (6, 0), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_372_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_81), (placed21 0 (1, 0) required_351)] +def childrenD_372_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_81), (placed21 0 (1, 0) envelope_351)] +theorem common_sub_372_i0 : commonEnvelope childrenD_372_i0 ⊆ insert (4, 4) required_372_i0 := by decide +kernel +theorem child_required_sub_372_i0 : ∀ j, childrenC_372_i0 j ⊆ insert (4, 4) required_372_i0 := by decide +kernel +theorem child_envelope_sub_372_i0 : ∀ j, childrenD_372_i0 j ⊆ envelope_372_i0 := by decide +kernel +theorem pivot_mem_372_i0 : (4, 4) ∈ envelope_372_i0 := by decide +kernel +theorem children_work_372_i0 : ∀ j, Template HasSnaky 5 (childrenC_372_i0 j) (childrenD_372_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_81 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_351 0 (1, 0)).mono (by decide +kernel) +theorem row_works_372_i0 : Template HasSnaky 6 required_372_i0 envelope_372_i0 := by + refine compose HasSnaky 5 childrenC_372_i0 childrenD_372_i0 children_work_372_i0 (4, 4) + required_372_i0 envelope_372_i0 pivot_mem_372_i0 child_required_sub_372_i0 child_envelope_sub_372_i0 ?_ + intro b hb + exact common_sub_372_i0 (mem_commonEnvelope childrenD_372_i0 b hb) +def required_372 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_372 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (6, 0), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_372 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_96), required_372_i0] +def childrenD_372 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_96), envelope_372_i0] +theorem common_sub_372 : commonEnvelope childrenD_372 ⊆ insert (4, 2) required_372 := by decide +kernel +theorem child_required_sub_372 : ∀ j, childrenC_372 j ⊆ insert (4, 2) required_372 := by decide +kernel +theorem child_envelope_sub_372 : ∀ j, childrenD_372 j ⊆ envelope_372 := by decide +kernel +theorem pivot_mem_372 : (4, 2) ∈ envelope_372 := by decide +kernel +theorem children_work_372 : ∀ j, Template HasSnaky 6 (childrenC_372 j) (childrenD_372 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_96 3 (0, 4)).mono (by decide +kernel) + · exact row_works_372_i0.mono (by decide +kernel) +theorem row_works_372 : Template HasSnaky 7 required_372 envelope_372 := by + refine compose HasSnaky 6 childrenC_372 childrenD_372 children_work_372 (4, 2) + required_372 envelope_372 pivot_mem_372 child_required_sub_372 child_envelope_sub_372 ?_ + intro b hb + exact common_sub_372 (mem_commonEnvelope childrenD_372 b hb) +def required_379 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 0), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_379 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_379 : Fin 3 → Finset Cell := ![(placed21 3 (0, 2) required_21), (placed21 1 (0, 1) required_37), required_378] +def childrenD_379 : Fin 3 → Finset Cell := ![(placed21 3 (0, 2) envelope_21), (placed21 1 (0, 1) envelope_37), envelope_378] +theorem common_sub_379 : commonEnvelope childrenD_379 ⊆ insert (3, 2) required_379 := by decide +kernel +theorem child_required_sub_379 : ∀ j, childrenC_379 j ⊆ insert (3, 2) required_379 := by decide +kernel +theorem child_envelope_sub_379 : ∀ j, childrenD_379 j ⊆ envelope_379 := by decide +kernel +theorem pivot_mem_379 : (3, 2) ∈ envelope_379 := by decide +kernel +theorem children_work_379 : ∀ j, Template HasSnaky 6 (childrenC_379 j) (childrenD_379 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 3 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_37 1 (0, 1)).mono (by decide +kernel) + · exact row_works_378.mono (by decide +kernel) +theorem row_works_379 : Template HasSnaky 7 required_379 envelope_379 := by + refine compose HasSnaky 6 childrenC_379 childrenD_379 children_work_379 (3, 2) + required_379 envelope_379 pivot_mem_379 child_required_sub_379 child_envelope_sub_379 ?_ + intro b hb + exact common_sub_379 (mem_commonEnvelope childrenD_379 b hb) +def required_385 : Finset Cell := ⟨(([(0, 2), (3, 1), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_385 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (7, 3), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_385 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_115), (placed21 7 (5, 4) required_383)] +def childrenD_385 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_115), (placed21 7 (5, 4) envelope_383)] +theorem common_sub_385 : commonEnvelope childrenD_385 ⊆ insert (3, 3) required_385 := by decide +kernel +theorem child_required_sub_385 : ∀ j, childrenC_385 j ⊆ insert (3, 3) required_385 := by decide +kernel +theorem child_envelope_sub_385 : ∀ j, childrenD_385 j ⊆ envelope_385 := by decide +kernel +theorem pivot_mem_385 : (3, 3) ∈ envelope_385 := by decide +kernel +theorem children_work_385 : ∀ j, Template HasSnaky 6 (childrenC_385 j) (childrenD_385 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_115 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_383 7 (5, 4)).mono (by decide +kernel) +theorem row_works_385 : Template HasSnaky 7 required_385 envelope_385 := by + refine compose HasSnaky 6 childrenC_385 childrenD_385 children_work_385 (3, 3) + required_385 envelope_385 pivot_mem_385 child_required_sub_385 child_envelope_sub_385 ?_ + intro b hb + exact common_sub_385 (mem_commonEnvelope childrenD_385 b hb) +def required_388 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_388 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_388 : Fin 2 → Finset Cell := ![(placed21 2 (2, 0) required_11), (placed21 0 (0, 1) required_387)] +def childrenD_388 : Fin 2 → Finset Cell := ![(placed21 2 (2, 0) envelope_11), (placed21 0 (0, 1) envelope_387)] +theorem common_sub_388 : commonEnvelope childrenD_388 ⊆ insert (2, 4) required_388 := by decide +kernel +theorem child_required_sub_388 : ∀ j, childrenC_388 j ⊆ insert (2, 4) required_388 := by decide +kernel +theorem child_envelope_sub_388 : ∀ j, childrenD_388 j ⊆ envelope_388 := by decide +kernel +theorem pivot_mem_388 : (2, 4) ∈ envelope_388 := by decide +kernel +theorem children_work_388 : ∀ j, Template HasSnaky 6 (childrenC_388 j) (childrenD_388 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 2 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_387 0 (0, 1)).mono (by decide +kernel) +theorem row_works_388 : Template HasSnaky 7 required_388 envelope_388 := by + refine compose HasSnaky 6 childrenC_388 childrenD_388 children_work_388 (2, 4) + required_388 envelope_388 pivot_mem_388 child_required_sub_388 child_envelope_sub_388 ?_ + intro b hb + exact common_sub_388 (mem_commonEnvelope childrenD_388 b hb) +def required_394 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_394 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_394 : Fin 3 → Finset Cell := ![(placed21 0 (0, 1) required_17), required_241, required_392] +def childrenD_394 : Fin 3 → Finset Cell := ![(placed21 0 (0, 1) envelope_17), envelope_241, envelope_392] +theorem common_sub_394 : commonEnvelope childrenD_394 ⊆ insert (1, 4) required_394 := by decide +kernel +theorem child_required_sub_394 : ∀ j, childrenC_394 j ⊆ insert (1, 4) required_394 := by decide +kernel +theorem child_envelope_sub_394 : ∀ j, childrenD_394 j ⊆ envelope_394 := by decide +kernel +theorem pivot_mem_394 : (1, 4) ∈ envelope_394 := by decide +kernel +theorem children_work_394 : ∀ j, Template HasSnaky 6 (childrenC_394 j) (childrenD_394 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_17 0 (0, 1)).mono (by decide +kernel) + · exact row_works_241.mono (by decide +kernel) + · exact row_works_392.mono (by decide +kernel) +theorem row_works_394 : Template HasSnaky 7 required_394 envelope_394 := by + refine compose HasSnaky 6 childrenC_394 childrenD_394 children_work_394 (1, 4) + required_394 envelope_394 pivot_mem_394 child_required_sub_394 child_envelope_sub_394 ?_ + intro b hb + exact common_sub_394 (mem_commonEnvelope childrenD_394 b hb) +def required_404_i1 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_404_i1 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_404_i1 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_0), required_354] +def childrenD_404_i1 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_0), envelope_354] +theorem common_sub_404_i1 : commonEnvelope childrenD_404_i1 ⊆ insert (3, 1) required_404_i1 := by decide +kernel +theorem child_required_sub_404_i1 : ∀ j, childrenC_404_i1 j ⊆ insert (3, 1) required_404_i1 := by decide +kernel +theorem child_envelope_sub_404_i1 : ∀ j, childrenD_404_i1 j ⊆ envelope_404_i1 := by decide +kernel +theorem pivot_mem_404_i1 : (3, 1) ∈ envelope_404_i1 := by decide +kernel +theorem children_work_404_i1 : ∀ j, Template HasSnaky 4 (childrenC_404_i1 j) (childrenD_404_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact row_works_354.mono (by decide +kernel) +theorem row_works_404_i1 : Template HasSnaky 5 required_404_i1 envelope_404_i1 := by + refine compose HasSnaky 4 childrenC_404_i1 childrenD_404_i1 children_work_404_i1 (3, 1) + required_404_i1 envelope_404_i1 pivot_mem_404_i1 child_required_sub_404_i1 child_envelope_sub_404_i1 ?_ + intro b hb + exact common_sub_404_i1 (mem_commonEnvelope childrenD_404_i1 b hb) +def required_404_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_404_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_404_i0 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), required_404_i1] +def childrenD_404_i0 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), envelope_404_i1] +theorem common_sub_404_i0 : commonEnvelope childrenD_404_i0 ⊆ insert (2, 1) required_404_i0 := by decide +kernel +theorem child_required_sub_404_i0 : ∀ j, childrenC_404_i0 j ⊆ insert (2, 1) required_404_i0 := by decide +kernel +theorem child_envelope_sub_404_i0 : ∀ j, childrenD_404_i0 j ⊆ envelope_404_i0 := by decide +kernel +theorem pivot_mem_404_i0 : (2, 1) ∈ envelope_404_i0 := by decide +kernel +theorem children_work_404_i0 : ∀ j, Template HasSnaky 5 (childrenC_404_i0 j) (childrenD_404_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact row_works_404_i1.mono (by decide +kernel) +theorem row_works_404_i0 : Template HasSnaky 6 required_404_i0 envelope_404_i0 := by + refine compose HasSnaky 5 childrenC_404_i0 childrenD_404_i0 children_work_404_i0 (2, 1) + required_404_i0 envelope_404_i0 pivot_mem_404_i0 child_required_sub_404_i0 child_envelope_sub_404_i0 ?_ + intro b hb + exact common_sub_404_i0 (mem_commonEnvelope childrenD_404_i0 b hb) +def required_404 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_404 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_404 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), required_404_i0] +def childrenD_404 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), envelope_404_i0] +theorem common_sub_404 : commonEnvelope childrenD_404 ⊆ insert (2, 4) required_404 := by decide +kernel +theorem child_required_sub_404 : ∀ j, childrenC_404 j ⊆ insert (2, 4) required_404 := by decide +kernel +theorem child_envelope_sub_404 : ∀ j, childrenD_404 j ⊆ envelope_404 := by decide +kernel +theorem pivot_mem_404 : (2, 4) ∈ envelope_404 := by decide +kernel +theorem children_work_404 : ∀ j, Template HasSnaky 6 (childrenC_404 j) (childrenD_404 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact row_works_404_i0.mono (by decide +kernel) +theorem row_works_404 : Template HasSnaky 7 required_404 envelope_404 := by + refine compose HasSnaky 6 childrenC_404 childrenD_404 children_work_404 (2, 4) + required_404 envelope_404 pivot_mem_404 child_required_sub_404 child_envelope_sub_404 ?_ + intro b hb + exact common_sub_404 (mem_commonEnvelope childrenD_404 b hb) +def required_415 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_415 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 4), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_415 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_2), (placed21 2 (5, 0) required_414)] +def childrenD_415 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_2), (placed21 2 (5, 0) envelope_414)] +theorem common_sub_415 : commonEnvelope childrenD_415 ⊆ insert (3, 2) required_415 := by decide +kernel +theorem child_required_sub_415 : ∀ j, childrenC_415 j ⊆ insert (3, 2) required_415 := by decide +kernel +theorem child_envelope_sub_415 : ∀ j, childrenD_415 j ⊆ envelope_415 := by decide +kernel +theorem pivot_mem_415 : (3, 2) ∈ envelope_415 := by decide +kernel +theorem children_work_415 : ∀ j, Template HasSnaky 6 (childrenC_415 j) (childrenD_415 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_414 2 (5, 0)).mono (by decide +kernel) +theorem row_works_415 : Template HasSnaky 7 required_415 envelope_415 := by + refine compose HasSnaky 6 childrenC_415 childrenD_415 children_work_415 (3, 2) + required_415 envelope_415 pivot_mem_415 child_required_sub_415 child_envelope_sub_415 ?_ + intro b hb + exact common_sub_415 (mem_commonEnvelope childrenD_415 b hb) +def required_418_i2 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (3, 0), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_418_i2 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_418_i2 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), (placed21 2 (3, 0) required_29)] +def childrenD_418_i2 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), (placed21 2 (3, 0) envelope_29)] +theorem common_sub_418_i2 : commonEnvelope childrenD_418_i2 ⊆ insert (2, 2) required_418_i2 := by decide +kernel +theorem child_required_sub_418_i2 : ∀ j, childrenC_418_i2 j ⊆ insert (2, 2) required_418_i2 := by decide +kernel +theorem child_envelope_sub_418_i2 : ∀ j, childrenD_418_i2 j ⊆ envelope_418_i2 := by decide +kernel +theorem pivot_mem_418_i2 : (2, 2) ∈ envelope_418_i2 := by decide +kernel +theorem children_work_418_i2 : ∀ j, Template HasSnaky 3 (childrenC_418_i2 j) (childrenD_418_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_29 2 (3, 0)).mono (by decide +kernel) +theorem row_works_418_i2 : Template HasSnaky 4 required_418_i2 envelope_418_i2 := by + refine compose HasSnaky 3 childrenC_418_i2 childrenD_418_i2 children_work_418_i2 (2, 2) + required_418_i2 envelope_418_i2 pivot_mem_418_i2 child_required_sub_418_i2 child_envelope_sub_418_i2 ?_ + intro b hb + exact common_sub_418_i2 (mem_commonEnvelope childrenD_418_i2 b hb) +def required_418_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (3, 0), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_418_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_418_i1 : Fin 4 → Finset Cell := ![(placed21 1 (2, 0) required_8), (placed21 5 (4, 0) required_25), (placed21 0 (2, 0) required_41), required_418_i2] +def childrenD_418_i1 : Fin 4 → Finset Cell := ![(placed21 1 (2, 0) envelope_8), (placed21 5 (4, 0) envelope_25), (placed21 0 (2, 0) envelope_41), envelope_418_i2] +theorem common_sub_418_i1 : commonEnvelope childrenD_418_i1 ⊆ insert (3, 3) required_418_i1 := by decide +kernel +theorem child_required_sub_418_i1 : ∀ j, childrenC_418_i1 j ⊆ insert (3, 3) required_418_i1 := by decide +kernel +theorem child_envelope_sub_418_i1 : ∀ j, childrenD_418_i1 j ⊆ envelope_418_i1 := by decide +kernel +theorem pivot_mem_418_i1 : (3, 3) ∈ envelope_418_i1 := by decide +kernel +theorem children_work_418_i1 : ∀ j, Template HasSnaky 4 (childrenC_418_i1 j) (childrenD_418_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_25 5 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_41 0 (2, 0)).mono (by decide +kernel) + · exact row_works_418_i2.mono (by decide +kernel) +theorem row_works_418_i1 : Template HasSnaky 5 required_418_i1 envelope_418_i1 := by + refine compose HasSnaky 4 childrenC_418_i1 childrenD_418_i1 children_work_418_i1 (3, 3) + required_418_i1 envelope_418_i1 pivot_mem_418_i1 child_required_sub_418_i1 child_envelope_sub_418_i1 ?_ + intro b hb + exact common_sub_418_i1 (mem_commonEnvelope childrenD_418_i1 b hb) +def required_418_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (3, 0), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_418_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_418_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), required_418_i1] +def childrenD_418_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), envelope_418_i1] +theorem common_sub_418_i0 : commonEnvelope childrenD_418_i0 ⊆ insert (3, 2) required_418_i0 := by decide +kernel +theorem child_required_sub_418_i0 : ∀ j, childrenC_418_i0 j ⊆ insert (3, 2) required_418_i0 := by decide +kernel +theorem child_envelope_sub_418_i0 : ∀ j, childrenD_418_i0 j ⊆ envelope_418_i0 := by decide +kernel +theorem pivot_mem_418_i0 : (3, 2) ∈ envelope_418_i0 := by decide +kernel +theorem children_work_418_i0 : ∀ j, Template HasSnaky 5 (childrenC_418_i0 j) (childrenD_418_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact row_works_418_i1.mono (by decide +kernel) +theorem row_works_418_i0 : Template HasSnaky 6 required_418_i0 envelope_418_i0 := by + refine compose HasSnaky 5 childrenC_418_i0 childrenD_418_i0 children_work_418_i0 (3, 2) + required_418_i0 envelope_418_i0 pivot_mem_418_i0 child_required_sub_418_i0 child_envelope_sub_418_i0 ?_ + intro b hb + exact common_sub_418_i0 (mem_commonEnvelope childrenD_418_i0 b hb) +def required_418 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_418 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_418 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), required_418_i0] +def childrenD_418 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), envelope_418_i0] +theorem common_sub_418 : commonEnvelope childrenD_418 ⊆ insert (3, 0) required_418 := by decide +kernel +theorem child_required_sub_418 : ∀ j, childrenC_418 j ⊆ insert (3, 0) required_418 := by decide +kernel +theorem child_envelope_sub_418 : ∀ j, childrenD_418 j ⊆ envelope_418 := by decide +kernel +theorem pivot_mem_418 : (3, 0) ∈ envelope_418 := by decide +kernel +theorem children_work_418 : ∀ j, Template HasSnaky 6 (childrenC_418 j) (childrenD_418 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact row_works_418_i0.mono (by decide +kernel) +theorem row_works_418 : Template HasSnaky 7 required_418 envelope_418 := by + refine compose HasSnaky 6 childrenC_418 childrenD_418 children_work_418 (3, 0) + required_418 envelope_418 pivot_mem_418 child_required_sub_418 child_envelope_sub_418 ?_ + intro b hb + exact common_sub_418 (mem_commonEnvelope childrenD_418 b hb) +def required_422_i0 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_422_i0 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_422_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) required_69), (placed21 5 (5, 1) required_413)] +def childrenD_422_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) envelope_69), (placed21 5 (5, 1) envelope_413)] +theorem common_sub_422_i0 : commonEnvelope childrenD_422_i0 ⊆ insert (4, 2) required_422_i0 := by decide +kernel +theorem child_required_sub_422_i0 : ∀ j, childrenC_422_i0 j ⊆ insert (4, 2) required_422_i0 := by decide +kernel +theorem child_envelope_sub_422_i0 : ∀ j, childrenD_422_i0 j ⊆ envelope_422_i0 := by decide +kernel +theorem pivot_mem_422_i0 : (4, 2) ∈ envelope_422_i0 := by decide +kernel +theorem children_work_422_i0 : ∀ j, Template HasSnaky 5 (childrenC_422_i0 j) (childrenD_422_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_69 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_413 5 (5, 1)).mono (by decide +kernel) +theorem row_works_422_i0 : Template HasSnaky 6 required_422_i0 envelope_422_i0 := by + refine compose HasSnaky 5 childrenC_422_i0 childrenD_422_i0 children_work_422_i0 (4, 2) + required_422_i0 envelope_422_i0 pivot_mem_422_i0 child_required_sub_422_i0 child_envelope_sub_422_i0 ?_ + intro b hb + exact common_sub_422_i0 (mem_commonEnvelope childrenD_422_i0 b hb) +def required_422 : Finset Cell := ⟨(([(1, 2), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_422 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_422 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_0), required_422_i0] +def childrenD_422 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_0), envelope_422_i0] +theorem common_sub_422 : commonEnvelope childrenD_422 ⊆ insert (2, 2) required_422 := by decide +kernel +theorem child_required_sub_422 : ∀ j, childrenC_422 j ⊆ insert (2, 2) required_422 := by decide +kernel +theorem child_envelope_sub_422 : ∀ j, childrenD_422 j ⊆ envelope_422 := by decide +kernel +theorem pivot_mem_422 : (2, 2) ∈ envelope_422 := by decide +kernel +theorem children_work_422 : ∀ j, Template HasSnaky 6 (childrenC_422 j) (childrenD_422 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 0 (0, 2)).mono (by decide +kernel) + · exact row_works_422_i0.mono (by decide +kernel) +theorem row_works_422 : Template HasSnaky 7 required_422 envelope_422 := by + refine compose HasSnaky 6 childrenC_422 childrenD_422 children_work_422 (2, 2) + required_422 envelope_422 pivot_mem_422 child_required_sub_422 child_envelope_sub_422 ?_ + intro b hb + exact common_sub_422 (mem_commonEnvelope childrenD_422 b hb) +def required_430 : Finset Cell := ⟨(([(0, 4), (1, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_430 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_430 : Fin 5 → Finset Cell := ![(placed21 4 (2, 7) required_14), (placed21 4 (2, 7) required_31), (placed21 0 (0, 2) required_58), (placed21 4 (0, 6) required_100), (placed21 0 (0, 2) required_429)] +def childrenD_430 : Fin 5 → Finset Cell := ![(placed21 4 (2, 7) envelope_14), (placed21 4 (2, 7) envelope_31), (placed21 0 (0, 2) envelope_58), (placed21 4 (0, 6) envelope_100), (placed21 0 (0, 2) envelope_429)] +theorem common_sub_430 : commonEnvelope childrenD_430 ⊆ insert (3, 5) required_430 := by decide +kernel +theorem child_required_sub_430 : ∀ j, childrenC_430 j ⊆ insert (3, 5) required_430 := by decide +kernel +theorem child_envelope_sub_430 : ∀ j, childrenD_430 j ⊆ envelope_430 := by decide +kernel +theorem pivot_mem_430 : (3, 5) ∈ envelope_430 := by decide +kernel +theorem children_work_430 : ∀ j, Template HasSnaky 6 (childrenC_430 j) (childrenD_430 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_31 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_58 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_100 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_429 0 (0, 2)).mono (by decide +kernel) +theorem row_works_430 : Template HasSnaky 7 required_430 envelope_430 := by + refine compose HasSnaky 6 childrenC_430 childrenD_430 children_work_430 (3, 5) + required_430 envelope_430 pivot_mem_430 child_required_sub_430 child_envelope_sub_430 ?_ + intro b hb + exact common_sub_430 (mem_commonEnvelope childrenD_430 b hb) +def required_431 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_431 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_431 : Fin 3 → Finset Cell := ![(placed21 7 (5, 4) required_160), (placed21 2 (5, 0) required_243), (placed21 0 (1, 1) required_429)] +def childrenD_431 : Fin 3 → Finset Cell := ![(placed21 7 (5, 4) envelope_160), (placed21 2 (5, 0) envelope_243), (placed21 0 (1, 1) envelope_429)] +theorem common_sub_431 : commonEnvelope childrenD_431 ⊆ insert (4, 4) required_431 := by decide +kernel +theorem child_required_sub_431 : ∀ j, childrenC_431 j ⊆ insert (4, 4) required_431 := by decide +kernel +theorem child_envelope_sub_431 : ∀ j, childrenD_431 j ⊆ envelope_431 := by decide +kernel +theorem pivot_mem_431 : (4, 4) ∈ envelope_431 := by decide +kernel +theorem children_work_431 : ∀ j, Template HasSnaky 6 (childrenC_431 j) (childrenD_431 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_160 7 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_243 2 (5, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_429 0 (1, 1)).mono (by decide +kernel) +theorem row_works_431 : Template HasSnaky 7 required_431 envelope_431 := by + refine compose HasSnaky 6 childrenC_431 childrenD_431 children_work_431 (4, 4) + required_431 envelope_431 pivot_mem_431 child_required_sub_431 child_envelope_sub_431 ?_ + intro b hb + exact common_sub_431 (mem_commonEnvelope childrenD_431 b hb) +def required_436 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_436 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 4), (5, 6), (6, 2), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_436 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) required_10), (placed21 3 (1, 6) required_47), (placed21 6 (3, 6) required_52), (placed21 5 (6, 2) required_435)] +def childrenD_436 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) envelope_10), (placed21 3 (1, 6) envelope_47), (placed21 6 (3, 6) envelope_52), (placed21 5 (6, 2) envelope_435)] +theorem common_sub_436 : commonEnvelope childrenD_436 ⊆ insert (3, 5) required_436 := by decide +kernel +theorem child_required_sub_436 : ∀ j, childrenC_436 j ⊆ insert (3, 5) required_436 := by decide +kernel +theorem child_envelope_sub_436 : ∀ j, childrenD_436 j ⊆ envelope_436 := by decide +kernel +theorem pivot_mem_436 : (3, 5) ∈ envelope_436 := by decide +kernel +theorem children_work_436 : ∀ j, Template HasSnaky 6 (childrenC_436 j) (childrenD_436 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_47 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (6, 2)).mono (by decide +kernel) +theorem row_works_436 : Template HasSnaky 7 required_436 envelope_436 := by + refine compose HasSnaky 6 childrenC_436 childrenD_436 children_work_436 (3, 5) + required_436 envelope_436 pivot_mem_436 child_required_sub_436 child_envelope_sub_436 ?_ + intro b hb + exact common_sub_436 (mem_commonEnvelope childrenD_436 b hb) +def required_437 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_437 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 4), (5, 6), (6, 2), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_437 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) required_10), (placed21 3 (1, 6) required_47), (placed21 6 (3, 6) required_52), (placed21 5 (6, 2) required_435)] +def childrenD_437 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) envelope_10), (placed21 3 (1, 6) envelope_47), (placed21 6 (3, 6) envelope_52), (placed21 5 (6, 2) envelope_435)] +theorem common_sub_437 : commonEnvelope childrenD_437 ⊆ insert (3, 4) required_437 := by decide +kernel +theorem child_required_sub_437 : ∀ j, childrenC_437 j ⊆ insert (3, 4) required_437 := by decide +kernel +theorem child_envelope_sub_437 : ∀ j, childrenD_437 j ⊆ envelope_437 := by decide +kernel +theorem pivot_mem_437 : (3, 4) ∈ envelope_437 := by decide +kernel +theorem children_work_437 : ∀ j, Template HasSnaky 6 (childrenC_437 j) (childrenD_437 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_47 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (6, 2)).mono (by decide +kernel) +theorem row_works_437 : Template HasSnaky 7 required_437 envelope_437 := by + refine compose HasSnaky 6 childrenC_437 childrenD_437 children_work_437 (3, 4) + required_437 envelope_437 pivot_mem_437 child_required_sub_437 child_envelope_sub_437 ?_ + intro b hb + exact common_sub_437 (mem_commonEnvelope childrenD_437 b hb) +def required_446_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_446_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_446_i0 : Fin 2 → Finset Cell := ![(placed21 3 (1, 7) required_0), (placed21 4 (0, 5) required_72)] +def childrenD_446_i0 : Fin 2 → Finset Cell := ![(placed21 3 (1, 7) envelope_0), (placed21 4 (0, 5) envelope_72)] +theorem common_sub_446_i0 : commonEnvelope childrenD_446_i0 ⊆ insert (2, 4) required_446_i0 := by decide +kernel +theorem child_required_sub_446_i0 : ∀ j, childrenC_446_i0 j ⊆ insert (2, 4) required_446_i0 := by decide +kernel +theorem child_envelope_sub_446_i0 : ∀ j, childrenD_446_i0 j ⊆ envelope_446_i0 := by decide +kernel +theorem pivot_mem_446_i0 : (2, 4) ∈ envelope_446_i0 := by decide +kernel +theorem children_work_446_i0 : ∀ j, Template HasSnaky 5 (childrenC_446_i0 j) (childrenD_446_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_72 4 (0, 5)).mono (by decide +kernel) +theorem row_works_446_i0 : Template HasSnaky 6 required_446_i0 envelope_446_i0 := by + refine compose HasSnaky 5 childrenC_446_i0 childrenD_446_i0 children_work_446_i0 (2, 4) + required_446_i0 envelope_446_i0 pivot_mem_446_i0 child_required_sub_446_i0 child_envelope_sub_446_i0 ?_ + intro b hb + exact common_sub_446_i0 (mem_commonEnvelope childrenD_446_i0 b hb) +def required_446 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_446 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_446 : Fin 2 → Finset Cell := ![(placed21 3 (1, 6) required_5), required_446_i0] +def childrenD_446 : Fin 2 → Finset Cell := ![(placed21 3 (1, 6) envelope_5), envelope_446_i0] +theorem common_sub_446 : commonEnvelope childrenD_446 ⊆ insert (2, 3) required_446 := by decide +kernel +theorem child_required_sub_446 : ∀ j, childrenC_446 j ⊆ insert (2, 3) required_446 := by decide +kernel +theorem child_envelope_sub_446 : ∀ j, childrenD_446 j ⊆ envelope_446 := by decide +kernel +theorem pivot_mem_446 : (2, 3) ∈ envelope_446 := by decide +kernel +theorem children_work_446 : ∀ j, Template HasSnaky 6 (childrenC_446 j) (childrenD_446 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 6)).mono (by decide +kernel) + · exact row_works_446_i0.mono (by decide +kernel) +theorem row_works_446 : Template HasSnaky 7 required_446 envelope_446 := by + refine compose HasSnaky 6 childrenC_446 childrenD_446 children_work_446 (2, 3) + required_446 envelope_446 pivot_mem_446 child_required_sub_446 child_envelope_sub_446 ?_ + intro b hb + exact common_sub_446 (mem_commonEnvelope childrenD_446 b hb) +def height_361 : ℕ := 7 +def childrenH_361 : Fin 3 → ℕ := ![height_15, height_57, height_360] +theorem height_exact_361 : height_361 = 1 + Finset.univ.sup childrenH_361 := by decide +kernel +theorem required_origin_361 : ∀ x ∈ required_361, + (∃ j, x ∈ childrenC_361 j) ∨ ∀ j, x ∈ childrenD_361 j := by decide +kernel +theorem required_exact_361 : required_361 = + ((Finset.univ.biUnion childrenC_361) ∪ commonEnvelope childrenD_361).erase (3, 1) := by + exact required_eq_combination childrenC_361 childrenD_361 (3, 1) required_361 + (by decide +kernel) child_required_sub_361 common_sub_361 required_origin_361 +theorem envelope_origin_361 : ∀ x ∈ envelope_361, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_361 j := by decide +kernel +theorem envelope_exact_361 : envelope_361 = + insert (3, 1) (Finset.univ.biUnion childrenD_361) := by + exact envelope_eq_combination childrenD_361 (3, 1) envelope_361 + pivot_mem_361 child_envelope_sub_361 envelope_origin_361 +def checked_361 : CheckedCard where + required := required_361 + envelope := envelope_361 + height := height_361 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_361 +def height_372_i0 : ℕ := 6 +def childrenH_372_i0 : Fin 2 → ℕ := ![height_81, height_351] +theorem height_exact_372_i0 : height_372_i0 = 1 + Finset.univ.sup childrenH_372_i0 := by decide +kernel +theorem required_origin_372_i0 : ∀ x ∈ required_372_i0, + (∃ j, x ∈ childrenC_372_i0 j) ∨ ∀ j, x ∈ childrenD_372_i0 j := by decide +kernel +theorem required_exact_372_i0 : required_372_i0 = + ((Finset.univ.biUnion childrenC_372_i0) ∪ commonEnvelope childrenD_372_i0).erase (4, 4) := by + exact required_eq_combination childrenC_372_i0 childrenD_372_i0 (4, 4) required_372_i0 + (by decide +kernel) child_required_sub_372_i0 common_sub_372_i0 required_origin_372_i0 +theorem envelope_origin_372_i0 : ∀ x ∈ envelope_372_i0, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_372_i0 j := by decide +kernel +theorem envelope_exact_372_i0 : envelope_372_i0 = + insert (4, 4) (Finset.univ.biUnion childrenD_372_i0) := by + exact envelope_eq_combination childrenD_372_i0 (4, 4) envelope_372_i0 + pivot_mem_372_i0 child_envelope_sub_372_i0 envelope_origin_372_i0 +def checked_372_i0 : CheckedCard where + required := required_372_i0 + envelope := envelope_372_i0 + height := height_372_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_372_i0 +def height_372 : ℕ := 7 +def childrenH_372 : Fin 2 → ℕ := ![height_96, height_372_i0] +theorem height_exact_372 : height_372 = 1 + Finset.univ.sup childrenH_372 := by decide +kernel +theorem required_origin_372 : ∀ x ∈ required_372, + (∃ j, x ∈ childrenC_372 j) ∨ ∀ j, x ∈ childrenD_372 j := by decide +kernel +theorem required_exact_372 : required_372 = + ((Finset.univ.biUnion childrenC_372) ∪ commonEnvelope childrenD_372).erase (4, 2) := by + exact required_eq_combination childrenC_372 childrenD_372 (4, 2) required_372 + (by decide +kernel) child_required_sub_372 common_sub_372 required_origin_372 +theorem envelope_origin_372 : ∀ x ∈ envelope_372, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_372 j := by decide +kernel +theorem envelope_exact_372 : envelope_372 = + insert (4, 2) (Finset.univ.biUnion childrenD_372) := by + exact envelope_eq_combination childrenD_372 (4, 2) envelope_372 + pivot_mem_372 child_envelope_sub_372 envelope_origin_372 +def checked_372 : CheckedCard where + required := required_372 + envelope := envelope_372 + height := height_372 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_372 +def height_379 : ℕ := 7 +def childrenH_379 : Fin 3 → ℕ := ![height_21, height_37, height_378] +theorem height_exact_379 : height_379 = 1 + Finset.univ.sup childrenH_379 := by decide +kernel +theorem required_origin_379 : ∀ x ∈ required_379, + (∃ j, x ∈ childrenC_379 j) ∨ ∀ j, x ∈ childrenD_379 j := by decide +kernel +theorem required_exact_379 : required_379 = + ((Finset.univ.biUnion childrenC_379) ∪ commonEnvelope childrenD_379).erase (3, 2) := by + exact required_eq_combination childrenC_379 childrenD_379 (3, 2) required_379 + (by decide +kernel) child_required_sub_379 common_sub_379 required_origin_379 +theorem envelope_origin_379 : ∀ x ∈ envelope_379, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_379 j := by decide +kernel +theorem envelope_exact_379 : envelope_379 = + insert (3, 2) (Finset.univ.biUnion childrenD_379) := by + exact envelope_eq_combination childrenD_379 (3, 2) envelope_379 + pivot_mem_379 child_envelope_sub_379 envelope_origin_379 +def checked_379 : CheckedCard where + required := required_379 + envelope := envelope_379 + height := height_379 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_379 +def height_385 : ℕ := 7 +def childrenH_385 : Fin 2 → ℕ := ![height_115, height_383] +theorem height_exact_385 : height_385 = 1 + Finset.univ.sup childrenH_385 := by decide +kernel +theorem required_origin_385 : ∀ x ∈ required_385, + (∃ j, x ∈ childrenC_385 j) ∨ ∀ j, x ∈ childrenD_385 j := by decide +kernel +theorem required_exact_385 : required_385 = + ((Finset.univ.biUnion childrenC_385) ∪ commonEnvelope childrenD_385).erase (3, 3) := by + exact required_eq_combination childrenC_385 childrenD_385 (3, 3) required_385 + (by decide +kernel) child_required_sub_385 common_sub_385 required_origin_385 +theorem envelope_origin_385 : ∀ x ∈ envelope_385, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_385 j := by decide +kernel +theorem envelope_exact_385 : envelope_385 = + insert (3, 3) (Finset.univ.biUnion childrenD_385) := by + exact envelope_eq_combination childrenD_385 (3, 3) envelope_385 + pivot_mem_385 child_envelope_sub_385 envelope_origin_385 +def checked_385 : CheckedCard where + required := required_385 + envelope := envelope_385 + height := height_385 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_385 +def height_388 : ℕ := 7 +def childrenH_388 : Fin 2 → ℕ := ![height_11, height_387] +theorem height_exact_388 : height_388 = 1 + Finset.univ.sup childrenH_388 := by decide +kernel +theorem required_origin_388 : ∀ x ∈ required_388, + (∃ j, x ∈ childrenC_388 j) ∨ ∀ j, x ∈ childrenD_388 j := by decide +kernel +theorem required_exact_388 : required_388 = + ((Finset.univ.biUnion childrenC_388) ∪ commonEnvelope childrenD_388).erase (2, 4) := by + exact required_eq_combination childrenC_388 childrenD_388 (2, 4) required_388 + (by decide +kernel) child_required_sub_388 common_sub_388 required_origin_388 +theorem envelope_origin_388 : ∀ x ∈ envelope_388, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_388 j := by decide +kernel +theorem envelope_exact_388 : envelope_388 = + insert (2, 4) (Finset.univ.biUnion childrenD_388) := by + exact envelope_eq_combination childrenD_388 (2, 4) envelope_388 + pivot_mem_388 child_envelope_sub_388 envelope_origin_388 +def checked_388 : CheckedCard where + required := required_388 + envelope := envelope_388 + height := height_388 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_388 +def height_394 : ℕ := 7 +def childrenH_394 : Fin 3 → ℕ := ![height_17, height_241, height_392] +theorem height_exact_394 : height_394 = 1 + Finset.univ.sup childrenH_394 := by decide +kernel +theorem required_origin_394 : ∀ x ∈ required_394, + (∃ j, x ∈ childrenC_394 j) ∨ ∀ j, x ∈ childrenD_394 j := by decide +kernel +theorem required_exact_394 : required_394 = + ((Finset.univ.biUnion childrenC_394) ∪ commonEnvelope childrenD_394).erase (1, 4) := by + exact required_eq_combination childrenC_394 childrenD_394 (1, 4) required_394 + (by decide +kernel) child_required_sub_394 common_sub_394 required_origin_394 +theorem envelope_origin_394 : ∀ x ∈ envelope_394, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_394 j := by decide +kernel +theorem envelope_exact_394 : envelope_394 = + insert (1, 4) (Finset.univ.biUnion childrenD_394) := by + exact envelope_eq_combination childrenD_394 (1, 4) envelope_394 + pivot_mem_394 child_envelope_sub_394 envelope_origin_394 +def checked_394 : CheckedCard where + required := required_394 + envelope := envelope_394 + height := height_394 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_394 +def height_404_i1 : ℕ := 5 +def childrenH_404_i1 : Fin 2 → ℕ := ![height_0, height_354] +theorem height_exact_404_i1 : height_404_i1 = 1 + Finset.univ.sup childrenH_404_i1 := by decide +kernel +theorem required_origin_404_i1 : ∀ x ∈ required_404_i1, + (∃ j, x ∈ childrenC_404_i1 j) ∨ ∀ j, x ∈ childrenD_404_i1 j := by decide +kernel +theorem required_exact_404_i1 : required_404_i1 = + ((Finset.univ.biUnion childrenC_404_i1) ∪ commonEnvelope childrenD_404_i1).erase (3, 1) := by + exact required_eq_combination childrenC_404_i1 childrenD_404_i1 (3, 1) required_404_i1 + (by decide +kernel) child_required_sub_404_i1 common_sub_404_i1 required_origin_404_i1 +theorem envelope_origin_404_i1 : ∀ x ∈ envelope_404_i1, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_404_i1 j := by decide +kernel +theorem envelope_exact_404_i1 : envelope_404_i1 = + insert (3, 1) (Finset.univ.biUnion childrenD_404_i1) := by + exact envelope_eq_combination childrenD_404_i1 (3, 1) envelope_404_i1 + pivot_mem_404_i1 child_envelope_sub_404_i1 envelope_origin_404_i1 +def checked_404_i1 : CheckedCard where + required := required_404_i1 + envelope := envelope_404_i1 + height := height_404_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_404_i1 +def height_404_i0 : ℕ := 6 +def childrenH_404_i0 : Fin 2 → ℕ := ![height_5, height_404_i1] +theorem height_exact_404_i0 : height_404_i0 = 1 + Finset.univ.sup childrenH_404_i0 := by decide +kernel +theorem required_origin_404_i0 : ∀ x ∈ required_404_i0, + (∃ j, x ∈ childrenC_404_i0 j) ∨ ∀ j, x ∈ childrenD_404_i0 j := by decide +kernel +theorem required_exact_404_i0 : required_404_i0 = + ((Finset.univ.biUnion childrenC_404_i0) ∪ commonEnvelope childrenD_404_i0).erase (2, 1) := by + exact required_eq_combination childrenC_404_i0 childrenD_404_i0 (2, 1) required_404_i0 + (by decide +kernel) child_required_sub_404_i0 common_sub_404_i0 required_origin_404_i0 +theorem envelope_origin_404_i0 : ∀ x ∈ envelope_404_i0, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_404_i0 j := by decide +kernel +theorem envelope_exact_404_i0 : envelope_404_i0 = + insert (2, 1) (Finset.univ.biUnion childrenD_404_i0) := by + exact envelope_eq_combination childrenD_404_i0 (2, 1) envelope_404_i0 + pivot_mem_404_i0 child_envelope_sub_404_i0 envelope_origin_404_i0 +def checked_404_i0 : CheckedCard where + required := required_404_i0 + envelope := envelope_404_i0 + height := height_404_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_404_i0 +def height_404 : ℕ := 7 +def childrenH_404 : Fin 2 → ℕ := ![height_5, height_404_i0] +theorem height_exact_404 : height_404 = 1 + Finset.univ.sup childrenH_404 := by decide +kernel +theorem required_origin_404 : ∀ x ∈ required_404, + (∃ j, x ∈ childrenC_404 j) ∨ ∀ j, x ∈ childrenD_404 j := by decide +kernel +theorem required_exact_404 : required_404 = + ((Finset.univ.biUnion childrenC_404) ∪ commonEnvelope childrenD_404).erase (2, 4) := by + exact required_eq_combination childrenC_404 childrenD_404 (2, 4) required_404 + (by decide +kernel) child_required_sub_404 common_sub_404 required_origin_404 +theorem envelope_origin_404 : ∀ x ∈ envelope_404, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_404 j := by decide +kernel +theorem envelope_exact_404 : envelope_404 = + insert (2, 4) (Finset.univ.biUnion childrenD_404) := by + exact envelope_eq_combination childrenD_404 (2, 4) envelope_404 + pivot_mem_404 child_envelope_sub_404 envelope_origin_404 +def checked_404 : CheckedCard where + required := required_404 + envelope := envelope_404 + height := height_404 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_404 +def height_415 : ℕ := 7 +def childrenH_415 : Fin 2 → ℕ := ![height_2, height_414] +theorem height_exact_415 : height_415 = 1 + Finset.univ.sup childrenH_415 := by decide +kernel +theorem required_origin_415 : ∀ x ∈ required_415, + (∃ j, x ∈ childrenC_415 j) ∨ ∀ j, x ∈ childrenD_415 j := by decide +kernel +theorem required_exact_415 : required_415 = + ((Finset.univ.biUnion childrenC_415) ∪ commonEnvelope childrenD_415).erase (3, 2) := by + exact required_eq_combination childrenC_415 childrenD_415 (3, 2) required_415 + (by decide +kernel) child_required_sub_415 common_sub_415 required_origin_415 +theorem envelope_origin_415 : ∀ x ∈ envelope_415, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_415 j := by decide +kernel +theorem envelope_exact_415 : envelope_415 = + insert (3, 2) (Finset.univ.biUnion childrenD_415) := by + exact envelope_eq_combination childrenD_415 (3, 2) envelope_415 + pivot_mem_415 child_envelope_sub_415 envelope_origin_415 +def checked_415 : CheckedCard where + required := required_415 + envelope := envelope_415 + height := height_415 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_415 +def height_418_i2 : ℕ := 4 +def childrenH_418_i2 : Fin 2 → ℕ := ![height_5, height_29] +theorem height_exact_418_i2 : height_418_i2 = 1 + Finset.univ.sup childrenH_418_i2 := by decide +kernel +theorem required_origin_418_i2 : ∀ x ∈ required_418_i2, + (∃ j, x ∈ childrenC_418_i2 j) ∨ ∀ j, x ∈ childrenD_418_i2 j := by decide +kernel +theorem required_exact_418_i2 : required_418_i2 = + ((Finset.univ.biUnion childrenC_418_i2) ∪ commonEnvelope childrenD_418_i2).erase (2, 2) := by + exact required_eq_combination childrenC_418_i2 childrenD_418_i2 (2, 2) required_418_i2 + (by decide +kernel) child_required_sub_418_i2 common_sub_418_i2 required_origin_418_i2 +theorem envelope_origin_418_i2 : ∀ x ∈ envelope_418_i2, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_418_i2 j := by decide +kernel +theorem envelope_exact_418_i2 : envelope_418_i2 = + insert (2, 2) (Finset.univ.biUnion childrenD_418_i2) := by + exact envelope_eq_combination childrenD_418_i2 (2, 2) envelope_418_i2 + pivot_mem_418_i2 child_envelope_sub_418_i2 envelope_origin_418_i2 +def checked_418_i2 : CheckedCard where + required := required_418_i2 + envelope := envelope_418_i2 + height := height_418_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_418_i2 +def height_418_i1 : ℕ := 5 +def childrenH_418_i1 : Fin 4 → ℕ := ![height_8, height_25, height_41, height_418_i2] +theorem height_exact_418_i1 : height_418_i1 = 1 + Finset.univ.sup childrenH_418_i1 := by decide +kernel +theorem required_origin_418_i1 : ∀ x ∈ required_418_i1, + (∃ j, x ∈ childrenC_418_i1 j) ∨ ∀ j, x ∈ childrenD_418_i1 j := by decide +kernel +theorem required_exact_418_i1 : required_418_i1 = + ((Finset.univ.biUnion childrenC_418_i1) ∪ commonEnvelope childrenD_418_i1).erase (3, 3) := by + exact required_eq_combination childrenC_418_i1 childrenD_418_i1 (3, 3) required_418_i1 + (by decide +kernel) child_required_sub_418_i1 common_sub_418_i1 required_origin_418_i1 +theorem envelope_origin_418_i1 : ∀ x ∈ envelope_418_i1, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_418_i1 j := by decide +kernel +theorem envelope_exact_418_i1 : envelope_418_i1 = + insert (3, 3) (Finset.univ.biUnion childrenD_418_i1) := by + exact envelope_eq_combination childrenD_418_i1 (3, 3) envelope_418_i1 + pivot_mem_418_i1 child_envelope_sub_418_i1 envelope_origin_418_i1 +def checked_418_i1 : CheckedCard where + required := required_418_i1 + envelope := envelope_418_i1 + height := height_418_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_418_i1 +def height_418_i0 : ℕ := 6 +def childrenH_418_i0 : Fin 2 → ℕ := ![height_5, height_418_i1] +theorem height_exact_418_i0 : height_418_i0 = 1 + Finset.univ.sup childrenH_418_i0 := by decide +kernel +theorem required_origin_418_i0 : ∀ x ∈ required_418_i0, + (∃ j, x ∈ childrenC_418_i0 j) ∨ ∀ j, x ∈ childrenD_418_i0 j := by decide +kernel +theorem required_exact_418_i0 : required_418_i0 = + ((Finset.univ.biUnion childrenC_418_i0) ∪ commonEnvelope childrenD_418_i0).erase (3, 2) := by + exact required_eq_combination childrenC_418_i0 childrenD_418_i0 (3, 2) required_418_i0 + (by decide +kernel) child_required_sub_418_i0 common_sub_418_i0 required_origin_418_i0 +theorem envelope_origin_418_i0 : ∀ x ∈ envelope_418_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_418_i0 j := by decide +kernel +theorem envelope_exact_418_i0 : envelope_418_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_418_i0) := by + exact envelope_eq_combination childrenD_418_i0 (3, 2) envelope_418_i0 + pivot_mem_418_i0 child_envelope_sub_418_i0 envelope_origin_418_i0 +def checked_418_i0 : CheckedCard where + required := required_418_i0 + envelope := envelope_418_i0 + height := height_418_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_418_i0 +def height_418 : ℕ := 7 +def childrenH_418 : Fin 2 → ℕ := ![height_5, height_418_i0] +theorem height_exact_418 : height_418 = 1 + Finset.univ.sup childrenH_418 := by decide +kernel +theorem required_origin_418 : ∀ x ∈ required_418, + (∃ j, x ∈ childrenC_418 j) ∨ ∀ j, x ∈ childrenD_418 j := by decide +kernel +theorem required_exact_418 : required_418 = + ((Finset.univ.biUnion childrenC_418) ∪ commonEnvelope childrenD_418).erase (3, 0) := by + exact required_eq_combination childrenC_418 childrenD_418 (3, 0) required_418 + (by decide +kernel) child_required_sub_418 common_sub_418 required_origin_418 +theorem envelope_origin_418 : ∀ x ∈ envelope_418, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_418 j := by decide +kernel +theorem envelope_exact_418 : envelope_418 = + insert (3, 0) (Finset.univ.biUnion childrenD_418) := by + exact envelope_eq_combination childrenD_418 (3, 0) envelope_418 + pivot_mem_418 child_envelope_sub_418 envelope_origin_418 +def checked_418 : CheckedCard where + required := required_418 + envelope := envelope_418 + height := height_418 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_418 +def height_422_i0 : ℕ := 6 +def childrenH_422_i0 : Fin 2 → ℕ := ![height_69, height_413] +theorem height_exact_422_i0 : height_422_i0 = 1 + Finset.univ.sup childrenH_422_i0 := by decide +kernel +theorem required_origin_422_i0 : ∀ x ∈ required_422_i0, + (∃ j, x ∈ childrenC_422_i0 j) ∨ ∀ j, x ∈ childrenD_422_i0 j := by decide +kernel +theorem required_exact_422_i0 : required_422_i0 = + ((Finset.univ.biUnion childrenC_422_i0) ∪ commonEnvelope childrenD_422_i0).erase (4, 2) := by + exact required_eq_combination childrenC_422_i0 childrenD_422_i0 (4, 2) required_422_i0 + (by decide +kernel) child_required_sub_422_i0 common_sub_422_i0 required_origin_422_i0 +theorem envelope_origin_422_i0 : ∀ x ∈ envelope_422_i0, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_422_i0 j := by decide +kernel +theorem envelope_exact_422_i0 : envelope_422_i0 = + insert (4, 2) (Finset.univ.biUnion childrenD_422_i0) := by + exact envelope_eq_combination childrenD_422_i0 (4, 2) envelope_422_i0 + pivot_mem_422_i0 child_envelope_sub_422_i0 envelope_origin_422_i0 +def checked_422_i0 : CheckedCard where + required := required_422_i0 + envelope := envelope_422_i0 + height := height_422_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_422_i0 +def height_422 : ℕ := 7 +def childrenH_422 : Fin 2 → ℕ := ![height_0, height_422_i0] +theorem height_exact_422 : height_422 = 1 + Finset.univ.sup childrenH_422 := by decide +kernel +theorem required_origin_422 : ∀ x ∈ required_422, + (∃ j, x ∈ childrenC_422 j) ∨ ∀ j, x ∈ childrenD_422 j := by decide +kernel +theorem required_exact_422 : required_422 = + ((Finset.univ.biUnion childrenC_422) ∪ commonEnvelope childrenD_422).erase (2, 2) := by + exact required_eq_combination childrenC_422 childrenD_422 (2, 2) required_422 + (by decide +kernel) child_required_sub_422 common_sub_422 required_origin_422 +theorem envelope_origin_422 : ∀ x ∈ envelope_422, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_422 j := by decide +kernel +theorem envelope_exact_422 : envelope_422 = + insert (2, 2) (Finset.univ.biUnion childrenD_422) := by + exact envelope_eq_combination childrenD_422 (2, 2) envelope_422 + pivot_mem_422 child_envelope_sub_422 envelope_origin_422 +def checked_422 : CheckedCard where + required := required_422 + envelope := envelope_422 + height := height_422 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_422 +def height_430 : ℕ := 7 +def childrenH_430 : Fin 5 → ℕ := ![height_14, height_31, height_58, height_100, height_429] +theorem height_exact_430 : height_430 = 1 + Finset.univ.sup childrenH_430 := by decide +kernel +theorem required_origin_430 : ∀ x ∈ required_430, + (∃ j, x ∈ childrenC_430 j) ∨ ∀ j, x ∈ childrenD_430 j := by decide +kernel +theorem required_exact_430 : required_430 = + ((Finset.univ.biUnion childrenC_430) ∪ commonEnvelope childrenD_430).erase (3, 5) := by + exact required_eq_combination childrenC_430 childrenD_430 (3, 5) required_430 + (by decide +kernel) child_required_sub_430 common_sub_430 required_origin_430 +theorem envelope_origin_430 : ∀ x ∈ envelope_430, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_430 j := by decide +kernel +theorem envelope_exact_430 : envelope_430 = + insert (3, 5) (Finset.univ.biUnion childrenD_430) := by + exact envelope_eq_combination childrenD_430 (3, 5) envelope_430 + pivot_mem_430 child_envelope_sub_430 envelope_origin_430 +def checked_430 : CheckedCard where + required := required_430 + envelope := envelope_430 + height := height_430 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_430 +def height_431 : ℕ := 7 +def childrenH_431 : Fin 3 → ℕ := ![height_160, height_243, height_429] +theorem height_exact_431 : height_431 = 1 + Finset.univ.sup childrenH_431 := by decide +kernel +theorem required_origin_431 : ∀ x ∈ required_431, + (∃ j, x ∈ childrenC_431 j) ∨ ∀ j, x ∈ childrenD_431 j := by decide +kernel +theorem required_exact_431 : required_431 = + ((Finset.univ.biUnion childrenC_431) ∪ commonEnvelope childrenD_431).erase (4, 4) := by + exact required_eq_combination childrenC_431 childrenD_431 (4, 4) required_431 + (by decide +kernel) child_required_sub_431 common_sub_431 required_origin_431 +theorem envelope_origin_431 : ∀ x ∈ envelope_431, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_431 j := by decide +kernel +theorem envelope_exact_431 : envelope_431 = + insert (4, 4) (Finset.univ.biUnion childrenD_431) := by + exact envelope_eq_combination childrenD_431 (4, 4) envelope_431 + pivot_mem_431 child_envelope_sub_431 envelope_origin_431 +def checked_431 : CheckedCard where + required := required_431 + envelope := envelope_431 + height := height_431 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_431 +def height_436 : ℕ := 7 +def childrenH_436 : Fin 4 → ℕ := ![height_10, height_47, height_52, height_435] +theorem height_exact_436 : height_436 = 1 + Finset.univ.sup childrenH_436 := by decide +kernel +theorem required_origin_436 : ∀ x ∈ required_436, + (∃ j, x ∈ childrenC_436 j) ∨ ∀ j, x ∈ childrenD_436 j := by decide +kernel +theorem required_exact_436 : required_436 = + ((Finset.univ.biUnion childrenC_436) ∪ commonEnvelope childrenD_436).erase (3, 5) := by + exact required_eq_combination childrenC_436 childrenD_436 (3, 5) required_436 + (by decide +kernel) child_required_sub_436 common_sub_436 required_origin_436 +theorem envelope_origin_436 : ∀ x ∈ envelope_436, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_436 j := by decide +kernel +theorem envelope_exact_436 : envelope_436 = + insert (3, 5) (Finset.univ.biUnion childrenD_436) := by + exact envelope_eq_combination childrenD_436 (3, 5) envelope_436 + pivot_mem_436 child_envelope_sub_436 envelope_origin_436 +def checked_436 : CheckedCard where + required := required_436 + envelope := envelope_436 + height := height_436 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_436 +def height_437 : ℕ := 7 +def childrenH_437 : Fin 4 → ℕ := ![height_10, height_47, height_52, height_435] +theorem height_exact_437 : height_437 = 1 + Finset.univ.sup childrenH_437 := by decide +kernel +theorem required_origin_437 : ∀ x ∈ required_437, + (∃ j, x ∈ childrenC_437 j) ∨ ∀ j, x ∈ childrenD_437 j := by decide +kernel +theorem required_exact_437 : required_437 = + ((Finset.univ.biUnion childrenC_437) ∪ commonEnvelope childrenD_437).erase (3, 4) := by + exact required_eq_combination childrenC_437 childrenD_437 (3, 4) required_437 + (by decide +kernel) child_required_sub_437 common_sub_437 required_origin_437 +theorem envelope_origin_437 : ∀ x ∈ envelope_437, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_437 j := by decide +kernel +theorem envelope_exact_437 : envelope_437 = + insert (3, 4) (Finset.univ.biUnion childrenD_437) := by + exact envelope_eq_combination childrenD_437 (3, 4) envelope_437 + pivot_mem_437 child_envelope_sub_437 envelope_origin_437 +def checked_437 : CheckedCard where + required := required_437 + envelope := envelope_437 + height := height_437 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_437 +def height_446_i0 : ℕ := 6 +def childrenH_446_i0 : Fin 2 → ℕ := ![height_0, height_72] +theorem height_exact_446_i0 : height_446_i0 = 1 + Finset.univ.sup childrenH_446_i0 := by decide +kernel +theorem required_origin_446_i0 : ∀ x ∈ required_446_i0, + (∃ j, x ∈ childrenC_446_i0 j) ∨ ∀ j, x ∈ childrenD_446_i0 j := by decide +kernel +theorem required_exact_446_i0 : required_446_i0 = + ((Finset.univ.biUnion childrenC_446_i0) ∪ commonEnvelope childrenD_446_i0).erase (2, 4) := by + exact required_eq_combination childrenC_446_i0 childrenD_446_i0 (2, 4) required_446_i0 + (by decide +kernel) child_required_sub_446_i0 common_sub_446_i0 required_origin_446_i0 +theorem envelope_origin_446_i0 : ∀ x ∈ envelope_446_i0, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_446_i0 j := by decide +kernel +theorem envelope_exact_446_i0 : envelope_446_i0 = + insert (2, 4) (Finset.univ.biUnion childrenD_446_i0) := by + exact envelope_eq_combination childrenD_446_i0 (2, 4) envelope_446_i0 + pivot_mem_446_i0 child_envelope_sub_446_i0 envelope_origin_446_i0 +def checked_446_i0 : CheckedCard where + required := required_446_i0 + envelope := envelope_446_i0 + height := height_446_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_446_i0 +def height_446 : ℕ := 7 +def childrenH_446 : Fin 2 → ℕ := ![height_5, height_446_i0] +theorem height_exact_446 : height_446 = 1 + Finset.univ.sup childrenH_446 := by decide +kernel +theorem required_origin_446 : ∀ x ∈ required_446, + (∃ j, x ∈ childrenC_446 j) ∨ ∀ j, x ∈ childrenD_446 j := by decide +kernel +theorem required_exact_446 : required_446 = + ((Finset.univ.biUnion childrenC_446) ∪ commonEnvelope childrenD_446).erase (2, 3) := by + exact required_eq_combination childrenC_446 childrenD_446 (2, 3) required_446 + (by decide +kernel) child_required_sub_446 common_sub_446 required_origin_446 +theorem envelope_origin_446 : ∀ x ∈ envelope_446, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_446 j := by decide +kernel +theorem envelope_exact_446 : envelope_446 = + insert (2, 3) (Finset.univ.biUnion childrenD_446) := by + exact envelope_eq_combination childrenD_446 (2, 3) envelope_446 + pivot_mem_446 child_envelope_sub_446 envelope_origin_446 +def checked_446 : CheckedCard where + required := required_446 + envelope := envelope_446 + height := height_446 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_446 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part03.lean new file mode 100644 index 0000000..308d759 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part03.lean @@ -0,0 +1,934 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_447_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_447_i0 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_447_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 0) required_0), (placed21 1 (0, 1) required_445)] +def childrenD_447_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 0) envelope_0), (placed21 1 (0, 1) envelope_445)] +theorem common_sub_447_i0 : commonEnvelope childrenD_447_i0 ⊆ insert (2, 3) required_447_i0 := by decide +kernel +theorem child_required_sub_447_i0 : ∀ j, childrenC_447_i0 j ⊆ insert (2, 3) required_447_i0 := by decide +kernel +theorem child_envelope_sub_447_i0 : ∀ j, childrenD_447_i0 j ⊆ envelope_447_i0 := by decide +kernel +theorem pivot_mem_447_i0 : (2, 3) ∈ envelope_447_i0 := by decide +kernel +theorem children_work_447_i0 : ∀ j, Template HasSnaky 5 (childrenC_447_i0 j) (childrenD_447_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_445 1 (0, 1)).mono (by decide +kernel) +theorem row_works_447_i0 : Template HasSnaky 6 required_447_i0 envelope_447_i0 := by + refine compose HasSnaky 5 childrenC_447_i0 childrenD_447_i0 children_work_447_i0 (2, 3) + required_447_i0 envelope_447_i0 pivot_mem_447_i0 child_required_sub_447_i0 child_envelope_sub_447_i0 ?_ + intro b hb + exact common_sub_447_i0 (mem_commonEnvelope childrenD_447_i0 b hb) +def required_447 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_447 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_447 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), required_447_i0] +def childrenD_447 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), envelope_447_i0] +theorem common_sub_447 : commonEnvelope childrenD_447 ⊆ insert (2, 4) required_447 := by decide +kernel +theorem child_required_sub_447 : ∀ j, childrenC_447 j ⊆ insert (2, 4) required_447 := by decide +kernel +theorem child_envelope_sub_447 : ∀ j, childrenD_447 j ⊆ envelope_447 := by decide +kernel +theorem pivot_mem_447 : (2, 4) ∈ envelope_447 := by decide +kernel +theorem children_work_447 : ∀ j, Template HasSnaky 6 (childrenC_447 j) (childrenD_447 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact row_works_447_i0.mono (by decide +kernel) +theorem row_works_447 : Template HasSnaky 7 required_447 envelope_447 := by + refine compose HasSnaky 6 childrenC_447 childrenD_447 children_work_447 (2, 4) + required_447 envelope_447 pivot_mem_447 child_required_sub_447 child_envelope_sub_447 ?_ + intro b hb + exact common_sub_447 (mem_commonEnvelope childrenD_447 b hb) +def required_453_i1 : Finset Cell := ⟨(([(0, 2), (2, 1), (3, 0), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_453_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_453_i1 : Fin 3 → Finset Cell := ![(placed21 2 (3, 0) required_21), (placed21 0 (2, 0) required_37), (placed21 5 (4, 0) required_354)] +def childrenD_453_i1 : Fin 3 → Finset Cell := ![(placed21 2 (3, 0) envelope_21), (placed21 0 (2, 0) envelope_37), (placed21 5 (4, 0) envelope_354)] +theorem common_sub_453_i1 : commonEnvelope childrenD_453_i1 ⊆ insert (3, 3) required_453_i1 := by decide +kernel +theorem child_required_sub_453_i1 : ∀ j, childrenC_453_i1 j ⊆ insert (3, 3) required_453_i1 := by decide +kernel +theorem child_envelope_sub_453_i1 : ∀ j, childrenD_453_i1 j ⊆ envelope_453_i1 := by decide +kernel +theorem pivot_mem_453_i1 : (3, 3) ∈ envelope_453_i1 := by decide +kernel +theorem children_work_453_i1 : ∀ j, Template HasSnaky 4 (childrenC_453_i1 j) (childrenD_453_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 2 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_37 0 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_354 5 (4, 0)).mono (by decide +kernel) +theorem row_works_453_i1 : Template HasSnaky 5 required_453_i1 envelope_453_i1 := by + refine compose HasSnaky 4 childrenC_453_i1 childrenD_453_i1 children_work_453_i1 (3, 3) + required_453_i1 envelope_453_i1 pivot_mem_453_i1 child_required_sub_453_i1 child_envelope_sub_453_i1 ?_ + intro b hb + exact common_sub_453_i1 (mem_commonEnvelope childrenD_453_i1 b hb) +def required_453_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (2, 1), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_453_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_453_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), required_453_i1] +def childrenD_453_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), envelope_453_i1] +theorem common_sub_453_i0 : commonEnvelope childrenD_453_i0 ⊆ insert (3, 0) required_453_i0 := by decide +kernel +theorem child_required_sub_453_i0 : ∀ j, childrenC_453_i0 j ⊆ insert (3, 0) required_453_i0 := by decide +kernel +theorem child_envelope_sub_453_i0 : ∀ j, childrenD_453_i0 j ⊆ envelope_453_i0 := by decide +kernel +theorem pivot_mem_453_i0 : (3, 0) ∈ envelope_453_i0 := by decide +kernel +theorem children_work_453_i0 : ∀ j, Template HasSnaky 5 (childrenC_453_i0 j) (childrenD_453_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact row_works_453_i1.mono (by decide +kernel) +theorem row_works_453_i0 : Template HasSnaky 6 required_453_i0 envelope_453_i0 := by + refine compose HasSnaky 5 childrenC_453_i0 childrenD_453_i0 children_work_453_i0 (3, 0) + required_453_i0 envelope_453_i0 pivot_mem_453_i0 child_required_sub_453_i0 child_envelope_sub_453_i0 ?_ + intro b hb + exact common_sub_453_i0 (mem_commonEnvelope childrenD_453_i0 b hb) +def required_453 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_453 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_453 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), required_453_i0] +def childrenD_453 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), envelope_453_i0] +theorem common_sub_453 : commonEnvelope childrenD_453 ⊆ insert (3, 2) required_453 := by decide +kernel +theorem child_required_sub_453 : ∀ j, childrenC_453 j ⊆ insert (3, 2) required_453 := by decide +kernel +theorem child_envelope_sub_453 : ∀ j, childrenD_453 j ⊆ envelope_453 := by decide +kernel +theorem pivot_mem_453 : (3, 2) ∈ envelope_453 := by decide +kernel +theorem children_work_453 : ∀ j, Template HasSnaky 6 (childrenC_453 j) (childrenD_453 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact row_works_453_i0.mono (by decide +kernel) +theorem row_works_453 : Template HasSnaky 7 required_453 envelope_453 := by + refine compose HasSnaky 6 childrenC_453 childrenD_453 children_work_453 (3, 2) + required_453 envelope_453 pivot_mem_453 child_required_sub_453 child_envelope_sub_453 ?_ + intro b hb + exact common_sub_453 (mem_commonEnvelope childrenD_453 b hb) +def required_466 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_466 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_466 : Fin 4 → Finset Cell := ![(placed21 2 (1, 0) required_7), (placed21 1 (0, 1) required_8), required_9, required_465] +def childrenD_466 : Fin 4 → Finset Cell := ![(placed21 2 (1, 0) envelope_7), (placed21 1 (0, 1) envelope_8), envelope_9, envelope_465] +theorem common_sub_466 : commonEnvelope childrenD_466 ⊆ insert (1, 4) required_466 := by decide +kernel +theorem child_required_sub_466 : ∀ j, childrenC_466 j ⊆ insert (1, 4) required_466 := by decide +kernel +theorem child_envelope_sub_466 : ∀ j, childrenD_466 j ⊆ envelope_466 := by decide +kernel +theorem pivot_mem_466 : (1, 4) ∈ envelope_466 := by decide +kernel +theorem children_work_466 : ∀ j, Template HasSnaky 6 (childrenC_466 j) (childrenD_466 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact row_works_9.mono (by decide +kernel) + · exact row_works_465.mono (by decide +kernel) +theorem row_works_466 : Template HasSnaky 7 required_466 envelope_466 := by + refine compose HasSnaky 6 childrenC_466 childrenD_466 children_work_466 (1, 4) + required_466 envelope_466 pivot_mem_466 child_required_sub_466 child_envelope_sub_466 ?_ + intro b hb + exact common_sub_466 (mem_commonEnvelope childrenD_466 b hb) +def required_469_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_469_i0 : Finset Cell := ⟨(([(0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_469_i0 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) required_101), (placed21 5 (2, 1) required_314)] +def childrenD_469_i0 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) envelope_101), (placed21 5 (2, 1) envelope_314)] +theorem common_sub_469_i0 : commonEnvelope childrenD_469_i0 ⊆ insert (2, 3) required_469_i0 := by decide +kernel +theorem child_required_sub_469_i0 : ∀ j, childrenC_469_i0 j ⊆ insert (2, 3) required_469_i0 := by decide +kernel +theorem child_envelope_sub_469_i0 : ∀ j, childrenD_469_i0 j ⊆ envelope_469_i0 := by decide +kernel +theorem pivot_mem_469_i0 : (2, 3) ∈ envelope_469_i0 := by decide +kernel +theorem children_work_469_i0 : ∀ j, Template HasSnaky 5 (childrenC_469_i0 j) (childrenD_469_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_101 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_314 5 (2, 1)).mono (by decide +kernel) +theorem row_works_469_i0 : Template HasSnaky 6 required_469_i0 envelope_469_i0 := by + refine compose HasSnaky 5 childrenC_469_i0 childrenD_469_i0 children_work_469_i0 (2, 3) + required_469_i0 envelope_469_i0 pivot_mem_469_i0 child_required_sub_469_i0 child_envelope_sub_469_i0 ?_ + intro b hb + exact common_sub_469_i0 (mem_commonEnvelope childrenD_469_i0 b hb) +def required_469 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_469 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_469 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_78), required_469_i0] +def childrenD_469 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_78), envelope_469_i0] +theorem common_sub_469 : commonEnvelope childrenD_469 ⊆ insert (3, 2) required_469 := by decide +kernel +theorem child_required_sub_469 : ∀ j, childrenC_469 j ⊆ insert (3, 2) required_469 := by decide +kernel +theorem child_envelope_sub_469 : ∀ j, childrenD_469 j ⊆ envelope_469 := by decide +kernel +theorem pivot_mem_469 : (3, 2) ∈ envelope_469 := by decide +kernel +theorem children_work_469 : ∀ j, Template HasSnaky 6 (childrenC_469 j) (childrenD_469 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_78 3 (0, 4)).mono (by decide +kernel) + · exact row_works_469_i0.mono (by decide +kernel) +theorem row_works_469 : Template HasSnaky 7 required_469 envelope_469 := by + refine compose HasSnaky 6 childrenC_469 childrenD_469 children_work_469 (3, 2) + required_469 envelope_469 pivot_mem_469 child_required_sub_469 child_envelope_sub_469 ?_ + intro b hb + exact common_sub_469 (mem_commonEnvelope childrenD_469 b hb) +def required_472 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_472 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_472 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) required_5), (placed21 2 (4, 0) required_471)] +def childrenD_472 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) envelope_5), (placed21 2 (4, 0) envelope_471)] +theorem common_sub_472 : commonEnvelope childrenD_472 ⊆ insert (4, 3) required_472 := by decide +kernel +theorem child_required_sub_472 : ∀ j, childrenC_472 j ⊆ insert (4, 3) required_472 := by decide +kernel +theorem child_envelope_sub_472 : ∀ j, childrenD_472 j ⊆ envelope_472 := by decide +kernel +theorem pivot_mem_472 : (4, 3) ∈ envelope_472 := by decide +kernel +theorem children_work_472 : ∀ j, Template HasSnaky 6 (childrenC_472 j) (childrenD_472 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_471 2 (4, 0)).mono (by decide +kernel) +theorem row_works_472 : Template HasSnaky 7 required_472 envelope_472 := by + refine compose HasSnaky 6 childrenC_472 childrenD_472 children_work_472 (4, 3) + required_472 envelope_472 pivot_mem_472 child_required_sub_472 child_envelope_sub_472 ?_ + intro b hb + exact common_sub_472 (mem_commonEnvelope childrenD_472 b hb) +def required_487 : Finset Cell := ⟨(([(0, 1), (1, 3), (3, 0), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_487 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_487 : Fin 2 → Finset Cell := ![(placed21 5 (3, 0) required_5), required_486] +def childrenD_487 : Fin 2 → Finset Cell := ![(placed21 5 (3, 0) envelope_5), envelope_486] +theorem common_sub_487 : commonEnvelope childrenD_487 ⊆ insert (2, 3) required_487 := by decide +kernel +theorem child_required_sub_487 : ∀ j, childrenC_487 j ⊆ insert (2, 3) required_487 := by decide +kernel +theorem child_envelope_sub_487 : ∀ j, childrenD_487 j ⊆ envelope_487 := by decide +kernel +theorem pivot_mem_487 : (2, 3) ∈ envelope_487 := by decide +kernel +theorem children_work_487 : ∀ j, Template HasSnaky 6 (childrenC_487 j) (childrenD_487 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (3, 0)).mono (by decide +kernel) + · exact row_works_486.mono (by decide +kernel) +theorem row_works_487 : Template HasSnaky 7 required_487 envelope_487 := by + refine compose HasSnaky 6 childrenC_487 childrenD_487 children_work_487 (2, 3) + required_487 envelope_487 pivot_mem_487 child_required_sub_487 child_envelope_sub_487 ?_ + intro b hb + exact common_sub_487 (mem_commonEnvelope childrenD_487 b hb) +def required_488_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 6), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_488_i1 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (2, 6), (2, 7), (3, 6), (4, 5), (4, 6), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_488_i1 : Fin 2 → Finset Cell := ![(placed21 1 (1, 3) required_5), (placed21 3 (0, 6) required_34)] +def childrenD_488_i1 : Fin 2 → Finset Cell := ![(placed21 1 (1, 3) envelope_5), (placed21 3 (0, 6) envelope_34)] +theorem common_sub_488_i1 : commonEnvelope childrenD_488_i1 ⊆ insert (1, 6) required_488_i1 := by decide +kernel +theorem child_required_sub_488_i1 : ∀ j, childrenC_488_i1 j ⊆ insert (1, 6) required_488_i1 := by decide +kernel +theorem child_envelope_sub_488_i1 : ∀ j, childrenD_488_i1 j ⊆ envelope_488_i1 := by decide +kernel +theorem pivot_mem_488_i1 : (1, 6) ∈ envelope_488_i1 := by decide +kernel +theorem children_work_488_i1 : ∀ j, Template HasSnaky 2 (childrenC_488_i1 j) (childrenD_488_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_34 3 (0, 6)).mono (by decide +kernel) +theorem row_works_488_i1 : Template HasSnaky 3 required_488_i1 envelope_488_i1 := by + refine compose HasSnaky 2 childrenC_488_i1 childrenD_488_i1 children_work_488_i1 (1, 6) + required_488_i1 envelope_488_i1 pivot_mem_488_i1 child_required_sub_488_i1 child_envelope_sub_488_i1 ?_ + intro b hb + exact common_sub_488_i1 (mem_commonEnvelope childrenD_488_i1 b hb) +def required_488_i0 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_488_i0 : Finset Cell := ⟨(([(0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7), (3, 6), (4, 5), (4, 6), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_488_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) required_4), required_488_i1] +def childrenD_488_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) envelope_4), envelope_488_i1] +theorem common_sub_488_i0 : commonEnvelope childrenD_488_i0 ⊆ insert (2, 6) required_488_i0 := by decide +kernel +theorem child_required_sub_488_i0 : ∀ j, childrenC_488_i0 j ⊆ insert (2, 6) required_488_i0 := by decide +kernel +theorem child_envelope_sub_488_i0 : ∀ j, childrenD_488_i0 j ⊆ envelope_488_i0 := by decide +kernel +theorem pivot_mem_488_i0 : (2, 6) ∈ envelope_488_i0 := by decide +kernel +theorem children_work_488_i0 : ∀ j, Template HasSnaky 3 (childrenC_488_i0 j) (childrenD_488_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 1 (1, 2)).mono (by decide +kernel) + · exact row_works_488_i1.mono (by decide +kernel) +theorem row_works_488_i0 : Template HasSnaky 4 required_488_i0 envelope_488_i0 := by + refine compose HasSnaky 3 childrenC_488_i0 childrenD_488_i0 children_work_488_i0 (2, 6) + required_488_i0 envelope_488_i0 pivot_mem_488_i0 child_required_sub_488_i0 child_envelope_sub_488_i0 ?_ + intro b hb + exact common_sub_488_i0 (mem_commonEnvelope childrenD_488_i0 b hb) +def required_488_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (4, 3), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_488_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_488_i2 : Fin 3 → Finset Cell := ![(placed21 0 (4, 2) required_7), (placed21 2 (5, 2) required_9), (placed21 0 (1, 3) required_357)] +def childrenD_488_i2 : Fin 3 → Finset Cell := ![(placed21 0 (4, 2) envelope_7), (placed21 2 (5, 2) envelope_9), (placed21 0 (1, 3) envelope_357)] +theorem common_sub_488_i2 : commonEnvelope childrenD_488_i2 ⊆ insert (4, 4) required_488_i2 := by decide +kernel +theorem child_required_sub_488_i2 : ∀ j, childrenC_488_i2 j ⊆ insert (4, 4) required_488_i2 := by decide +kernel +theorem child_envelope_sub_488_i2 : ∀ j, childrenD_488_i2 j ⊆ envelope_488_i2 := by decide +kernel +theorem pivot_mem_488_i2 : (4, 4) ∈ envelope_488_i2 := by decide +kernel +theorem children_work_488_i2 : ∀ j, Template HasSnaky 5 (childrenC_488_i2 j) (childrenD_488_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_357 0 (1, 3)).mono (by decide +kernel) +theorem row_works_488_i2 : Template HasSnaky 6 required_488_i2 envelope_488_i2 := by + refine compose HasSnaky 5 childrenC_488_i2 childrenD_488_i2 children_work_488_i2 (4, 4) + required_488_i2 envelope_488_i2 pivot_mem_488_i2 child_required_sub_488_i2 child_envelope_sub_488_i2 ?_ + intro b hb + exact common_sub_488_i2 (mem_commonEnvelope childrenD_488_i2 b hb) +def required_488 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_488 : Finset Cell := ⟨(([(0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_488 : Fin 3 → Finset Cell := ![(placed21 6 (5, 9) required_95), required_488_i0, required_488_i2] +def childrenD_488 : Fin 3 → Finset Cell := ![(placed21 6 (5, 9) envelope_95), envelope_488_i0, envelope_488_i2] +theorem common_sub_488 : commonEnvelope childrenD_488 ⊆ insert (4, 6) required_488 := by decide +kernel +theorem child_required_sub_488 : ∀ j, childrenC_488 j ⊆ insert (4, 6) required_488 := by decide +kernel +theorem child_envelope_sub_488 : ∀ j, childrenD_488 j ⊆ envelope_488 := by decide +kernel +theorem pivot_mem_488 : (4, 6) ∈ envelope_488 := by decide +kernel +theorem children_work_488 : ∀ j, Template HasSnaky 6 (childrenC_488 j) (childrenD_488 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_95 6 (5, 9)).mono (by decide +kernel) + · exact row_works_488_i0.mono (by decide +kernel) + · exact row_works_488_i2.mono (by decide +kernel) +theorem row_works_488 : Template HasSnaky 7 required_488 envelope_488 := by + refine compose HasSnaky 6 childrenC_488 childrenD_488 children_work_488 (4, 6) + required_488 envelope_488 pivot_mem_488 child_required_sub_488 child_envelope_sub_488 ?_ + intro b hb + exact common_sub_488 (mem_commonEnvelope childrenD_488 b hb) +def required_499_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_499_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_499_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_1), (placed21 0 (1, 1) required_347)] +def childrenD_499_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_1), (placed21 0 (1, 1) envelope_347)] +theorem common_sub_499_i0 : commonEnvelope childrenD_499_i0 ⊆ insert (4, 3) required_499_i0 := by decide +kernel +theorem child_required_sub_499_i0 : ∀ j, childrenC_499_i0 j ⊆ insert (4, 3) required_499_i0 := by decide +kernel +theorem child_envelope_sub_499_i0 : ∀ j, childrenD_499_i0 j ⊆ envelope_499_i0 := by decide +kernel +theorem pivot_mem_499_i0 : (4, 3) ∈ envelope_499_i0 := by decide +kernel +theorem children_work_499_i0 : ∀ j, Template HasSnaky 5 (childrenC_499_i0 j) (childrenD_499_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 6 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_347 0 (1, 1)).mono (by decide +kernel) +theorem row_works_499_i0 : Template HasSnaky 6 required_499_i0 envelope_499_i0 := by + refine compose HasSnaky 5 childrenC_499_i0 childrenD_499_i0 children_work_499_i0 (4, 3) + required_499_i0 envelope_499_i0 pivot_mem_499_i0 child_required_sub_499_i0 child_envelope_sub_499_i0 ?_ + intro b hb + exact common_sub_499_i0 (mem_commonEnvelope childrenD_499_i0 b hb) +def required_499_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_499_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_499_i1 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) required_43), (placed21 0 (2, 0) required_52)] +def childrenD_499_i1 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) envelope_43), (placed21 0 (2, 0) envelope_52)] +theorem common_sub_499_i1 : commonEnvelope childrenD_499_i1 ⊆ insert (3, 3) required_499_i1 := by decide +kernel +theorem child_required_sub_499_i1 : ∀ j, childrenC_499_i1 j ⊆ insert (3, 3) required_499_i1 := by decide +kernel +theorem child_envelope_sub_499_i1 : ∀ j, childrenD_499_i1 j ⊆ envelope_499_i1 := by decide +kernel +theorem pivot_mem_499_i1 : (3, 3) ∈ envelope_499_i1 := by decide +kernel +theorem children_work_499_i1 : ∀ j, Template HasSnaky 3 (childrenC_499_i1 j) (childrenD_499_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_43 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (2, 0)).mono (by decide +kernel) +theorem row_works_499_i1 : Template HasSnaky 4 required_499_i1 envelope_499_i1 := by + refine compose HasSnaky 3 childrenC_499_i1 childrenD_499_i1 children_work_499_i1 (3, 3) + required_499_i1 envelope_499_i1 pivot_mem_499_i1 child_required_sub_499_i1 child_envelope_sub_499_i1 ?_ + intro b hb + exact common_sub_499_i1 (mem_commonEnvelope childrenD_499_i1 b hb) +def required_499 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_499 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_499 : Fin 3 → Finset Cell := ![(placed21 2 (2, 0) required_15), required_499_i0, required_499_i1] +def childrenD_499 : Fin 3 → Finset Cell := ![(placed21 2 (2, 0) envelope_15), envelope_499_i0, envelope_499_i1] +theorem common_sub_499 : commonEnvelope childrenD_499 ⊆ insert (2, 1) required_499 := by decide +kernel +theorem child_required_sub_499 : ∀ j, childrenC_499 j ⊆ insert (2, 1) required_499 := by decide +kernel +theorem child_envelope_sub_499 : ∀ j, childrenD_499 j ⊆ envelope_499 := by decide +kernel +theorem pivot_mem_499 : (2, 1) ∈ envelope_499 := by decide +kernel +theorem children_work_499 : ∀ j, Template HasSnaky 6 (childrenC_499 j) (childrenD_499 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 2 (2, 0)).mono (by decide +kernel) + · exact row_works_499_i0.mono (by decide +kernel) + · exact row_works_499_i1.mono (by decide +kernel) +theorem row_works_499 : Template HasSnaky 7 required_499 envelope_499 := by + refine compose HasSnaky 6 childrenC_499 childrenD_499 children_work_499 (2, 1) + required_499 envelope_499 pivot_mem_499 child_required_sub_499 child_envelope_sub_499 ?_ + intro b hb + exact common_sub_499 (mem_commonEnvelope childrenD_499 b hb) +def required_504_i1 : Finset Cell := ⟨(([(2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_504_i1 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 4), (4, 5), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_504_i1 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) required_0), (placed21 1 (0, 1) required_56)] +def childrenD_504_i1 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) envelope_0), (placed21 1 (0, 1) envelope_56)] +theorem common_sub_504_i1 : commonEnvelope childrenD_504_i1 ⊆ insert (2, 3) required_504_i1 := by decide +kernel +theorem child_required_sub_504_i1 : ∀ j, childrenC_504_i1 j ⊆ insert (2, 3) required_504_i1 := by decide +kernel +theorem child_envelope_sub_504_i1 : ∀ j, childrenD_504_i1 j ⊆ envelope_504_i1 := by decide +kernel +theorem pivot_mem_504_i1 : (2, 3) ∈ envelope_504_i1 := by decide +kernel +theorem children_work_504_i1 : ∀ j, Template HasSnaky 4 (childrenC_504_i1 j) (childrenD_504_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_56 1 (0, 1)).mono (by decide +kernel) +theorem row_works_504_i1 : Template HasSnaky 5 required_504_i1 envelope_504_i1 := by + refine compose HasSnaky 4 childrenC_504_i1 childrenD_504_i1 children_work_504_i1 (2, 3) + required_504_i1 envelope_504_i1 pivot_mem_504_i1 child_required_sub_504_i1 child_envelope_sub_504_i1 ?_ + intro b hb + exact common_sub_504_i1 (mem_commonEnvelope childrenD_504_i1 b hb) +def required_504_i0 : Finset Cell := ⟨(([(2, 2), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_504_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_504_i0 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) required_6), (placed21 0 (2, 2) required_18), required_504_i1] +def childrenD_504_i0 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) envelope_6), (placed21 0 (2, 2) envelope_18), envelope_504_i1] +theorem common_sub_504_i0 : commonEnvelope childrenD_504_i0 ⊆ insert (3, 5) required_504_i0 := by decide +kernel +theorem child_required_sub_504_i0 : ∀ j, childrenC_504_i0 j ⊆ insert (3, 5) required_504_i0 := by decide +kernel +theorem child_envelope_sub_504_i0 : ∀ j, childrenD_504_i0 j ⊆ envelope_504_i0 := by decide +kernel +theorem pivot_mem_504_i0 : (3, 5) ∈ envelope_504_i0 := by decide +kernel +theorem children_work_504_i0 : ∀ j, Template HasSnaky 5 (childrenC_504_i0 j) (childrenD_504_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_18 0 (2, 2)).mono (by decide +kernel) + · exact row_works_504_i1.mono (by decide +kernel) +theorem row_works_504_i0 : Template HasSnaky 6 required_504_i0 envelope_504_i0 := by + refine compose HasSnaky 5 childrenC_504_i0 childrenD_504_i0 children_work_504_i0 (3, 5) + required_504_i0 envelope_504_i0 pivot_mem_504_i0 child_required_sub_504_i0 child_envelope_sub_504_i0 ?_ + intro b hb + exact common_sub_504_i0 (mem_commonEnvelope childrenD_504_i0 b hb) +def required_504 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_504 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_504 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) required_32), required_504_i0] +def childrenD_504 : Fin 2 → Finset Cell := ![(placed21 7 (4, 4) envelope_32), envelope_504_i0] +theorem common_sub_504 : commonEnvelope childrenD_504 ⊆ insert (3, 1) required_504 := by decide +kernel +theorem child_required_sub_504 : ∀ j, childrenC_504 j ⊆ insert (3, 1) required_504 := by decide +kernel +theorem child_envelope_sub_504 : ∀ j, childrenD_504 j ⊆ envelope_504 := by decide +kernel +theorem pivot_mem_504 : (3, 1) ∈ envelope_504 := by decide +kernel +theorem children_work_504 : ∀ j, Template HasSnaky 6 (childrenC_504 j) (childrenD_504 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_32 7 (4, 4)).mono (by decide +kernel) + · exact row_works_504_i0.mono (by decide +kernel) +theorem row_works_504 : Template HasSnaky 7 required_504 envelope_504 := by + refine compose HasSnaky 6 childrenC_504 childrenD_504 children_work_504 (3, 1) + required_504 envelope_504 pivot_mem_504 child_required_sub_504 child_envelope_sub_504 ?_ + intro b hb + exact common_sub_504 (mem_commonEnvelope childrenD_504 b hb) +def required_507_i0 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_507_i0 : Finset Cell := ⟨(([(1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_507_i0 : Fin 3 → Finset Cell := ![(placed21 6 (4, 7) required_33), (placed21 6 (3, 6) required_44), (placed21 3 (1, 6) required_47)] +def childrenD_507_i0 : Fin 3 → Finset Cell := ![(placed21 6 (4, 7) envelope_33), (placed21 6 (3, 6) envelope_44), (placed21 3 (1, 6) envelope_47)] +theorem common_sub_507_i0 : commonEnvelope childrenD_507_i0 ⊆ insert (3, 5) required_507_i0 := by decide +kernel +theorem child_required_sub_507_i0 : ∀ j, childrenC_507_i0 j ⊆ insert (3, 5) required_507_i0 := by decide +kernel +theorem child_envelope_sub_507_i0 : ∀ j, childrenD_507_i0 j ⊆ envelope_507_i0 := by decide +kernel +theorem pivot_mem_507_i0 : (3, 5) ∈ envelope_507_i0 := by decide +kernel +theorem children_work_507_i0 : ∀ j, Template HasSnaky 5 (childrenC_507_i0 j) (childrenD_507_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_33 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_44 6 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_47 3 (1, 6)).mono (by decide +kernel) +theorem row_works_507_i0 : Template HasSnaky 6 required_507_i0 envelope_507_i0 := by + refine compose HasSnaky 5 childrenC_507_i0 childrenD_507_i0 children_work_507_i0 (3, 5) + required_507_i0 envelope_507_i0 pivot_mem_507_i0 child_required_sub_507_i0 child_envelope_sub_507_i0 ?_ + intro b hb + exact common_sub_507_i0 (mem_commonEnvelope childrenD_507_i0 b hb) +def required_507 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_507 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_507 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) required_44), required_274, (placed21 2 (4, 0) required_506), required_507_i0] +def childrenD_507 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) envelope_44), envelope_274, (placed21 2 (4, 0) envelope_506), envelope_507_i0] +theorem common_sub_507 : commonEnvelope childrenD_507 ⊆ insert (3, 4) required_507 := by decide +kernel +theorem child_required_sub_507 : ∀ j, childrenC_507 j ⊆ insert (3, 4) required_507 := by decide +kernel +theorem child_envelope_sub_507 : ∀ j, childrenD_507 j ⊆ envelope_507 := by decide +kernel +theorem pivot_mem_507 : (3, 4) ∈ envelope_507 := by decide +kernel +theorem children_work_507 : ∀ j, Template HasSnaky 6 (childrenC_507 j) (childrenD_507 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 1 (0, 3)).mono (by decide +kernel) + · exact row_works_274.mono (by decide +kernel) + · exact (placed21_template row_works_506 2 (4, 0)).mono (by decide +kernel) + · exact row_works_507_i0.mono (by decide +kernel) +theorem row_works_507 : Template HasSnaky 7 required_507 envelope_507 := by + refine compose HasSnaky 6 childrenC_507 childrenD_507 children_work_507 (3, 4) + required_507 envelope_507 pivot_mem_507 child_required_sub_507 child_envelope_sub_507 ?_ + intro b hb + exact common_sub_507 (mem_commonEnvelope childrenD_507 b hb) +def height_447_i0 : ℕ := 6 +def childrenH_447_i0 : Fin 2 → ℕ := ![height_0, height_445] +theorem height_exact_447_i0 : height_447_i0 = 1 + Finset.univ.sup childrenH_447_i0 := by decide +kernel +theorem required_origin_447_i0 : ∀ x ∈ required_447_i0, + (∃ j, x ∈ childrenC_447_i0 j) ∨ ∀ j, x ∈ childrenD_447_i0 j := by decide +kernel +theorem required_exact_447_i0 : required_447_i0 = + ((Finset.univ.biUnion childrenC_447_i0) ∪ commonEnvelope childrenD_447_i0).erase (2, 3) := by + exact required_eq_combination childrenC_447_i0 childrenD_447_i0 (2, 3) required_447_i0 + (by decide +kernel) child_required_sub_447_i0 common_sub_447_i0 required_origin_447_i0 +theorem envelope_origin_447_i0 : ∀ x ∈ envelope_447_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_447_i0 j := by decide +kernel +theorem envelope_exact_447_i0 : envelope_447_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_447_i0) := by + exact envelope_eq_combination childrenD_447_i0 (2, 3) envelope_447_i0 + pivot_mem_447_i0 child_envelope_sub_447_i0 envelope_origin_447_i0 +def checked_447_i0 : CheckedCard where + required := required_447_i0 + envelope := envelope_447_i0 + height := height_447_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_447_i0 +def height_447 : ℕ := 7 +def childrenH_447 : Fin 2 → ℕ := ![height_5, height_447_i0] +theorem height_exact_447 : height_447 = 1 + Finset.univ.sup childrenH_447 := by decide +kernel +theorem required_origin_447 : ∀ x ∈ required_447, + (∃ j, x ∈ childrenC_447 j) ∨ ∀ j, x ∈ childrenD_447 j := by decide +kernel +theorem required_exact_447 : required_447 = + ((Finset.univ.biUnion childrenC_447) ∪ commonEnvelope childrenD_447).erase (2, 4) := by + exact required_eq_combination childrenC_447 childrenD_447 (2, 4) required_447 + (by decide +kernel) child_required_sub_447 common_sub_447 required_origin_447 +theorem envelope_origin_447 : ∀ x ∈ envelope_447, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_447 j := by decide +kernel +theorem envelope_exact_447 : envelope_447 = + insert (2, 4) (Finset.univ.biUnion childrenD_447) := by + exact envelope_eq_combination childrenD_447 (2, 4) envelope_447 + pivot_mem_447 child_envelope_sub_447 envelope_origin_447 +def checked_447 : CheckedCard where + required := required_447 + envelope := envelope_447 + height := height_447 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_447 +def height_453_i1 : ℕ := 5 +def childrenH_453_i1 : Fin 3 → ℕ := ![height_21, height_37, height_354] +theorem height_exact_453_i1 : height_453_i1 = 1 + Finset.univ.sup childrenH_453_i1 := by decide +kernel +theorem required_origin_453_i1 : ∀ x ∈ required_453_i1, + (∃ j, x ∈ childrenC_453_i1 j) ∨ ∀ j, x ∈ childrenD_453_i1 j := by decide +kernel +theorem required_exact_453_i1 : required_453_i1 = + ((Finset.univ.biUnion childrenC_453_i1) ∪ commonEnvelope childrenD_453_i1).erase (3, 3) := by + exact required_eq_combination childrenC_453_i1 childrenD_453_i1 (3, 3) required_453_i1 + (by decide +kernel) child_required_sub_453_i1 common_sub_453_i1 required_origin_453_i1 +theorem envelope_origin_453_i1 : ∀ x ∈ envelope_453_i1, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_453_i1 j := by decide +kernel +theorem envelope_exact_453_i1 : envelope_453_i1 = + insert (3, 3) (Finset.univ.biUnion childrenD_453_i1) := by + exact envelope_eq_combination childrenD_453_i1 (3, 3) envelope_453_i1 + pivot_mem_453_i1 child_envelope_sub_453_i1 envelope_origin_453_i1 +def checked_453_i1 : CheckedCard where + required := required_453_i1 + envelope := envelope_453_i1 + height := height_453_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_453_i1 +def height_453_i0 : ℕ := 6 +def childrenH_453_i0 : Fin 2 → ℕ := ![height_5, height_453_i1] +theorem height_exact_453_i0 : height_453_i0 = 1 + Finset.univ.sup childrenH_453_i0 := by decide +kernel +theorem required_origin_453_i0 : ∀ x ∈ required_453_i0, + (∃ j, x ∈ childrenC_453_i0 j) ∨ ∀ j, x ∈ childrenD_453_i0 j := by decide +kernel +theorem required_exact_453_i0 : required_453_i0 = + ((Finset.univ.biUnion childrenC_453_i0) ∪ commonEnvelope childrenD_453_i0).erase (3, 0) := by + exact required_eq_combination childrenC_453_i0 childrenD_453_i0 (3, 0) required_453_i0 + (by decide +kernel) child_required_sub_453_i0 common_sub_453_i0 required_origin_453_i0 +theorem envelope_origin_453_i0 : ∀ x ∈ envelope_453_i0, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_453_i0 j := by decide +kernel +theorem envelope_exact_453_i0 : envelope_453_i0 = + insert (3, 0) (Finset.univ.biUnion childrenD_453_i0) := by + exact envelope_eq_combination childrenD_453_i0 (3, 0) envelope_453_i0 + pivot_mem_453_i0 child_envelope_sub_453_i0 envelope_origin_453_i0 +def checked_453_i0 : CheckedCard where + required := required_453_i0 + envelope := envelope_453_i0 + height := height_453_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_453_i0 +def height_453 : ℕ := 7 +def childrenH_453 : Fin 2 → ℕ := ![height_5, height_453_i0] +theorem height_exact_453 : height_453 = 1 + Finset.univ.sup childrenH_453 := by decide +kernel +theorem required_origin_453 : ∀ x ∈ required_453, + (∃ j, x ∈ childrenC_453 j) ∨ ∀ j, x ∈ childrenD_453 j := by decide +kernel +theorem required_exact_453 : required_453 = + ((Finset.univ.biUnion childrenC_453) ∪ commonEnvelope childrenD_453).erase (3, 2) := by + exact required_eq_combination childrenC_453 childrenD_453 (3, 2) required_453 + (by decide +kernel) child_required_sub_453 common_sub_453 required_origin_453 +theorem envelope_origin_453 : ∀ x ∈ envelope_453, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_453 j := by decide +kernel +theorem envelope_exact_453 : envelope_453 = + insert (3, 2) (Finset.univ.biUnion childrenD_453) := by + exact envelope_eq_combination childrenD_453 (3, 2) envelope_453 + pivot_mem_453 child_envelope_sub_453 envelope_origin_453 +def checked_453 : CheckedCard where + required := required_453 + envelope := envelope_453 + height := height_453 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_453 +def height_466 : ℕ := 7 +def childrenH_466 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_465] +theorem height_exact_466 : height_466 = 1 + Finset.univ.sup childrenH_466 := by decide +kernel +theorem required_origin_466 : ∀ x ∈ required_466, + (∃ j, x ∈ childrenC_466 j) ∨ ∀ j, x ∈ childrenD_466 j := by decide +kernel +theorem required_exact_466 : required_466 = + ((Finset.univ.biUnion childrenC_466) ∪ commonEnvelope childrenD_466).erase (1, 4) := by + exact required_eq_combination childrenC_466 childrenD_466 (1, 4) required_466 + (by decide +kernel) child_required_sub_466 common_sub_466 required_origin_466 +theorem envelope_origin_466 : ∀ x ∈ envelope_466, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_466 j := by decide +kernel +theorem envelope_exact_466 : envelope_466 = + insert (1, 4) (Finset.univ.biUnion childrenD_466) := by + exact envelope_eq_combination childrenD_466 (1, 4) envelope_466 + pivot_mem_466 child_envelope_sub_466 envelope_origin_466 +def checked_466 : CheckedCard where + required := required_466 + envelope := envelope_466 + height := height_466 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_466 +def height_469_i0 : ℕ := 6 +def childrenH_469_i0 : Fin 2 → ℕ := ![height_101, height_314] +theorem height_exact_469_i0 : height_469_i0 = 1 + Finset.univ.sup childrenH_469_i0 := by decide +kernel +theorem required_origin_469_i0 : ∀ x ∈ required_469_i0, + (∃ j, x ∈ childrenC_469_i0 j) ∨ ∀ j, x ∈ childrenD_469_i0 j := by decide +kernel +theorem required_exact_469_i0 : required_469_i0 = + ((Finset.univ.biUnion childrenC_469_i0) ∪ commonEnvelope childrenD_469_i0).erase (2, 3) := by + exact required_eq_combination childrenC_469_i0 childrenD_469_i0 (2, 3) required_469_i0 + (by decide +kernel) child_required_sub_469_i0 common_sub_469_i0 required_origin_469_i0 +theorem envelope_origin_469_i0 : ∀ x ∈ envelope_469_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_469_i0 j := by decide +kernel +theorem envelope_exact_469_i0 : envelope_469_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_469_i0) := by + exact envelope_eq_combination childrenD_469_i0 (2, 3) envelope_469_i0 + pivot_mem_469_i0 child_envelope_sub_469_i0 envelope_origin_469_i0 +def checked_469_i0 : CheckedCard where + required := required_469_i0 + envelope := envelope_469_i0 + height := height_469_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_469_i0 +def height_469 : ℕ := 7 +def childrenH_469 : Fin 2 → ℕ := ![height_78, height_469_i0] +theorem height_exact_469 : height_469 = 1 + Finset.univ.sup childrenH_469 := by decide +kernel +theorem required_origin_469 : ∀ x ∈ required_469, + (∃ j, x ∈ childrenC_469 j) ∨ ∀ j, x ∈ childrenD_469 j := by decide +kernel +theorem required_exact_469 : required_469 = + ((Finset.univ.biUnion childrenC_469) ∪ commonEnvelope childrenD_469).erase (3, 2) := by + exact required_eq_combination childrenC_469 childrenD_469 (3, 2) required_469 + (by decide +kernel) child_required_sub_469 common_sub_469 required_origin_469 +theorem envelope_origin_469 : ∀ x ∈ envelope_469, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_469 j := by decide +kernel +theorem envelope_exact_469 : envelope_469 = + insert (3, 2) (Finset.univ.biUnion childrenD_469) := by + exact envelope_eq_combination childrenD_469 (3, 2) envelope_469 + pivot_mem_469 child_envelope_sub_469 envelope_origin_469 +def checked_469 : CheckedCard where + required := required_469 + envelope := envelope_469 + height := height_469 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_469 +def height_472 : ℕ := 7 +def childrenH_472 : Fin 2 → ℕ := ![height_5, height_471] +theorem height_exact_472 : height_472 = 1 + Finset.univ.sup childrenH_472 := by decide +kernel +theorem required_origin_472 : ∀ x ∈ required_472, + (∃ j, x ∈ childrenC_472 j) ∨ ∀ j, x ∈ childrenD_472 j := by decide +kernel +theorem required_exact_472 : required_472 = + ((Finset.univ.biUnion childrenC_472) ∪ commonEnvelope childrenD_472).erase (4, 3) := by + exact required_eq_combination childrenC_472 childrenD_472 (4, 3) required_472 + (by decide +kernel) child_required_sub_472 common_sub_472 required_origin_472 +theorem envelope_origin_472 : ∀ x ∈ envelope_472, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_472 j := by decide +kernel +theorem envelope_exact_472 : envelope_472 = + insert (4, 3) (Finset.univ.biUnion childrenD_472) := by + exact envelope_eq_combination childrenD_472 (4, 3) envelope_472 + pivot_mem_472 child_envelope_sub_472 envelope_origin_472 +def checked_472 : CheckedCard where + required := required_472 + envelope := envelope_472 + height := height_472 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_472 +def height_487 : ℕ := 7 +def childrenH_487 : Fin 2 → ℕ := ![height_5, height_486] +theorem height_exact_487 : height_487 = 1 + Finset.univ.sup childrenH_487 := by decide +kernel +theorem required_origin_487 : ∀ x ∈ required_487, + (∃ j, x ∈ childrenC_487 j) ∨ ∀ j, x ∈ childrenD_487 j := by decide +kernel +theorem required_exact_487 : required_487 = + ((Finset.univ.biUnion childrenC_487) ∪ commonEnvelope childrenD_487).erase (2, 3) := by + exact required_eq_combination childrenC_487 childrenD_487 (2, 3) required_487 + (by decide +kernel) child_required_sub_487 common_sub_487 required_origin_487 +theorem envelope_origin_487 : ∀ x ∈ envelope_487, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_487 j := by decide +kernel +theorem envelope_exact_487 : envelope_487 = + insert (2, 3) (Finset.univ.biUnion childrenD_487) := by + exact envelope_eq_combination childrenD_487 (2, 3) envelope_487 + pivot_mem_487 child_envelope_sub_487 envelope_origin_487 +def checked_487 : CheckedCard where + required := required_487 + envelope := envelope_487 + height := height_487 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_487 +def height_488_i1 : ℕ := 3 +def childrenH_488_i1 : Fin 2 → ℕ := ![height_5, height_34] +theorem height_exact_488_i1 : height_488_i1 = 1 + Finset.univ.sup childrenH_488_i1 := by decide +kernel +theorem required_origin_488_i1 : ∀ x ∈ required_488_i1, + (∃ j, x ∈ childrenC_488_i1 j) ∨ ∀ j, x ∈ childrenD_488_i1 j := by decide +kernel +theorem required_exact_488_i1 : required_488_i1 = + ((Finset.univ.biUnion childrenC_488_i1) ∪ commonEnvelope childrenD_488_i1).erase (1, 6) := by + exact required_eq_combination childrenC_488_i1 childrenD_488_i1 (1, 6) required_488_i1 + (by decide +kernel) child_required_sub_488_i1 common_sub_488_i1 required_origin_488_i1 +theorem envelope_origin_488_i1 : ∀ x ∈ envelope_488_i1, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_488_i1 j := by decide +kernel +theorem envelope_exact_488_i1 : envelope_488_i1 = + insert (1, 6) (Finset.univ.biUnion childrenD_488_i1) := by + exact envelope_eq_combination childrenD_488_i1 (1, 6) envelope_488_i1 + pivot_mem_488_i1 child_envelope_sub_488_i1 envelope_origin_488_i1 +def checked_488_i1 : CheckedCard where + required := required_488_i1 + envelope := envelope_488_i1 + height := height_488_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_488_i1 +def height_488_i0 : ℕ := 4 +def childrenH_488_i0 : Fin 2 → ℕ := ![height_4, height_488_i1] +theorem height_exact_488_i0 : height_488_i0 = 1 + Finset.univ.sup childrenH_488_i0 := by decide +kernel +theorem required_origin_488_i0 : ∀ x ∈ required_488_i0, + (∃ j, x ∈ childrenC_488_i0 j) ∨ ∀ j, x ∈ childrenD_488_i0 j := by decide +kernel +theorem required_exact_488_i0 : required_488_i0 = + ((Finset.univ.biUnion childrenC_488_i0) ∪ commonEnvelope childrenD_488_i0).erase (2, 6) := by + exact required_eq_combination childrenC_488_i0 childrenD_488_i0 (2, 6) required_488_i0 + (by decide +kernel) child_required_sub_488_i0 common_sub_488_i0 required_origin_488_i0 +theorem envelope_origin_488_i0 : ∀ x ∈ envelope_488_i0, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_488_i0 j := by decide +kernel +theorem envelope_exact_488_i0 : envelope_488_i0 = + insert (2, 6) (Finset.univ.biUnion childrenD_488_i0) := by + exact envelope_eq_combination childrenD_488_i0 (2, 6) envelope_488_i0 + pivot_mem_488_i0 child_envelope_sub_488_i0 envelope_origin_488_i0 +def checked_488_i0 : CheckedCard where + required := required_488_i0 + envelope := envelope_488_i0 + height := height_488_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_488_i0 +def height_488_i2 : ℕ := 6 +def childrenH_488_i2 : Fin 3 → ℕ := ![height_7, height_9, height_357] +theorem height_exact_488_i2 : height_488_i2 = 1 + Finset.univ.sup childrenH_488_i2 := by decide +kernel +theorem required_origin_488_i2 : ∀ x ∈ required_488_i2, + (∃ j, x ∈ childrenC_488_i2 j) ∨ ∀ j, x ∈ childrenD_488_i2 j := by decide +kernel +theorem required_exact_488_i2 : required_488_i2 = + ((Finset.univ.biUnion childrenC_488_i2) ∪ commonEnvelope childrenD_488_i2).erase (4, 4) := by + exact required_eq_combination childrenC_488_i2 childrenD_488_i2 (4, 4) required_488_i2 + (by decide +kernel) child_required_sub_488_i2 common_sub_488_i2 required_origin_488_i2 +theorem envelope_origin_488_i2 : ∀ x ∈ envelope_488_i2, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_488_i2 j := by decide +kernel +theorem envelope_exact_488_i2 : envelope_488_i2 = + insert (4, 4) (Finset.univ.biUnion childrenD_488_i2) := by + exact envelope_eq_combination childrenD_488_i2 (4, 4) envelope_488_i2 + pivot_mem_488_i2 child_envelope_sub_488_i2 envelope_origin_488_i2 +def checked_488_i2 : CheckedCard where + required := required_488_i2 + envelope := envelope_488_i2 + height := height_488_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_488_i2 +def height_488 : ℕ := 7 +def childrenH_488 : Fin 3 → ℕ := ![height_95, height_488_i0, height_488_i2] +theorem height_exact_488 : height_488 = 1 + Finset.univ.sup childrenH_488 := by decide +kernel +theorem required_origin_488 : ∀ x ∈ required_488, + (∃ j, x ∈ childrenC_488 j) ∨ ∀ j, x ∈ childrenD_488 j := by decide +kernel +theorem required_exact_488 : required_488 = + ((Finset.univ.biUnion childrenC_488) ∪ commonEnvelope childrenD_488).erase (4, 6) := by + exact required_eq_combination childrenC_488 childrenD_488 (4, 6) required_488 + (by decide +kernel) child_required_sub_488 common_sub_488 required_origin_488 +theorem envelope_origin_488 : ∀ x ∈ envelope_488, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_488 j := by decide +kernel +theorem envelope_exact_488 : envelope_488 = + insert (4, 6) (Finset.univ.biUnion childrenD_488) := by + exact envelope_eq_combination childrenD_488 (4, 6) envelope_488 + pivot_mem_488 child_envelope_sub_488 envelope_origin_488 +def checked_488 : CheckedCard where + required := required_488 + envelope := envelope_488 + height := height_488 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_488 +def height_499_i0 : ℕ := 6 +def childrenH_499_i0 : Fin 2 → ℕ := ![height_1, height_347] +theorem height_exact_499_i0 : height_499_i0 = 1 + Finset.univ.sup childrenH_499_i0 := by decide +kernel +theorem required_origin_499_i0 : ∀ x ∈ required_499_i0, + (∃ j, x ∈ childrenC_499_i0 j) ∨ ∀ j, x ∈ childrenD_499_i0 j := by decide +kernel +theorem required_exact_499_i0 : required_499_i0 = + ((Finset.univ.biUnion childrenC_499_i0) ∪ commonEnvelope childrenD_499_i0).erase (4, 3) := by + exact required_eq_combination childrenC_499_i0 childrenD_499_i0 (4, 3) required_499_i0 + (by decide +kernel) child_required_sub_499_i0 common_sub_499_i0 required_origin_499_i0 +theorem envelope_origin_499_i0 : ∀ x ∈ envelope_499_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_499_i0 j := by decide +kernel +theorem envelope_exact_499_i0 : envelope_499_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_499_i0) := by + exact envelope_eq_combination childrenD_499_i0 (4, 3) envelope_499_i0 + pivot_mem_499_i0 child_envelope_sub_499_i0 envelope_origin_499_i0 +def checked_499_i0 : CheckedCard where + required := required_499_i0 + envelope := envelope_499_i0 + height := height_499_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_499_i0 +def height_499_i1 : ℕ := 4 +def childrenH_499_i1 : Fin 2 → ℕ := ![height_43, height_52] +theorem height_exact_499_i1 : height_499_i1 = 1 + Finset.univ.sup childrenH_499_i1 := by decide +kernel +theorem required_origin_499_i1 : ∀ x ∈ required_499_i1, + (∃ j, x ∈ childrenC_499_i1 j) ∨ ∀ j, x ∈ childrenD_499_i1 j := by decide +kernel +theorem required_exact_499_i1 : required_499_i1 = + ((Finset.univ.biUnion childrenC_499_i1) ∪ commonEnvelope childrenD_499_i1).erase (3, 3) := by + exact required_eq_combination childrenC_499_i1 childrenD_499_i1 (3, 3) required_499_i1 + (by decide +kernel) child_required_sub_499_i1 common_sub_499_i1 required_origin_499_i1 +theorem envelope_origin_499_i1 : ∀ x ∈ envelope_499_i1, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_499_i1 j := by decide +kernel +theorem envelope_exact_499_i1 : envelope_499_i1 = + insert (3, 3) (Finset.univ.biUnion childrenD_499_i1) := by + exact envelope_eq_combination childrenD_499_i1 (3, 3) envelope_499_i1 + pivot_mem_499_i1 child_envelope_sub_499_i1 envelope_origin_499_i1 +def checked_499_i1 : CheckedCard where + required := required_499_i1 + envelope := envelope_499_i1 + height := height_499_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_499_i1 +def height_499 : ℕ := 7 +def childrenH_499 : Fin 3 → ℕ := ![height_15, height_499_i0, height_499_i1] +theorem height_exact_499 : height_499 = 1 + Finset.univ.sup childrenH_499 := by decide +kernel +theorem required_origin_499 : ∀ x ∈ required_499, + (∃ j, x ∈ childrenC_499 j) ∨ ∀ j, x ∈ childrenD_499 j := by decide +kernel +theorem required_exact_499 : required_499 = + ((Finset.univ.biUnion childrenC_499) ∪ commonEnvelope childrenD_499).erase (2, 1) := by + exact required_eq_combination childrenC_499 childrenD_499 (2, 1) required_499 + (by decide +kernel) child_required_sub_499 common_sub_499 required_origin_499 +theorem envelope_origin_499 : ∀ x ∈ envelope_499, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_499 j := by decide +kernel +theorem envelope_exact_499 : envelope_499 = + insert (2, 1) (Finset.univ.biUnion childrenD_499) := by + exact envelope_eq_combination childrenD_499 (2, 1) envelope_499 + pivot_mem_499 child_envelope_sub_499 envelope_origin_499 +def checked_499 : CheckedCard where + required := required_499 + envelope := envelope_499 + height := height_499 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_499 +def height_504_i1 : ℕ := 5 +def childrenH_504_i1 : Fin 2 → ℕ := ![height_0, height_56] +theorem height_exact_504_i1 : height_504_i1 = 1 + Finset.univ.sup childrenH_504_i1 := by decide +kernel +theorem required_origin_504_i1 : ∀ x ∈ required_504_i1, + (∃ j, x ∈ childrenC_504_i1 j) ∨ ∀ j, x ∈ childrenD_504_i1 j := by decide +kernel +theorem required_exact_504_i1 : required_504_i1 = + ((Finset.univ.biUnion childrenC_504_i1) ∪ commonEnvelope childrenD_504_i1).erase (2, 3) := by + exact required_eq_combination childrenC_504_i1 childrenD_504_i1 (2, 3) required_504_i1 + (by decide +kernel) child_required_sub_504_i1 common_sub_504_i1 required_origin_504_i1 +theorem envelope_origin_504_i1 : ∀ x ∈ envelope_504_i1, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_504_i1 j := by decide +kernel +theorem envelope_exact_504_i1 : envelope_504_i1 = + insert (2, 3) (Finset.univ.biUnion childrenD_504_i1) := by + exact envelope_eq_combination childrenD_504_i1 (2, 3) envelope_504_i1 + pivot_mem_504_i1 child_envelope_sub_504_i1 envelope_origin_504_i1 +def checked_504_i1 : CheckedCard where + required := required_504_i1 + envelope := envelope_504_i1 + height := height_504_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_504_i1 +def height_504_i0 : ℕ := 6 +def childrenH_504_i0 : Fin 3 → ℕ := ![height_6, height_18, height_504_i1] +theorem height_exact_504_i0 : height_504_i0 = 1 + Finset.univ.sup childrenH_504_i0 := by decide +kernel +theorem required_origin_504_i0 : ∀ x ∈ required_504_i0, + (∃ j, x ∈ childrenC_504_i0 j) ∨ ∀ j, x ∈ childrenD_504_i0 j := by decide +kernel +theorem required_exact_504_i0 : required_504_i0 = + ((Finset.univ.biUnion childrenC_504_i0) ∪ commonEnvelope childrenD_504_i0).erase (3, 5) := by + exact required_eq_combination childrenC_504_i0 childrenD_504_i0 (3, 5) required_504_i0 + (by decide +kernel) child_required_sub_504_i0 common_sub_504_i0 required_origin_504_i0 +theorem envelope_origin_504_i0 : ∀ x ∈ envelope_504_i0, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_504_i0 j := by decide +kernel +theorem envelope_exact_504_i0 : envelope_504_i0 = + insert (3, 5) (Finset.univ.biUnion childrenD_504_i0) := by + exact envelope_eq_combination childrenD_504_i0 (3, 5) envelope_504_i0 + pivot_mem_504_i0 child_envelope_sub_504_i0 envelope_origin_504_i0 +def checked_504_i0 : CheckedCard where + required := required_504_i0 + envelope := envelope_504_i0 + height := height_504_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_504_i0 +def height_504 : ℕ := 7 +def childrenH_504 : Fin 2 → ℕ := ![height_32, height_504_i0] +theorem height_exact_504 : height_504 = 1 + Finset.univ.sup childrenH_504 := by decide +kernel +theorem required_origin_504 : ∀ x ∈ required_504, + (∃ j, x ∈ childrenC_504 j) ∨ ∀ j, x ∈ childrenD_504 j := by decide +kernel +theorem required_exact_504 : required_504 = + ((Finset.univ.biUnion childrenC_504) ∪ commonEnvelope childrenD_504).erase (3, 1) := by + exact required_eq_combination childrenC_504 childrenD_504 (3, 1) required_504 + (by decide +kernel) child_required_sub_504 common_sub_504 required_origin_504 +theorem envelope_origin_504 : ∀ x ∈ envelope_504, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_504 j := by decide +kernel +theorem envelope_exact_504 : envelope_504 = + insert (3, 1) (Finset.univ.biUnion childrenD_504) := by + exact envelope_eq_combination childrenD_504 (3, 1) envelope_504 + pivot_mem_504 child_envelope_sub_504 envelope_origin_504 +def checked_504 : CheckedCard where + required := required_504 + envelope := envelope_504 + height := height_504 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_504 +def height_507_i0 : ℕ := 6 +def childrenH_507_i0 : Fin 3 → ℕ := ![height_33, height_44, height_47] +theorem height_exact_507_i0 : height_507_i0 = 1 + Finset.univ.sup childrenH_507_i0 := by decide +kernel +theorem required_origin_507_i0 : ∀ x ∈ required_507_i0, + (∃ j, x ∈ childrenC_507_i0 j) ∨ ∀ j, x ∈ childrenD_507_i0 j := by decide +kernel +theorem required_exact_507_i0 : required_507_i0 = + ((Finset.univ.biUnion childrenC_507_i0) ∪ commonEnvelope childrenD_507_i0).erase (3, 5) := by + exact required_eq_combination childrenC_507_i0 childrenD_507_i0 (3, 5) required_507_i0 + (by decide +kernel) child_required_sub_507_i0 common_sub_507_i0 required_origin_507_i0 +theorem envelope_origin_507_i0 : ∀ x ∈ envelope_507_i0, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_507_i0 j := by decide +kernel +theorem envelope_exact_507_i0 : envelope_507_i0 = + insert (3, 5) (Finset.univ.biUnion childrenD_507_i0) := by + exact envelope_eq_combination childrenD_507_i0 (3, 5) envelope_507_i0 + pivot_mem_507_i0 child_envelope_sub_507_i0 envelope_origin_507_i0 +def checked_507_i0 : CheckedCard where + required := required_507_i0 + envelope := envelope_507_i0 + height := height_507_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_507_i0 +def height_507 : ℕ := 7 +def childrenH_507 : Fin 4 → ℕ := ![height_44, height_274, height_506, height_507_i0] +theorem height_exact_507 : height_507 = 1 + Finset.univ.sup childrenH_507 := by decide +kernel +theorem required_origin_507 : ∀ x ∈ required_507, + (∃ j, x ∈ childrenC_507 j) ∨ ∀ j, x ∈ childrenD_507 j := by decide +kernel +theorem required_exact_507 : required_507 = + ((Finset.univ.biUnion childrenC_507) ∪ commonEnvelope childrenD_507).erase (3, 4) := by + exact required_eq_combination childrenC_507 childrenD_507 (3, 4) required_507 + (by decide +kernel) child_required_sub_507 common_sub_507 required_origin_507 +theorem envelope_origin_507 : ∀ x ∈ envelope_507, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_507 j := by decide +kernel +theorem envelope_exact_507 : envelope_507 = + insert (3, 4) (Finset.univ.biUnion childrenD_507) := by + exact envelope_eq_combination childrenD_507 (3, 4) envelope_507 + pivot_mem_507 child_envelope_sub_507 envelope_origin_507 +def checked_507 : CheckedCard where + required := required_507 + envelope := envelope_507 + height := height_507 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_507 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part04.lean new file mode 100644 index 0000000..bb4c525 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part04.lean @@ -0,0 +1,1013 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_511_i1 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_511_i1 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_511_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) required_2), (placed21 0 (3, 1) required_44)] +def childrenD_511_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) envelope_2), (placed21 0 (3, 1) envelope_44)] +theorem common_sub_511_i1 : commonEnvelope childrenD_511_i1 ⊆ insert (4, 4) required_511_i1 := by decide +kernel +theorem child_required_sub_511_i1 : ∀ j, childrenC_511_i1 j ⊆ insert (4, 4) required_511_i1 := by decide +kernel +theorem child_envelope_sub_511_i1 : ∀ j, childrenD_511_i1 j ⊆ envelope_511_i1 := by decide +kernel +theorem pivot_mem_511_i1 : (4, 4) ∈ envelope_511_i1 := by decide +kernel +theorem children_work_511_i1 : ∀ j, Template HasSnaky 3 (childrenC_511_i1 j) (childrenD_511_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 6 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_44 0 (3, 1)).mono (by decide +kernel) +theorem row_works_511_i1 : Template HasSnaky 4 required_511_i1 envelope_511_i1 := by + refine compose HasSnaky 3 childrenC_511_i1 childrenD_511_i1 children_work_511_i1 (4, 4) + required_511_i1 envelope_511_i1 pivot_mem_511_i1 child_required_sub_511_i1 child_envelope_sub_511_i1 ?_ + intro b hb + exact common_sub_511_i1 (mem_commonEnvelope childrenD_511_i1 b hb) +def required_511_i3 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_511_i3 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_511_i3 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) required_7), (placed21 2 (4, 1) required_9), (placed21 0 (1, 2) required_221)] +def childrenD_511_i3 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) envelope_7), (placed21 2 (4, 1) envelope_9), (placed21 0 (1, 2) envelope_221)] +theorem common_sub_511_i3 : commonEnvelope childrenD_511_i3 ⊆ insert (3, 5) required_511_i3 := by decide +kernel +theorem child_required_sub_511_i3 : ∀ j, childrenC_511_i3 j ⊆ insert (3, 5) required_511_i3 := by decide +kernel +theorem child_envelope_sub_511_i3 : ∀ j, childrenD_511_i3 j ⊆ envelope_511_i3 := by decide +kernel +theorem pivot_mem_511_i3 : (3, 5) ∈ envelope_511_i3 := by decide +kernel +theorem children_work_511_i3 : ∀ j, Template HasSnaky 3 (childrenC_511_i3 j) (childrenD_511_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_221 0 (1, 2)).mono (by decide +kernel) +theorem row_works_511_i3 : Template HasSnaky 4 required_511_i3 envelope_511_i3 := by + refine compose HasSnaky 3 childrenC_511_i3 childrenD_511_i3 children_work_511_i3 (3, 5) + required_511_i3 envelope_511_i3 pivot_mem_511_i3 child_required_sub_511_i3 child_envelope_sub_511_i3 ?_ + intro b hb + exact common_sub_511_i3 (mem_commonEnvelope childrenD_511_i3 b hb) +def required_511_i2 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_511_i2 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_511_i2 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) required_0), required_511_i3] +def childrenD_511_i2 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) envelope_0), envelope_511_i3] +theorem common_sub_511_i2 : commonEnvelope childrenD_511_i2 ⊆ insert (2, 4) required_511_i2 := by decide +kernel +theorem child_required_sub_511_i2 : ∀ j, childrenC_511_i2 j ⊆ insert (2, 4) required_511_i2 := by decide +kernel +theorem child_envelope_sub_511_i2 : ∀ j, childrenD_511_i2 j ⊆ envelope_511_i2 := by decide +kernel +theorem pivot_mem_511_i2 : (2, 4) ∈ envelope_511_i2 := by decide +kernel +theorem children_work_511_i2 : ∀ j, Template HasSnaky 4 (childrenC_511_i2 j) (childrenD_511_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 4)).mono (by decide +kernel) + · exact row_works_511_i3.mono (by decide +kernel) +theorem row_works_511_i2 : Template HasSnaky 5 required_511_i2 envelope_511_i2 := by + refine compose HasSnaky 4 childrenC_511_i2 childrenD_511_i2 children_work_511_i2 (2, 4) + required_511_i2 envelope_511_i2 pivot_mem_511_i2 child_required_sub_511_i2 child_envelope_sub_511_i2 ?_ + intro b hb + exact common_sub_511_i2 (mem_commonEnvelope childrenD_511_i2 b hb) +def required_511_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_511_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_511_i0 : Fin 5 → Finset Cell := ![(placed21 2 (4, 0) required_13), (placed21 2 (4, 0) required_14), (placed21 0 (0, 1) required_240), required_511_i1, required_511_i2] +def childrenD_511_i0 : Fin 5 → Finset Cell := ![(placed21 2 (4, 0) envelope_13), (placed21 2 (4, 0) envelope_14), (placed21 0 (0, 1) envelope_240), envelope_511_i1, envelope_511_i2] +theorem common_sub_511_i0 : commonEnvelope childrenD_511_i0 ⊆ insert (3, 4) required_511_i0 := by decide +kernel +theorem child_required_sub_511_i0 : ∀ j, childrenC_511_i0 j ⊆ insert (3, 4) required_511_i0 := by decide +kernel +theorem child_envelope_sub_511_i0 : ∀ j, childrenD_511_i0 j ⊆ envelope_511_i0 := by decide +kernel +theorem pivot_mem_511_i0 : (3, 4) ∈ envelope_511_i0 := by decide +kernel +theorem children_work_511_i0 : ∀ j, Template HasSnaky 5 (childrenC_511_i0 j) (childrenD_511_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_14 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_240 0 (0, 1)).mono (by decide +kernel) + · exact row_works_511_i1.mono (by decide +kernel) + · exact row_works_511_i2.mono (by decide +kernel) +theorem row_works_511_i0 : Template HasSnaky 6 required_511_i0 envelope_511_i0 := by + refine compose HasSnaky 5 childrenC_511_i0 childrenD_511_i0 children_work_511_i0 (3, 4) + required_511_i0 envelope_511_i0 pivot_mem_511_i0 child_required_sub_511_i0 child_envelope_sub_511_i0 ?_ + intro b hb + exact common_sub_511_i0 (mem_commonEnvelope childrenD_511_i0 b hb) +def required_511 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_511 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_511 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) required_15), required_511_i0] +def childrenD_511 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) envelope_15), envelope_511_i0] +theorem common_sub_511 : commonEnvelope childrenD_511 ⊆ insert (1, 4) required_511 := by decide +kernel +theorem child_required_sub_511 : ∀ j, childrenC_511 j ⊆ insert (1, 4) required_511 := by decide +kernel +theorem child_envelope_sub_511 : ∀ j, childrenD_511 j ⊆ envelope_511 := by decide +kernel +theorem pivot_mem_511 : (1, 4) ∈ envelope_511 := by decide +kernel +theorem children_work_511 : ∀ j, Template HasSnaky 6 (childrenC_511 j) (childrenD_511 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 6 (1, 5)).mono (by decide +kernel) + · exact row_works_511_i0.mono (by decide +kernel) +theorem row_works_511 : Template HasSnaky 7 required_511 envelope_511 := by + refine compose HasSnaky 6 childrenC_511 childrenD_511 children_work_511 (1, 4) + required_511 envelope_511 pivot_mem_511 child_required_sub_511 child_envelope_sub_511 ?_ + intro b hb + exact common_sub_511 (mem_commonEnvelope childrenD_511 b hb) +def required_522_i0 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_522_i0 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_522_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_5), (placed21 0 (1, 0) required_416)] +def childrenD_522_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_5), (placed21 0 (1, 0) envelope_416)] +theorem common_sub_522_i0 : commonEnvelope childrenD_522_i0 ⊆ insert (1, 3) required_522_i0 := by decide +kernel +theorem child_required_sub_522_i0 : ∀ j, childrenC_522_i0 j ⊆ insert (1, 3) required_522_i0 := by decide +kernel +theorem child_envelope_sub_522_i0 : ∀ j, childrenD_522_i0 j ⊆ envelope_522_i0 := by decide +kernel +theorem pivot_mem_522_i0 : (1, 3) ∈ envelope_522_i0 := by decide +kernel +theorem children_work_522_i0 : ∀ j, Template HasSnaky 5 (childrenC_522_i0 j) (childrenD_522_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_416 0 (1, 0)).mono (by decide +kernel) +theorem row_works_522_i0 : Template HasSnaky 6 required_522_i0 envelope_522_i0 := by + refine compose HasSnaky 5 childrenC_522_i0 childrenD_522_i0 children_work_522_i0 (1, 3) + required_522_i0 envelope_522_i0 pivot_mem_522_i0 child_required_sub_522_i0 child_envelope_sub_522_i0 ?_ + intro b hb + exact common_sub_522_i0 (mem_commonEnvelope childrenD_522_i0 b hb) +def required_522 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_522 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_522 : Fin 3 → Finset Cell := ![(placed21 0 (1, 1) required_8), (placed21 1 (0, 2) required_11), required_522_i0] +def childrenD_522 : Fin 3 → Finset Cell := ![(placed21 0 (1, 1) envelope_8), (placed21 1 (0, 2) envelope_11), envelope_522_i0] +theorem common_sub_522 : commonEnvelope childrenD_522 ⊆ insert (4, 2) required_522 := by decide +kernel +theorem child_required_sub_522 : ∀ j, childrenC_522 j ⊆ insert (4, 2) required_522 := by decide +kernel +theorem child_envelope_sub_522 : ∀ j, childrenD_522 j ⊆ envelope_522 := by decide +kernel +theorem pivot_mem_522 : (4, 2) ∈ envelope_522 := by decide +kernel +theorem children_work_522 : ∀ j, Template HasSnaky 6 (childrenC_522 j) (childrenD_522 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_11 1 (0, 2)).mono (by decide +kernel) + · exact row_works_522_i0.mono (by decide +kernel) +theorem row_works_522 : Template HasSnaky 7 required_522 envelope_522 := by + refine compose HasSnaky 6 childrenC_522 childrenD_522 children_work_522 (4, 2) + required_522 envelope_522 pivot_mem_522 child_required_sub_522 child_envelope_sub_522 ?_ + intro b hb + exact common_sub_522 (mem_commonEnvelope childrenD_522 b hb) +def required_526 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_526 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_526 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_0), required_525] +def childrenD_526 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_0), envelope_525] +theorem common_sub_526 : commonEnvelope childrenD_526 ⊆ insert (3, 1) required_526 := by decide +kernel +theorem child_required_sub_526 : ∀ j, childrenC_526 j ⊆ insert (3, 1) required_526 := by decide +kernel +theorem child_envelope_sub_526 : ∀ j, childrenD_526 j ⊆ envelope_526 := by decide +kernel +theorem pivot_mem_526 : (3, 1) ∈ envelope_526 := by decide +kernel +theorem children_work_526 : ∀ j, Template HasSnaky 6 (childrenC_526 j) (childrenD_526 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact row_works_525.mono (by decide +kernel) +theorem row_works_526 : Template HasSnaky 7 required_526 envelope_526 := by + refine compose HasSnaky 6 childrenC_526 childrenD_526 children_work_526 (3, 1) + required_526 envelope_526 pivot_mem_526 child_required_sub_526 child_envelope_sub_526 ?_ + intro b hb + exact common_sub_526 (mem_commonEnvelope childrenD_526 b hb) +def required_542_i3 : Finset Cell := ⟨(([(1, 3), (2, 1), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_542_i3 : Finset Cell := ⟨(([(1, 3), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_542_i3 : Fin 2 → Finset Cell := ![(placed21 6 (6, 2) required_0), (placed21 4 (1, 3) required_1)] +def childrenD_542_i3 : Fin 2 → Finset Cell := ![(placed21 6 (6, 2) envelope_0), (placed21 4 (1, 3) envelope_1)] +theorem common_sub_542_i3 : commonEnvelope childrenD_542_i3 ⊆ insert (5, 2) required_542_i3 := by decide +kernel +theorem child_required_sub_542_i3 : ∀ j, childrenC_542_i3 j ⊆ insert (5, 2) required_542_i3 := by decide +kernel +theorem child_envelope_sub_542_i3 : ∀ j, childrenD_542_i3 j ⊆ envelope_542_i3 := by decide +kernel +theorem pivot_mem_542_i3 : (5, 2) ∈ envelope_542_i3 := by decide +kernel +theorem children_work_542_i3 : ∀ j, Template HasSnaky 1 (childrenC_542_i3 j) (childrenD_542_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_1 4 (1, 3)).mono (by decide +kernel) +theorem row_works_542_i3 : Template HasSnaky 2 required_542_i3 envelope_542_i3 := by + refine compose HasSnaky 1 childrenC_542_i3 childrenD_542_i3 children_work_542_i3 (5, 2) + required_542_i3 envelope_542_i3 pivot_mem_542_i3 child_required_sub_542_i3 child_envelope_sub_542_i3 ?_ + intro b hb + exact common_sub_542_i3 (mem_commonEnvelope childrenD_542_i3 b hb) +def required_542_i2 : Finset Cell := ⟨(([(1, 3), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_542_i2 : Finset Cell := ⟨(([(1, 3), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_542_i2 : Fin 2 → Finset Cell := ![(placed21 0 (3, 1) required_29), required_542_i3] +def childrenD_542_i2 : Fin 2 → Finset Cell := ![(placed21 0 (3, 1) envelope_29), envelope_542_i3] +theorem common_sub_542_i2 : commonEnvelope childrenD_542_i2 ⊆ insert (4, 3) required_542_i2 := by decide +kernel +theorem child_required_sub_542_i2 : ∀ j, childrenC_542_i2 j ⊆ insert (4, 3) required_542_i2 := by decide +kernel +theorem child_envelope_sub_542_i2 : ∀ j, childrenD_542_i2 j ⊆ envelope_542_i2 := by decide +kernel +theorem pivot_mem_542_i2 : (4, 3) ∈ envelope_542_i2 := by decide +kernel +theorem children_work_542_i2 : ∀ j, Template HasSnaky 3 (childrenC_542_i2 j) (childrenD_542_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_29 0 (3, 1)).mono (by decide +kernel) + · exact row_works_542_i3.mono (by decide +kernel) +theorem row_works_542_i2 : Template HasSnaky 4 required_542_i2 envelope_542_i2 := by + refine compose HasSnaky 3 childrenC_542_i2 childrenD_542_i2 children_work_542_i2 (4, 3) + required_542_i2 envelope_542_i2 pivot_mem_542_i2 child_required_sub_542_i2 child_envelope_sub_542_i2 ?_ + intro b hb + exact common_sub_542_i2 (mem_commonEnvelope childrenD_542_i2 b hb) +def required_542_i1 : Finset Cell := ⟨(([(0, 1), (1, 3), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_542_i1 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_542_i1 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_1), required_542_i2] +def childrenD_542_i1 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_1), envelope_542_i2] +theorem common_sub_542_i1 : commonEnvelope childrenD_542_i1 ⊆ insert (4, 2) required_542_i1 := by decide +kernel +theorem child_required_sub_542_i1 : ∀ j, childrenC_542_i1 j ⊆ insert (4, 2) required_542_i1 := by decide +kernel +theorem child_envelope_sub_542_i1 : ∀ j, childrenD_542_i1 j ⊆ envelope_542_i1 := by decide +kernel +theorem pivot_mem_542_i1 : (4, 2) ∈ envelope_542_i1 := by decide +kernel +theorem children_work_542_i1 : ∀ j, Template HasSnaky 4 (childrenC_542_i1 j) (childrenD_542_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (0, 1)).mono (by decide +kernel) + · exact row_works_542_i2.mono (by decide +kernel) +theorem row_works_542_i1 : Template HasSnaky 5 required_542_i1 envelope_542_i1 := by + refine compose HasSnaky 4 childrenC_542_i1 childrenD_542_i1 children_work_542_i1 (4, 2) + required_542_i1 envelope_542_i1 pivot_mem_542_i1 child_required_sub_542_i1 child_envelope_sub_542_i1 ?_ + intro b hb + exact common_sub_542_i1 (mem_commonEnvelope childrenD_542_i1 b hb) +def required_542_i0 : Finset Cell := ⟨(([(0, 1), (1, 3), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_542_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 3), (2, 0), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_542_i0 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) required_5), required_542_i1] +def childrenD_542_i0 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) envelope_5), envelope_542_i1] +theorem common_sub_542_i0 : commonEnvelope childrenD_542_i0 ⊆ insert (2, 1) required_542_i0 := by decide +kernel +theorem child_required_sub_542_i0 : ∀ j, childrenC_542_i0 j ⊆ insert (2, 1) required_542_i0 := by decide +kernel +theorem child_envelope_sub_542_i0 : ∀ j, childrenD_542_i0 j ⊆ envelope_542_i0 := by decide +kernel +theorem pivot_mem_542_i0 : (2, 1) ∈ envelope_542_i0 := by decide +kernel +theorem children_work_542_i0 : ∀ j, Template HasSnaky 5 (childrenC_542_i0 j) (childrenD_542_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (3, 4)).mono (by decide +kernel) + · exact row_works_542_i1.mono (by decide +kernel) +theorem row_works_542_i0 : Template HasSnaky 6 required_542_i0 envelope_542_i0 := by + refine compose HasSnaky 5 childrenC_542_i0 childrenD_542_i0 children_work_542_i0 (2, 1) + required_542_i0 envelope_542_i0 pivot_mem_542_i0 child_required_sub_542_i0 child_envelope_sub_542_i0 ?_ + intro b hb + exact common_sub_542_i0 (mem_commonEnvelope childrenD_542_i0 b hb) +def required_542 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (1, 5), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_542 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_542 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_3), required_542_i0] +def childrenD_542 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_3), envelope_542_i0] +theorem common_sub_542 : commonEnvelope childrenD_542 ⊆ insert (1, 3) required_542 := by decide +kernel +theorem child_required_sub_542 : ∀ j, childrenC_542 j ⊆ insert (1, 3) required_542 := by decide +kernel +theorem child_envelope_sub_542 : ∀ j, childrenD_542 j ⊆ envelope_542 := by decide +kernel +theorem pivot_mem_542 : (1, 3) ∈ envelope_542 := by decide +kernel +theorem children_work_542 : ∀ j, Template HasSnaky 6 (childrenC_542 j) (childrenD_542 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 7 (1, 5)).mono (by decide +kernel) + · exact row_works_542_i0.mono (by decide +kernel) +theorem row_works_542 : Template HasSnaky 7 required_542 envelope_542 := by + refine compose HasSnaky 6 childrenC_542 childrenD_542 children_work_542 (1, 3) + required_542 envelope_542 pivot_mem_542 child_required_sub_542 child_envelope_sub_542 ?_ + intro b hb + exact common_sub_542 (mem_commonEnvelope childrenD_542 b hb) +def required_554_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (1, 4), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_554_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_554_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), (placed21 0 (0, 3) required_515)] +def childrenD_554_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), (placed21 0 (0, 3) envelope_515)] +theorem common_sub_554_i0 : commonEnvelope childrenD_554_i0 ⊆ insert (1, 3) required_554_i0 := by decide +kernel +theorem child_required_sub_554_i0 : ∀ j, childrenC_554_i0 j ⊆ insert (1, 3) required_554_i0 := by decide +kernel +theorem child_envelope_sub_554_i0 : ∀ j, childrenD_554_i0 j ⊆ envelope_554_i0 := by decide +kernel +theorem pivot_mem_554_i0 : (1, 3) ∈ envelope_554_i0 := by decide +kernel +theorem children_work_554_i0 : ∀ j, Template HasSnaky 5 (childrenC_554_i0 j) (childrenD_554_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_515 0 (0, 3)).mono (by decide +kernel) +theorem row_works_554_i0 : Template HasSnaky 6 required_554_i0 envelope_554_i0 := by + refine compose HasSnaky 5 childrenC_554_i0 childrenD_554_i0 children_work_554_i0 (1, 3) + required_554_i0 envelope_554_i0 pivot_mem_554_i0 child_required_sub_554_i0 child_envelope_sub_554_i0 ?_ + intro b hb + exact common_sub_554_i0 (mem_commonEnvelope childrenD_554_i0 b hb) +def required_554 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_554 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_554 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_5), required_554_i0] +def childrenD_554 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_5), envelope_554_i0] +theorem common_sub_554 : commonEnvelope childrenD_554 ⊆ insert (1, 4) required_554 := by decide +kernel +theorem child_required_sub_554 : ∀ j, childrenC_554 j ⊆ insert (1, 4) required_554 := by decide +kernel +theorem child_envelope_sub_554 : ∀ j, childrenD_554 j ⊆ envelope_554 := by decide +kernel +theorem pivot_mem_554 : (1, 4) ∈ envelope_554 := by decide +kernel +theorem children_work_554 : ∀ j, Template HasSnaky 6 (childrenC_554 j) (childrenD_554 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (0, 1)).mono (by decide +kernel) + · exact row_works_554_i0.mono (by decide +kernel) +theorem row_works_554 : Template HasSnaky 7 required_554 envelope_554 := by + refine compose HasSnaky 6 childrenC_554 childrenD_554 children_work_554 (1, 4) + required_554 envelope_554 pivot_mem_554 child_required_sub_554 child_envelope_sub_554 ?_ + intro b hb + exact common_sub_554 (mem_commonEnvelope childrenD_554 b hb) +def required_565_i0 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_565_i0 : Finset Cell := ⟨(([(1, 2), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (4, 3), (5, 2), (5, 3), (6, 2), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_565_i0 : Fin 2 → Finset Cell := ![(placed21 4 (2, 3) required_5), (placed21 0 (1, 1) required_179)] +def childrenD_565_i0 : Fin 2 → Finset Cell := ![(placed21 4 (2, 3) envelope_5), (placed21 0 (1, 1) envelope_179)] +theorem common_sub_565_i0 : commonEnvelope childrenD_565_i0 ⊆ insert (5, 3) required_565_i0 := by decide +kernel +theorem child_required_sub_565_i0 : ∀ j, childrenC_565_i0 j ⊆ insert (5, 3) required_565_i0 := by decide +kernel +theorem child_envelope_sub_565_i0 : ∀ j, childrenD_565_i0 j ⊆ envelope_565_i0 := by decide +kernel +theorem pivot_mem_565_i0 : (5, 3) ∈ envelope_565_i0 := by decide +kernel +theorem children_work_565_i0 : ∀ j, Template HasSnaky 5 (childrenC_565_i0 j) (childrenD_565_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_179 0 (1, 1)).mono (by decide +kernel) +theorem row_works_565_i0 : Template HasSnaky 6 required_565_i0 envelope_565_i0 := by + refine compose HasSnaky 5 childrenC_565_i0 childrenD_565_i0 children_work_565_i0 (5, 3) + required_565_i0 envelope_565_i0 pivot_mem_565_i0 child_required_sub_565_i0 child_envelope_sub_565_i0 ?_ + intro b hb + exact common_sub_565_i0 (mem_commonEnvelope childrenD_565_i0 b hb) +def required_565_i1 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_565_i1 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_565_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 3) required_4), required_142] +def childrenD_565_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 3) envelope_4), envelope_142] +theorem common_sub_565_i1 : commonEnvelope childrenD_565_i1 ⊆ insert (1, 3) required_565_i1 := by decide +kernel +theorem child_required_sub_565_i1 : ∀ j, childrenC_565_i1 j ⊆ insert (1, 3) required_565_i1 := by decide +kernel +theorem child_envelope_sub_565_i1 : ∀ j, childrenD_565_i1 j ⊆ envelope_565_i1 := by decide +kernel +theorem pivot_mem_565_i1 : (1, 3) ∈ envelope_565_i1 := by decide +kernel +theorem children_work_565_i1 : ∀ j, Template HasSnaky 5 (childrenC_565_i1 j) (childrenD_565_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (1, 3)).mono (by decide +kernel) + · exact row_works_142.mono (by decide +kernel) +theorem row_works_565_i1 : Template HasSnaky 6 required_565_i1 envelope_565_i1 := by + refine compose HasSnaky 5 childrenC_565_i1 childrenD_565_i1 children_work_565_i1 (1, 3) + required_565_i1 envelope_565_i1 pivot_mem_565_i1 child_required_sub_565_i1 child_envelope_sub_565_i1 ?_ + intro b hb + exact common_sub_565_i1 (mem_commonEnvelope childrenD_565_i1 b hb) +def required_565 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_565 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3), (6, 2), (6, 3), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_565 : Fin 3 → Finset Cell := ![(placed21 3 (1, 3) required_140), required_565_i0, required_565_i1] +def childrenD_565 : Fin 3 → Finset Cell := ![(placed21 3 (1, 3) envelope_140), envelope_565_i0, envelope_565_i1] +theorem common_sub_565 : commonEnvelope childrenD_565 ⊆ insert (5, 2) required_565 := by decide +kernel +theorem child_required_sub_565 : ∀ j, childrenC_565 j ⊆ insert (5, 2) required_565 := by decide +kernel +theorem child_envelope_sub_565 : ∀ j, childrenD_565 j ⊆ envelope_565 := by decide +kernel +theorem pivot_mem_565 : (5, 2) ∈ envelope_565 := by decide +kernel +theorem children_work_565 : ∀ j, Template HasSnaky 6 (childrenC_565 j) (childrenD_565 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_140 3 (1, 3)).mono (by decide +kernel) + · exact row_works_565_i0.mono (by decide +kernel) + · exact row_works_565_i1.mono (by decide +kernel) +theorem row_works_565 : Template HasSnaky 7 required_565 envelope_565 := by + refine compose HasSnaky 6 childrenC_565 childrenD_565 children_work_565 (5, 2) + required_565 envelope_565 pivot_mem_565 child_required_sub_565 child_envelope_sub_565 ?_ + intro b hb + exact common_sub_565 (mem_commonEnvelope childrenD_565 b hb) +def required_576_i2 : Finset Cell := ⟨(([(4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_576_i2 : Finset Cell := ⟨(([(4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (6, 4), (7, 4), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_576_i2 : Fin 2 → Finset Cell := ![(placed21 2 (8, 4) required_0), (placed21 1 (4, 2) required_5)] +def childrenD_576_i2 : Fin 2 → Finset Cell := ![(placed21 2 (8, 4) envelope_0), (placed21 1 (4, 2) envelope_5)] +theorem common_sub_576_i2 : commonEnvelope childrenD_576_i2 ⊆ insert (5, 5) required_576_i2 := by decide +kernel +theorem child_required_sub_576_i2 : ∀ j, childrenC_576_i2 j ⊆ insert (5, 5) required_576_i2 := by decide +kernel +theorem child_envelope_sub_576_i2 : ∀ j, childrenD_576_i2 j ⊆ envelope_576_i2 := by decide +kernel +theorem pivot_mem_576_i2 : (5, 5) ∈ envelope_576_i2 := by decide +kernel +theorem children_work_576_i2 : ∀ j, Template HasSnaky 1 (childrenC_576_i2 j) (childrenD_576_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (8, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 1 (4, 2)).mono (by decide +kernel) +theorem row_works_576_i2 : Template HasSnaky 2 required_576_i2 envelope_576_i2 := by + refine compose HasSnaky 1 childrenC_576_i2 childrenD_576_i2 children_work_576_i2 (5, 5) + required_576_i2 envelope_576_i2 pivot_mem_576_i2 child_required_sub_576_i2 child_envelope_sub_576_i2 ?_ + intro b hb + exact common_sub_576_i2 (mem_commonEnvelope childrenD_576_i2 b hb) +def required_576_i3 : Finset Cell := ⟨(([(1, 2), (1, 5), (2, 2), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_576_i3 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (3, 1), (3, 2), (4, 2), (4, 3), (4, 4), (4, 5), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_576_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) required_5), (placed21 3 (0, 5) required_87)] +def childrenD_576_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) envelope_5), (placed21 3 (0, 5) envelope_87)] +theorem common_sub_576_i3 : commonEnvelope childrenD_576_i3 ⊆ insert (3, 2) required_576_i3 := by decide +kernel +theorem child_required_sub_576_i3 : ∀ j, childrenC_576_i3 j ⊆ insert (3, 2) required_576_i3 := by decide +kernel +theorem child_envelope_sub_576_i3 : ∀ j, childrenD_576_i3 j ⊆ envelope_576_i3 := by decide +kernel +theorem pivot_mem_576_i3 : (3, 2) ∈ envelope_576_i3 := by decide +kernel +theorem children_work_576_i3 : ∀ j, Template HasSnaky 3 (childrenC_576_i3 j) (childrenD_576_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_87 3 (0, 5)).mono (by decide +kernel) +theorem row_works_576_i3 : Template HasSnaky 4 required_576_i3 envelope_576_i3 := by + refine compose HasSnaky 3 childrenC_576_i3 childrenD_576_i3 children_work_576_i3 (3, 2) + required_576_i3 envelope_576_i3 pivot_mem_576_i3 child_required_sub_576_i3 child_envelope_sub_576_i3 ?_ + intro b hb + exact common_sub_576_i3 (mem_commonEnvelope childrenD_576_i3 b hb) +def required_576_i1 : Finset Cell := ⟨(([(1, 2), (1, 5), (2, 2), (4, 2), (4, 3), (4, 4), (5, 4), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_576_i1 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (3, 1), (3, 2), (4, 2), (4, 3), (4, 4), (4, 5), (5, 2), (5, 4), (5, 5), (5, 6), (6, 4), (7, 4), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_576_i1 : Fin 2 → Finset Cell := ![required_576_i2, required_576_i3] +def childrenD_576_i1 : Fin 2 → Finset Cell := ![envelope_576_i2, envelope_576_i3] +theorem common_sub_576_i1 : commonEnvelope childrenD_576_i1 ⊆ insert (4, 5) required_576_i1 := by decide +kernel +theorem child_required_sub_576_i1 : ∀ j, childrenC_576_i1 j ⊆ insert (4, 5) required_576_i1 := by decide +kernel +theorem child_envelope_sub_576_i1 : ∀ j, childrenD_576_i1 j ⊆ envelope_576_i1 := by decide +kernel +theorem pivot_mem_576_i1 : (4, 5) ∈ envelope_576_i1 := by decide +kernel +theorem children_work_576_i1 : ∀ j, Template HasSnaky 4 (childrenC_576_i1 j) (childrenD_576_i1 j) := by + intro j + fin_cases j + · exact row_works_576_i2.mono (by decide +kernel) + · exact row_works_576_i3.mono (by decide +kernel) +theorem row_works_576_i1 : Template HasSnaky 5 required_576_i1 envelope_576_i1 := by + refine compose HasSnaky 4 childrenC_576_i1 childrenD_576_i1 children_work_576_i1 (4, 5) + required_576_i1 envelope_576_i1 pivot_mem_576_i1 child_required_sub_576_i1 child_envelope_sub_576_i1 ?_ + intro b hb + exact common_sub_576_i1 (mem_commonEnvelope childrenD_576_i1 b hb) +def required_576_i4 : Finset Cell := ⟨(([(1, 2), (1, 5), (2, 2), (4, 2), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_576_i4 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_576_i4 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) required_87), (placed21 0 (1, 0) required_215)] +def childrenD_576_i4 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) envelope_87), (placed21 0 (1, 0) envelope_215)] +theorem common_sub_576_i4 : commonEnvelope childrenD_576_i4 ⊆ insert (3, 2) required_576_i4 := by decide +kernel +theorem child_required_sub_576_i4 : ∀ j, childrenC_576_i4 j ⊆ insert (3, 2) required_576_i4 := by decide +kernel +theorem child_envelope_sub_576_i4 : ∀ j, childrenD_576_i4 j ⊆ envelope_576_i4 := by decide +kernel +theorem pivot_mem_576_i4 : (3, 2) ∈ envelope_576_i4 := by decide +kernel +theorem children_work_576_i4 : ∀ j, Template HasSnaky 3 (childrenC_576_i4 j) (childrenD_576_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_87 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_215 0 (1, 0)).mono (by decide +kernel) +theorem row_works_576_i4 : Template HasSnaky 4 required_576_i4 envelope_576_i4 := by + refine compose HasSnaky 3 childrenC_576_i4 childrenD_576_i4 children_work_576_i4 (3, 2) + required_576_i4 envelope_576_i4 pivot_mem_576_i4 child_required_sub_576_i4 child_envelope_sub_576_i4 ?_ + intro b hb + exact common_sub_576_i4 (mem_commonEnvelope childrenD_576_i4 b hb) +def required_576_i0 : Finset Cell := ⟨(([(1, 2), (1, 5), (2, 2), (4, 3), (4, 4), (5, 4), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_576_i0 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (7, 4), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_576_i0 : Fin 4 → Finset Cell := ![(placed21 0 (4, 1) required_52), (placed21 6 (5, 5) required_246), required_576_i1, required_576_i4] +def childrenD_576_i0 : Fin 4 → Finset Cell := ![(placed21 0 (4, 1) envelope_52), (placed21 6 (5, 5) envelope_246), envelope_576_i1, envelope_576_i4] +theorem common_sub_576_i0 : commonEnvelope childrenD_576_i0 ⊆ insert (4, 2) required_576_i0 := by decide +kernel +theorem child_required_sub_576_i0 : ∀ j, childrenC_576_i0 j ⊆ insert (4, 2) required_576_i0 := by decide +kernel +theorem child_envelope_sub_576_i0 : ∀ j, childrenD_576_i0 j ⊆ envelope_576_i0 := by decide +kernel +theorem pivot_mem_576_i0 : (4, 2) ∈ envelope_576_i0 := by decide +kernel +theorem children_work_576_i0 : ∀ j, Template HasSnaky 5 (childrenC_576_i0 j) (childrenD_576_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 0 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_246 6 (5, 5)).mono (by decide +kernel) + · exact row_works_576_i1.mono (by decide +kernel) + · exact row_works_576_i4.mono (by decide +kernel) +theorem row_works_576_i0 : Template HasSnaky 6 required_576_i0 envelope_576_i0 := by + refine compose HasSnaky 5 childrenC_576_i0 childrenD_576_i0 children_work_576_i0 (4, 2) + required_576_i0 envelope_576_i0 pivot_mem_576_i0 child_required_sub_576_i0 child_envelope_sub_576_i0 ?_ + intro b hb + exact common_sub_576_i0 (mem_commonEnvelope childrenD_576_i0 b hb) +def required_576 : Finset Cell := ⟨(([(1, 2), (1, 5), (2, 2), (4, 4), (5, 4), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_576 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (7, 4), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_576 : Fin 2 → Finset Cell := ![(placed21 6 (7, 4) required_5), required_576_i0] +def childrenD_576 : Fin 2 → Finset Cell := ![(placed21 6 (7, 4) envelope_5), envelope_576_i0] +theorem common_sub_576 : commonEnvelope childrenD_576 ⊆ insert (4, 3) required_576 := by decide +kernel +theorem child_required_sub_576 : ∀ j, childrenC_576 j ⊆ insert (4, 3) required_576 := by decide +kernel +theorem child_envelope_sub_576 : ∀ j, childrenD_576 j ⊆ envelope_576 := by decide +kernel +theorem pivot_mem_576 : (4, 3) ∈ envelope_576 := by decide +kernel +theorem children_work_576 : ∀ j, Template HasSnaky 6 (childrenC_576 j) (childrenD_576 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (7, 4)).mono (by decide +kernel) + · exact row_works_576_i0.mono (by decide +kernel) +theorem row_works_576 : Template HasSnaky 7 required_576 envelope_576 := by + refine compose HasSnaky 6 childrenC_576 childrenD_576 children_work_576 (4, 3) + required_576 envelope_576 pivot_mem_576 child_required_sub_576 child_envelope_sub_576 ?_ + intro b hb + exact common_sub_576 (mem_commonEnvelope childrenD_576 b hb) +def height_511_i1 : ℕ := 4 +def childrenH_511_i1 : Fin 2 → ℕ := ![height_2, height_44] +theorem height_exact_511_i1 : height_511_i1 = 1 + Finset.univ.sup childrenH_511_i1 := by decide +kernel +theorem required_origin_511_i1 : ∀ x ∈ required_511_i1, + (∃ j, x ∈ childrenC_511_i1 j) ∨ ∀ j, x ∈ childrenD_511_i1 j := by decide +kernel +theorem required_exact_511_i1 : required_511_i1 = + ((Finset.univ.biUnion childrenC_511_i1) ∪ commonEnvelope childrenD_511_i1).erase (4, 4) := by + exact required_eq_combination childrenC_511_i1 childrenD_511_i1 (4, 4) required_511_i1 + (by decide +kernel) child_required_sub_511_i1 common_sub_511_i1 required_origin_511_i1 +theorem envelope_origin_511_i1 : ∀ x ∈ envelope_511_i1, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_511_i1 j := by decide +kernel +theorem envelope_exact_511_i1 : envelope_511_i1 = + insert (4, 4) (Finset.univ.biUnion childrenD_511_i1) := by + exact envelope_eq_combination childrenD_511_i1 (4, 4) envelope_511_i1 + pivot_mem_511_i1 child_envelope_sub_511_i1 envelope_origin_511_i1 +def checked_511_i1 : CheckedCard where + required := required_511_i1 + envelope := envelope_511_i1 + height := height_511_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_511_i1 +def height_511_i3 : ℕ := 4 +def childrenH_511_i3 : Fin 3 → ℕ := ![height_7, height_9, height_221] +theorem height_exact_511_i3 : height_511_i3 = 1 + Finset.univ.sup childrenH_511_i3 := by decide +kernel +theorem required_origin_511_i3 : ∀ x ∈ required_511_i3, + (∃ j, x ∈ childrenC_511_i3 j) ∨ ∀ j, x ∈ childrenD_511_i3 j := by decide +kernel +theorem required_exact_511_i3 : required_511_i3 = + ((Finset.univ.biUnion childrenC_511_i3) ∪ commonEnvelope childrenD_511_i3).erase (3, 5) := by + exact required_eq_combination childrenC_511_i3 childrenD_511_i3 (3, 5) required_511_i3 + (by decide +kernel) child_required_sub_511_i3 common_sub_511_i3 required_origin_511_i3 +theorem envelope_origin_511_i3 : ∀ x ∈ envelope_511_i3, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_511_i3 j := by decide +kernel +theorem envelope_exact_511_i3 : envelope_511_i3 = + insert (3, 5) (Finset.univ.biUnion childrenD_511_i3) := by + exact envelope_eq_combination childrenD_511_i3 (3, 5) envelope_511_i3 + pivot_mem_511_i3 child_envelope_sub_511_i3 envelope_origin_511_i3 +def checked_511_i3 : CheckedCard where + required := required_511_i3 + envelope := envelope_511_i3 + height := height_511_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_511_i3 +def height_511_i2 : ℕ := 5 +def childrenH_511_i2 : Fin 2 → ℕ := ![height_0, height_511_i3] +theorem height_exact_511_i2 : height_511_i2 = 1 + Finset.univ.sup childrenH_511_i2 := by decide +kernel +theorem required_origin_511_i2 : ∀ x ∈ required_511_i2, + (∃ j, x ∈ childrenC_511_i2 j) ∨ ∀ j, x ∈ childrenD_511_i2 j := by decide +kernel +theorem required_exact_511_i2 : required_511_i2 = + ((Finset.univ.biUnion childrenC_511_i2) ∪ commonEnvelope childrenD_511_i2).erase (2, 4) := by + exact required_eq_combination childrenC_511_i2 childrenD_511_i2 (2, 4) required_511_i2 + (by decide +kernel) child_required_sub_511_i2 common_sub_511_i2 required_origin_511_i2 +theorem envelope_origin_511_i2 : ∀ x ∈ envelope_511_i2, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_511_i2 j := by decide +kernel +theorem envelope_exact_511_i2 : envelope_511_i2 = + insert (2, 4) (Finset.univ.biUnion childrenD_511_i2) := by + exact envelope_eq_combination childrenD_511_i2 (2, 4) envelope_511_i2 + pivot_mem_511_i2 child_envelope_sub_511_i2 envelope_origin_511_i2 +def checked_511_i2 : CheckedCard where + required := required_511_i2 + envelope := envelope_511_i2 + height := height_511_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_511_i2 +def height_511_i0 : ℕ := 6 +def childrenH_511_i0 : Fin 5 → ℕ := ![height_13, height_14, height_240, height_511_i1, height_511_i2] +theorem height_exact_511_i0 : height_511_i0 = 1 + Finset.univ.sup childrenH_511_i0 := by decide +kernel +theorem required_origin_511_i0 : ∀ x ∈ required_511_i0, + (∃ j, x ∈ childrenC_511_i0 j) ∨ ∀ j, x ∈ childrenD_511_i0 j := by decide +kernel +theorem required_exact_511_i0 : required_511_i0 = + ((Finset.univ.biUnion childrenC_511_i0) ∪ commonEnvelope childrenD_511_i0).erase (3, 4) := by + exact required_eq_combination childrenC_511_i0 childrenD_511_i0 (3, 4) required_511_i0 + (by decide +kernel) child_required_sub_511_i0 common_sub_511_i0 required_origin_511_i0 +theorem envelope_origin_511_i0 : ∀ x ∈ envelope_511_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_511_i0 j := by decide +kernel +theorem envelope_exact_511_i0 : envelope_511_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_511_i0) := by + exact envelope_eq_combination childrenD_511_i0 (3, 4) envelope_511_i0 + pivot_mem_511_i0 child_envelope_sub_511_i0 envelope_origin_511_i0 +def checked_511_i0 : CheckedCard where + required := required_511_i0 + envelope := envelope_511_i0 + height := height_511_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_511_i0 +def height_511 : ℕ := 7 +def childrenH_511 : Fin 2 → ℕ := ![height_15, height_511_i0] +theorem height_exact_511 : height_511 = 1 + Finset.univ.sup childrenH_511 := by decide +kernel +theorem required_origin_511 : ∀ x ∈ required_511, + (∃ j, x ∈ childrenC_511 j) ∨ ∀ j, x ∈ childrenD_511 j := by decide +kernel +theorem required_exact_511 : required_511 = + ((Finset.univ.biUnion childrenC_511) ∪ commonEnvelope childrenD_511).erase (1, 4) := by + exact required_eq_combination childrenC_511 childrenD_511 (1, 4) required_511 + (by decide +kernel) child_required_sub_511 common_sub_511 required_origin_511 +theorem envelope_origin_511 : ∀ x ∈ envelope_511, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_511 j := by decide +kernel +theorem envelope_exact_511 : envelope_511 = + insert (1, 4) (Finset.univ.biUnion childrenD_511) := by + exact envelope_eq_combination childrenD_511 (1, 4) envelope_511 + pivot_mem_511 child_envelope_sub_511 envelope_origin_511 +def checked_511 : CheckedCard where + required := required_511 + envelope := envelope_511 + height := height_511 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_511 +def height_522_i0 : ℕ := 6 +def childrenH_522_i0 : Fin 2 → ℕ := ![height_5, height_416] +theorem height_exact_522_i0 : height_522_i0 = 1 + Finset.univ.sup childrenH_522_i0 := by decide +kernel +theorem required_origin_522_i0 : ∀ x ∈ required_522_i0, + (∃ j, x ∈ childrenC_522_i0 j) ∨ ∀ j, x ∈ childrenD_522_i0 j := by decide +kernel +theorem required_exact_522_i0 : required_522_i0 = + ((Finset.univ.biUnion childrenC_522_i0) ∪ commonEnvelope childrenD_522_i0).erase (1, 3) := by + exact required_eq_combination childrenC_522_i0 childrenD_522_i0 (1, 3) required_522_i0 + (by decide +kernel) child_required_sub_522_i0 common_sub_522_i0 required_origin_522_i0 +theorem envelope_origin_522_i0 : ∀ x ∈ envelope_522_i0, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_522_i0 j := by decide +kernel +theorem envelope_exact_522_i0 : envelope_522_i0 = + insert (1, 3) (Finset.univ.biUnion childrenD_522_i0) := by + exact envelope_eq_combination childrenD_522_i0 (1, 3) envelope_522_i0 + pivot_mem_522_i0 child_envelope_sub_522_i0 envelope_origin_522_i0 +def checked_522_i0 : CheckedCard where + required := required_522_i0 + envelope := envelope_522_i0 + height := height_522_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_522_i0 +def height_522 : ℕ := 7 +def childrenH_522 : Fin 3 → ℕ := ![height_8, height_11, height_522_i0] +theorem height_exact_522 : height_522 = 1 + Finset.univ.sup childrenH_522 := by decide +kernel +theorem required_origin_522 : ∀ x ∈ required_522, + (∃ j, x ∈ childrenC_522 j) ∨ ∀ j, x ∈ childrenD_522 j := by decide +kernel +theorem required_exact_522 : required_522 = + ((Finset.univ.biUnion childrenC_522) ∪ commonEnvelope childrenD_522).erase (4, 2) := by + exact required_eq_combination childrenC_522 childrenD_522 (4, 2) required_522 + (by decide +kernel) child_required_sub_522 common_sub_522 required_origin_522 +theorem envelope_origin_522 : ∀ x ∈ envelope_522, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_522 j := by decide +kernel +theorem envelope_exact_522 : envelope_522 = + insert (4, 2) (Finset.univ.biUnion childrenD_522) := by + exact envelope_eq_combination childrenD_522 (4, 2) envelope_522 + pivot_mem_522 child_envelope_sub_522 envelope_origin_522 +def checked_522 : CheckedCard where + required := required_522 + envelope := envelope_522 + height := height_522 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_522 +def height_526 : ℕ := 7 +def childrenH_526 : Fin 2 → ℕ := ![height_0, height_525] +theorem height_exact_526 : height_526 = 1 + Finset.univ.sup childrenH_526 := by decide +kernel +theorem required_origin_526 : ∀ x ∈ required_526, + (∃ j, x ∈ childrenC_526 j) ∨ ∀ j, x ∈ childrenD_526 j := by decide +kernel +theorem required_exact_526 : required_526 = + ((Finset.univ.biUnion childrenC_526) ∪ commonEnvelope childrenD_526).erase (3, 1) := by + exact required_eq_combination childrenC_526 childrenD_526 (3, 1) required_526 + (by decide +kernel) child_required_sub_526 common_sub_526 required_origin_526 +theorem envelope_origin_526 : ∀ x ∈ envelope_526, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_526 j := by decide +kernel +theorem envelope_exact_526 : envelope_526 = + insert (3, 1) (Finset.univ.biUnion childrenD_526) := by + exact envelope_eq_combination childrenD_526 (3, 1) envelope_526 + pivot_mem_526 child_envelope_sub_526 envelope_origin_526 +def checked_526 : CheckedCard where + required := required_526 + envelope := envelope_526 + height := height_526 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_526 +def height_542_i3 : ℕ := 2 +def childrenH_542_i3 : Fin 2 → ℕ := ![height_0, height_1] +theorem height_exact_542_i3 : height_542_i3 = 1 + Finset.univ.sup childrenH_542_i3 := by decide +kernel +theorem required_origin_542_i3 : ∀ x ∈ required_542_i3, + (∃ j, x ∈ childrenC_542_i3 j) ∨ ∀ j, x ∈ childrenD_542_i3 j := by decide +kernel +theorem required_exact_542_i3 : required_542_i3 = + ((Finset.univ.biUnion childrenC_542_i3) ∪ commonEnvelope childrenD_542_i3).erase (5, 2) := by + exact required_eq_combination childrenC_542_i3 childrenD_542_i3 (5, 2) required_542_i3 + (by decide +kernel) child_required_sub_542_i3 common_sub_542_i3 required_origin_542_i3 +theorem envelope_origin_542_i3 : ∀ x ∈ envelope_542_i3, + x = (5, 2) ∨ ∃ j, x ∈ childrenD_542_i3 j := by decide +kernel +theorem envelope_exact_542_i3 : envelope_542_i3 = + insert (5, 2) (Finset.univ.biUnion childrenD_542_i3) := by + exact envelope_eq_combination childrenD_542_i3 (5, 2) envelope_542_i3 + pivot_mem_542_i3 child_envelope_sub_542_i3 envelope_origin_542_i3 +def checked_542_i3 : CheckedCard where + required := required_542_i3 + envelope := envelope_542_i3 + height := height_542_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_542_i3 +def height_542_i2 : ℕ := 4 +def childrenH_542_i2 : Fin 2 → ℕ := ![height_29, height_542_i3] +theorem height_exact_542_i2 : height_542_i2 = 1 + Finset.univ.sup childrenH_542_i2 := by decide +kernel +theorem required_origin_542_i2 : ∀ x ∈ required_542_i2, + (∃ j, x ∈ childrenC_542_i2 j) ∨ ∀ j, x ∈ childrenD_542_i2 j := by decide +kernel +theorem required_exact_542_i2 : required_542_i2 = + ((Finset.univ.biUnion childrenC_542_i2) ∪ commonEnvelope childrenD_542_i2).erase (4, 3) := by + exact required_eq_combination childrenC_542_i2 childrenD_542_i2 (4, 3) required_542_i2 + (by decide +kernel) child_required_sub_542_i2 common_sub_542_i2 required_origin_542_i2 +theorem envelope_origin_542_i2 : ∀ x ∈ envelope_542_i2, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_542_i2 j := by decide +kernel +theorem envelope_exact_542_i2 : envelope_542_i2 = + insert (4, 3) (Finset.univ.biUnion childrenD_542_i2) := by + exact envelope_eq_combination childrenD_542_i2 (4, 3) envelope_542_i2 + pivot_mem_542_i2 child_envelope_sub_542_i2 envelope_origin_542_i2 +def checked_542_i2 : CheckedCard where + required := required_542_i2 + envelope := envelope_542_i2 + height := height_542_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_542_i2 +def height_542_i1 : ℕ := 5 +def childrenH_542_i1 : Fin 2 → ℕ := ![height_1, height_542_i2] +theorem height_exact_542_i1 : height_542_i1 = 1 + Finset.univ.sup childrenH_542_i1 := by decide +kernel +theorem required_origin_542_i1 : ∀ x ∈ required_542_i1, + (∃ j, x ∈ childrenC_542_i1 j) ∨ ∀ j, x ∈ childrenD_542_i1 j := by decide +kernel +theorem required_exact_542_i1 : required_542_i1 = + ((Finset.univ.biUnion childrenC_542_i1) ∪ commonEnvelope childrenD_542_i1).erase (4, 2) := by + exact required_eq_combination childrenC_542_i1 childrenD_542_i1 (4, 2) required_542_i1 + (by decide +kernel) child_required_sub_542_i1 common_sub_542_i1 required_origin_542_i1 +theorem envelope_origin_542_i1 : ∀ x ∈ envelope_542_i1, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_542_i1 j := by decide +kernel +theorem envelope_exact_542_i1 : envelope_542_i1 = + insert (4, 2) (Finset.univ.biUnion childrenD_542_i1) := by + exact envelope_eq_combination childrenD_542_i1 (4, 2) envelope_542_i1 + pivot_mem_542_i1 child_envelope_sub_542_i1 envelope_origin_542_i1 +def checked_542_i1 : CheckedCard where + required := required_542_i1 + envelope := envelope_542_i1 + height := height_542_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_542_i1 +def height_542_i0 : ℕ := 6 +def childrenH_542_i0 : Fin 2 → ℕ := ![height_5, height_542_i1] +theorem height_exact_542_i0 : height_542_i0 = 1 + Finset.univ.sup childrenH_542_i0 := by decide +kernel +theorem required_origin_542_i0 : ∀ x ∈ required_542_i0, + (∃ j, x ∈ childrenC_542_i0 j) ∨ ∀ j, x ∈ childrenD_542_i0 j := by decide +kernel +theorem required_exact_542_i0 : required_542_i0 = + ((Finset.univ.biUnion childrenC_542_i0) ∪ commonEnvelope childrenD_542_i0).erase (2, 1) := by + exact required_eq_combination childrenC_542_i0 childrenD_542_i0 (2, 1) required_542_i0 + (by decide +kernel) child_required_sub_542_i0 common_sub_542_i0 required_origin_542_i0 +theorem envelope_origin_542_i0 : ∀ x ∈ envelope_542_i0, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_542_i0 j := by decide +kernel +theorem envelope_exact_542_i0 : envelope_542_i0 = + insert (2, 1) (Finset.univ.biUnion childrenD_542_i0) := by + exact envelope_eq_combination childrenD_542_i0 (2, 1) envelope_542_i0 + pivot_mem_542_i0 child_envelope_sub_542_i0 envelope_origin_542_i0 +def checked_542_i0 : CheckedCard where + required := required_542_i0 + envelope := envelope_542_i0 + height := height_542_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_542_i0 +def height_542 : ℕ := 7 +def childrenH_542 : Fin 2 → ℕ := ![height_3, height_542_i0] +theorem height_exact_542 : height_542 = 1 + Finset.univ.sup childrenH_542 := by decide +kernel +theorem required_origin_542 : ∀ x ∈ required_542, + (∃ j, x ∈ childrenC_542 j) ∨ ∀ j, x ∈ childrenD_542 j := by decide +kernel +theorem required_exact_542 : required_542 = + ((Finset.univ.biUnion childrenC_542) ∪ commonEnvelope childrenD_542).erase (1, 3) := by + exact required_eq_combination childrenC_542 childrenD_542 (1, 3) required_542 + (by decide +kernel) child_required_sub_542 common_sub_542 required_origin_542 +theorem envelope_origin_542 : ∀ x ∈ envelope_542, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_542 j := by decide +kernel +theorem envelope_exact_542 : envelope_542 = + insert (1, 3) (Finset.univ.biUnion childrenD_542) := by + exact envelope_eq_combination childrenD_542 (1, 3) envelope_542 + pivot_mem_542 child_envelope_sub_542 envelope_origin_542 +def checked_542 : CheckedCard where + required := required_542 + envelope := envelope_542 + height := height_542 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_542 +def height_554_i0 : ℕ := 6 +def childrenH_554_i0 : Fin 2 → ℕ := ![height_0, height_515] +theorem height_exact_554_i0 : height_554_i0 = 1 + Finset.univ.sup childrenH_554_i0 := by decide +kernel +theorem required_origin_554_i0 : ∀ x ∈ required_554_i0, + (∃ j, x ∈ childrenC_554_i0 j) ∨ ∀ j, x ∈ childrenD_554_i0 j := by decide +kernel +theorem required_exact_554_i0 : required_554_i0 = + ((Finset.univ.biUnion childrenC_554_i0) ∪ commonEnvelope childrenD_554_i0).erase (1, 3) := by + exact required_eq_combination childrenC_554_i0 childrenD_554_i0 (1, 3) required_554_i0 + (by decide +kernel) child_required_sub_554_i0 common_sub_554_i0 required_origin_554_i0 +theorem envelope_origin_554_i0 : ∀ x ∈ envelope_554_i0, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_554_i0 j := by decide +kernel +theorem envelope_exact_554_i0 : envelope_554_i0 = + insert (1, 3) (Finset.univ.biUnion childrenD_554_i0) := by + exact envelope_eq_combination childrenD_554_i0 (1, 3) envelope_554_i0 + pivot_mem_554_i0 child_envelope_sub_554_i0 envelope_origin_554_i0 +def checked_554_i0 : CheckedCard where + required := required_554_i0 + envelope := envelope_554_i0 + height := height_554_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_554_i0 +def height_554 : ℕ := 7 +def childrenH_554 : Fin 2 → ℕ := ![height_5, height_554_i0] +theorem height_exact_554 : height_554 = 1 + Finset.univ.sup childrenH_554 := by decide +kernel +theorem required_origin_554 : ∀ x ∈ required_554, + (∃ j, x ∈ childrenC_554 j) ∨ ∀ j, x ∈ childrenD_554 j := by decide +kernel +theorem required_exact_554 : required_554 = + ((Finset.univ.biUnion childrenC_554) ∪ commonEnvelope childrenD_554).erase (1, 4) := by + exact required_eq_combination childrenC_554 childrenD_554 (1, 4) required_554 + (by decide +kernel) child_required_sub_554 common_sub_554 required_origin_554 +theorem envelope_origin_554 : ∀ x ∈ envelope_554, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_554 j := by decide +kernel +theorem envelope_exact_554 : envelope_554 = + insert (1, 4) (Finset.univ.biUnion childrenD_554) := by + exact envelope_eq_combination childrenD_554 (1, 4) envelope_554 + pivot_mem_554 child_envelope_sub_554 envelope_origin_554 +def checked_554 : CheckedCard where + required := required_554 + envelope := envelope_554 + height := height_554 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_554 +def height_565_i0 : ℕ := 6 +def childrenH_565_i0 : Fin 2 → ℕ := ![height_5, height_179] +theorem height_exact_565_i0 : height_565_i0 = 1 + Finset.univ.sup childrenH_565_i0 := by decide +kernel +theorem required_origin_565_i0 : ∀ x ∈ required_565_i0, + (∃ j, x ∈ childrenC_565_i0 j) ∨ ∀ j, x ∈ childrenD_565_i0 j := by decide +kernel +theorem required_exact_565_i0 : required_565_i0 = + ((Finset.univ.biUnion childrenC_565_i0) ∪ commonEnvelope childrenD_565_i0).erase (5, 3) := by + exact required_eq_combination childrenC_565_i0 childrenD_565_i0 (5, 3) required_565_i0 + (by decide +kernel) child_required_sub_565_i0 common_sub_565_i0 required_origin_565_i0 +theorem envelope_origin_565_i0 : ∀ x ∈ envelope_565_i0, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_565_i0 j := by decide +kernel +theorem envelope_exact_565_i0 : envelope_565_i0 = + insert (5, 3) (Finset.univ.biUnion childrenD_565_i0) := by + exact envelope_eq_combination childrenD_565_i0 (5, 3) envelope_565_i0 + pivot_mem_565_i0 child_envelope_sub_565_i0 envelope_origin_565_i0 +def checked_565_i0 : CheckedCard where + required := required_565_i0 + envelope := envelope_565_i0 + height := height_565_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_565_i0 +def height_565_i1 : ℕ := 6 +def childrenH_565_i1 : Fin 2 → ℕ := ![height_4, height_142] +theorem height_exact_565_i1 : height_565_i1 = 1 + Finset.univ.sup childrenH_565_i1 := by decide +kernel +theorem required_origin_565_i1 : ∀ x ∈ required_565_i1, + (∃ j, x ∈ childrenC_565_i1 j) ∨ ∀ j, x ∈ childrenD_565_i1 j := by decide +kernel +theorem required_exact_565_i1 : required_565_i1 = + ((Finset.univ.biUnion childrenC_565_i1) ∪ commonEnvelope childrenD_565_i1).erase (1, 3) := by + exact required_eq_combination childrenC_565_i1 childrenD_565_i1 (1, 3) required_565_i1 + (by decide +kernel) child_required_sub_565_i1 common_sub_565_i1 required_origin_565_i1 +theorem envelope_origin_565_i1 : ∀ x ∈ envelope_565_i1, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_565_i1 j := by decide +kernel +theorem envelope_exact_565_i1 : envelope_565_i1 = + insert (1, 3) (Finset.univ.biUnion childrenD_565_i1) := by + exact envelope_eq_combination childrenD_565_i1 (1, 3) envelope_565_i1 + pivot_mem_565_i1 child_envelope_sub_565_i1 envelope_origin_565_i1 +def checked_565_i1 : CheckedCard where + required := required_565_i1 + envelope := envelope_565_i1 + height := height_565_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_565_i1 +def height_565 : ℕ := 7 +def childrenH_565 : Fin 3 → ℕ := ![height_140, height_565_i0, height_565_i1] +theorem height_exact_565 : height_565 = 1 + Finset.univ.sup childrenH_565 := by decide +kernel +theorem required_origin_565 : ∀ x ∈ required_565, + (∃ j, x ∈ childrenC_565 j) ∨ ∀ j, x ∈ childrenD_565 j := by decide +kernel +theorem required_exact_565 : required_565 = + ((Finset.univ.biUnion childrenC_565) ∪ commonEnvelope childrenD_565).erase (5, 2) := by + exact required_eq_combination childrenC_565 childrenD_565 (5, 2) required_565 + (by decide +kernel) child_required_sub_565 common_sub_565 required_origin_565 +theorem envelope_origin_565 : ∀ x ∈ envelope_565, + x = (5, 2) ∨ ∃ j, x ∈ childrenD_565 j := by decide +kernel +theorem envelope_exact_565 : envelope_565 = + insert (5, 2) (Finset.univ.biUnion childrenD_565) := by + exact envelope_eq_combination childrenD_565 (5, 2) envelope_565 + pivot_mem_565 child_envelope_sub_565 envelope_origin_565 +def checked_565 : CheckedCard where + required := required_565 + envelope := envelope_565 + height := height_565 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_565 +def height_576_i2 : ℕ := 2 +def childrenH_576_i2 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_576_i2 : height_576_i2 = 1 + Finset.univ.sup childrenH_576_i2 := by decide +kernel +theorem required_origin_576_i2 : ∀ x ∈ required_576_i2, + (∃ j, x ∈ childrenC_576_i2 j) ∨ ∀ j, x ∈ childrenD_576_i2 j := by decide +kernel +theorem required_exact_576_i2 : required_576_i2 = + ((Finset.univ.biUnion childrenC_576_i2) ∪ commonEnvelope childrenD_576_i2).erase (5, 5) := by + exact required_eq_combination childrenC_576_i2 childrenD_576_i2 (5, 5) required_576_i2 + (by decide +kernel) child_required_sub_576_i2 common_sub_576_i2 required_origin_576_i2 +theorem envelope_origin_576_i2 : ∀ x ∈ envelope_576_i2, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_576_i2 j := by decide +kernel +theorem envelope_exact_576_i2 : envelope_576_i2 = + insert (5, 5) (Finset.univ.biUnion childrenD_576_i2) := by + exact envelope_eq_combination childrenD_576_i2 (5, 5) envelope_576_i2 + pivot_mem_576_i2 child_envelope_sub_576_i2 envelope_origin_576_i2 +def checked_576_i2 : CheckedCard where + required := required_576_i2 + envelope := envelope_576_i2 + height := height_576_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_576_i2 +def height_576_i3 : ℕ := 4 +def childrenH_576_i3 : Fin 2 → ℕ := ![height_5, height_87] +theorem height_exact_576_i3 : height_576_i3 = 1 + Finset.univ.sup childrenH_576_i3 := by decide +kernel +theorem required_origin_576_i3 : ∀ x ∈ required_576_i3, + (∃ j, x ∈ childrenC_576_i3 j) ∨ ∀ j, x ∈ childrenD_576_i3 j := by decide +kernel +theorem required_exact_576_i3 : required_576_i3 = + ((Finset.univ.biUnion childrenC_576_i3) ∪ commonEnvelope childrenD_576_i3).erase (3, 2) := by + exact required_eq_combination childrenC_576_i3 childrenD_576_i3 (3, 2) required_576_i3 + (by decide +kernel) child_required_sub_576_i3 common_sub_576_i3 required_origin_576_i3 +theorem envelope_origin_576_i3 : ∀ x ∈ envelope_576_i3, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_576_i3 j := by decide +kernel +theorem envelope_exact_576_i3 : envelope_576_i3 = + insert (3, 2) (Finset.univ.biUnion childrenD_576_i3) := by + exact envelope_eq_combination childrenD_576_i3 (3, 2) envelope_576_i3 + pivot_mem_576_i3 child_envelope_sub_576_i3 envelope_origin_576_i3 +def checked_576_i3 : CheckedCard where + required := required_576_i3 + envelope := envelope_576_i3 + height := height_576_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_576_i3 +def height_576_i1 : ℕ := 5 +def childrenH_576_i1 : Fin 2 → ℕ := ![height_576_i2, height_576_i3] +theorem height_exact_576_i1 : height_576_i1 = 1 + Finset.univ.sup childrenH_576_i1 := by decide +kernel +theorem required_origin_576_i1 : ∀ x ∈ required_576_i1, + (∃ j, x ∈ childrenC_576_i1 j) ∨ ∀ j, x ∈ childrenD_576_i1 j := by decide +kernel +theorem required_exact_576_i1 : required_576_i1 = + ((Finset.univ.biUnion childrenC_576_i1) ∪ commonEnvelope childrenD_576_i1).erase (4, 5) := by + exact required_eq_combination childrenC_576_i1 childrenD_576_i1 (4, 5) required_576_i1 + (by decide +kernel) child_required_sub_576_i1 common_sub_576_i1 required_origin_576_i1 +theorem envelope_origin_576_i1 : ∀ x ∈ envelope_576_i1, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_576_i1 j := by decide +kernel +theorem envelope_exact_576_i1 : envelope_576_i1 = + insert (4, 5) (Finset.univ.biUnion childrenD_576_i1) := by + exact envelope_eq_combination childrenD_576_i1 (4, 5) envelope_576_i1 + pivot_mem_576_i1 child_envelope_sub_576_i1 envelope_origin_576_i1 +def checked_576_i1 : CheckedCard where + required := required_576_i1 + envelope := envelope_576_i1 + height := height_576_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_576_i1 +def height_576_i4 : ℕ := 4 +def childrenH_576_i4 : Fin 2 → ℕ := ![height_87, height_215] +theorem height_exact_576_i4 : height_576_i4 = 1 + Finset.univ.sup childrenH_576_i4 := by decide +kernel +theorem required_origin_576_i4 : ∀ x ∈ required_576_i4, + (∃ j, x ∈ childrenC_576_i4 j) ∨ ∀ j, x ∈ childrenD_576_i4 j := by decide +kernel +theorem required_exact_576_i4 : required_576_i4 = + ((Finset.univ.biUnion childrenC_576_i4) ∪ commonEnvelope childrenD_576_i4).erase (3, 2) := by + exact required_eq_combination childrenC_576_i4 childrenD_576_i4 (3, 2) required_576_i4 + (by decide +kernel) child_required_sub_576_i4 common_sub_576_i4 required_origin_576_i4 +theorem envelope_origin_576_i4 : ∀ x ∈ envelope_576_i4, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_576_i4 j := by decide +kernel +theorem envelope_exact_576_i4 : envelope_576_i4 = + insert (3, 2) (Finset.univ.biUnion childrenD_576_i4) := by + exact envelope_eq_combination childrenD_576_i4 (3, 2) envelope_576_i4 + pivot_mem_576_i4 child_envelope_sub_576_i4 envelope_origin_576_i4 +def checked_576_i4 : CheckedCard where + required := required_576_i4 + envelope := envelope_576_i4 + height := height_576_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_576_i4 +def height_576_i0 : ℕ := 6 +def childrenH_576_i0 : Fin 4 → ℕ := ![height_52, height_246, height_576_i1, height_576_i4] +theorem height_exact_576_i0 : height_576_i0 = 1 + Finset.univ.sup childrenH_576_i0 := by decide +kernel +theorem required_origin_576_i0 : ∀ x ∈ required_576_i0, + (∃ j, x ∈ childrenC_576_i0 j) ∨ ∀ j, x ∈ childrenD_576_i0 j := by decide +kernel +theorem required_exact_576_i0 : required_576_i0 = + ((Finset.univ.biUnion childrenC_576_i0) ∪ commonEnvelope childrenD_576_i0).erase (4, 2) := by + exact required_eq_combination childrenC_576_i0 childrenD_576_i0 (4, 2) required_576_i0 + (by decide +kernel) child_required_sub_576_i0 common_sub_576_i0 required_origin_576_i0 +theorem envelope_origin_576_i0 : ∀ x ∈ envelope_576_i0, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_576_i0 j := by decide +kernel +theorem envelope_exact_576_i0 : envelope_576_i0 = + insert (4, 2) (Finset.univ.biUnion childrenD_576_i0) := by + exact envelope_eq_combination childrenD_576_i0 (4, 2) envelope_576_i0 + pivot_mem_576_i0 child_envelope_sub_576_i0 envelope_origin_576_i0 +def checked_576_i0 : CheckedCard where + required := required_576_i0 + envelope := envelope_576_i0 + height := height_576_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_576_i0 +def height_576 : ℕ := 7 +def childrenH_576 : Fin 2 → ℕ := ![height_5, height_576_i0] +theorem height_exact_576 : height_576 = 1 + Finset.univ.sup childrenH_576 := by decide +kernel +theorem required_origin_576 : ∀ x ∈ required_576, + (∃ j, x ∈ childrenC_576 j) ∨ ∀ j, x ∈ childrenD_576 j := by decide +kernel +theorem required_exact_576 : required_576 = + ((Finset.univ.biUnion childrenC_576) ∪ commonEnvelope childrenD_576).erase (4, 3) := by + exact required_eq_combination childrenC_576 childrenD_576 (4, 3) required_576 + (by decide +kernel) child_required_sub_576 common_sub_576 required_origin_576 +theorem envelope_origin_576 : ∀ x ∈ envelope_576, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_576 j := by decide +kernel +theorem envelope_exact_576 : envelope_576 = + insert (4, 3) (Finset.univ.biUnion childrenD_576) := by + exact envelope_eq_combination childrenD_576 (4, 3) envelope_576 + pivot_mem_576 child_envelope_sub_576 envelope_origin_576 +def checked_576 : CheckedCard where + required := required_576 + envelope := envelope_576 + height := height_576 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_576 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part05.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part05.lean new file mode 100644 index 0000000..0e9bab1 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part05.lean @@ -0,0 +1,991 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_593_i0 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_593_i0 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_593_i0 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) required_36), (placed21 0 (3, 1) required_105), (placed21 4 (3, 6) required_250), (placed21 4 (3, 6) required_592)] +def childrenD_593_i0 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) envelope_36), (placed21 0 (3, 1) envelope_105), (placed21 4 (3, 6) envelope_250), (placed21 4 (3, 6) envelope_592)] +theorem common_sub_593_i0 : commonEnvelope childrenD_593_i0 ⊆ insert (4, 5) required_593_i0 := by decide +kernel +theorem child_required_sub_593_i0 : ∀ j, childrenC_593_i0 j ⊆ insert (4, 5) required_593_i0 := by decide +kernel +theorem child_envelope_sub_593_i0 : ∀ j, childrenD_593_i0 j ⊆ envelope_593_i0 := by decide +kernel +theorem pivot_mem_593_i0 : (4, 5) ∈ envelope_593_i0 := by decide +kernel +theorem children_work_593_i0 : ∀ j, Template HasSnaky 5 (childrenC_593_i0 j) (childrenD_593_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_36 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_105 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_250 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_592 4 (3, 6)).mono (by decide +kernel) +theorem row_works_593_i0 : Template HasSnaky 6 required_593_i0 envelope_593_i0 := by + refine compose HasSnaky 5 childrenC_593_i0 childrenD_593_i0 children_work_593_i0 (4, 5) + required_593_i0 envelope_593_i0 pivot_mem_593_i0 child_required_sub_593_i0 child_envelope_sub_593_i0 ?_ + intro b hb + exact common_sub_593_i0 (mem_commonEnvelope childrenD_593_i0 b hb) +def required_593 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 2), (3, 3), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_593 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_593 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_2), required_593_i0] +def childrenD_593 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_2), envelope_593_i0] +theorem common_sub_593 : commonEnvelope childrenD_593 ⊆ insert (4, 3) required_593 := by decide +kernel +theorem child_required_sub_593 : ∀ j, childrenC_593 j ⊆ insert (4, 3) required_593 := by decide +kernel +theorem child_envelope_sub_593 : ∀ j, childrenD_593 j ⊆ envelope_593 := by decide +kernel +theorem pivot_mem_593 : (4, 3) ∈ envelope_593 := by decide +kernel +theorem children_work_593 : ∀ j, Template HasSnaky 6 (childrenC_593 j) (childrenD_593 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 2)).mono (by decide +kernel) + · exact row_works_593_i0.mono (by decide +kernel) +theorem row_works_593 : Template HasSnaky 7 required_593 envelope_593 := by + refine compose HasSnaky 6 childrenC_593 childrenD_593 children_work_593 (4, 3) + required_593 envelope_593 pivot_mem_593 child_required_sub_593 child_envelope_sub_593 ?_ + intro b hb + exact common_sub_593 (mem_commonEnvelope childrenD_593 b hb) +def required_610 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_610 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 6), (0, 7), (0, 8), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (5, 5), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_610 : Fin 4 → Finset Cell := ![(placed21 0 (0, 1) required_19), (placed21 5 (2, 2) required_197), (placed21 0 (0, 1) required_225), (placed21 4 (0, 6) required_609)] +def childrenD_610 : Fin 4 → Finset Cell := ![(placed21 0 (0, 1) envelope_19), (placed21 5 (2, 2) envelope_197), (placed21 0 (0, 1) envelope_225), (placed21 4 (0, 6) envelope_609)] +theorem common_sub_610 : commonEnvelope childrenD_610 ⊆ insert (1, 5) required_610 := by decide +kernel +theorem child_required_sub_610 : ∀ j, childrenC_610 j ⊆ insert (1, 5) required_610 := by decide +kernel +theorem child_envelope_sub_610 : ∀ j, childrenD_610 j ⊆ envelope_610 := by decide +kernel +theorem pivot_mem_610 : (1, 5) ∈ envelope_610 := by decide +kernel +theorem children_work_610 : ∀ j, Template HasSnaky 6 (childrenC_610 j) (childrenD_610 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_197 5 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_225 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_609 4 (0, 6)).mono (by decide +kernel) +theorem row_works_610 : Template HasSnaky 7 required_610 envelope_610 := by + refine compose HasSnaky 6 childrenC_610 childrenD_610 children_work_610 (1, 5) + required_610 envelope_610 pivot_mem_610 child_required_sub_610 child_envelope_sub_610 ?_ + intro b hb + exact common_sub_610 (mem_commonEnvelope childrenD_610 b hb) +def required_620_i0 : Finset Cell := ⟨(([(3, 4), (3, 5), (3, 6), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_620_i0 : Finset Cell := ⟨(([(2, 1), (2, 2), (2, 3), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 8), (4, 9), (4, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_620_i0 : Fin 3 → Finset Cell := ![(placed21 6 (4, 6) required_17), (placed21 6 (4, 6) required_37), (placed21 5 (4, 3) required_233)] +def childrenD_620_i0 : Fin 3 → Finset Cell := ![(placed21 6 (4, 6) envelope_17), (placed21 6 (4, 6) envelope_37), (placed21 5 (4, 3) envelope_233)] +theorem common_sub_620_i0 : commonEnvelope childrenD_620_i0 ⊆ insert (3, 3) required_620_i0 := by decide +kernel +theorem child_required_sub_620_i0 : ∀ j, childrenC_620_i0 j ⊆ insert (3, 3) required_620_i0 := by decide +kernel +theorem child_envelope_sub_620_i0 : ∀ j, childrenD_620_i0 j ⊆ envelope_620_i0 := by decide +kernel +theorem pivot_mem_620_i0 : (3, 3) ∈ envelope_620_i0 := by decide +kernel +theorem children_work_620_i0 : ∀ j, Template HasSnaky 5 (childrenC_620_i0 j) (childrenD_620_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_17 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_37 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_233 5 (4, 3)).mono (by decide +kernel) +theorem row_works_620_i0 : Template HasSnaky 6 required_620_i0 envelope_620_i0 := by + refine compose HasSnaky 5 childrenC_620_i0 childrenD_620_i0 children_work_620_i0 (3, 3) + required_620_i0 envelope_620_i0 pivot_mem_620_i0 child_required_sub_620_i0 child_envelope_sub_620_i0 ?_ + intro b hb + exact common_sub_620_i0 (mem_commonEnvelope childrenD_620_i0 b hb) +def required_620 : Finset Cell := ⟨(([(3, 4), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_620 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 6), (2, 1), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 8), (4, 9), (4, 10), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_620 : Fin 5 → Finset Cell := ![(placed21 5 (6, 3) required_57), (placed21 7 (6, 7) required_57), (placed21 5 (6, 3) required_293), (placed21 7 (6, 7) required_293), required_620_i0] +def childrenD_620 : Fin 5 → Finset Cell := ![(placed21 5 (6, 3) envelope_57), (placed21 7 (6, 7) envelope_57), (placed21 5 (6, 3) envelope_293), (placed21 7 (6, 7) envelope_293), envelope_620_i0] +theorem common_sub_620 : commonEnvelope childrenD_620 ⊆ insert (4, 5) required_620 := by decide +kernel +theorem child_required_sub_620 : ∀ j, childrenC_620 j ⊆ insert (4, 5) required_620 := by decide +kernel +theorem child_envelope_sub_620 : ∀ j, childrenD_620 j ⊆ envelope_620 := by decide +kernel +theorem pivot_mem_620 : (4, 5) ∈ envelope_620 := by decide +kernel +theorem children_work_620 : ∀ j, Template HasSnaky 6 (childrenC_620 j) (childrenD_620 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_57 5 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_57 7 (6, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_293 5 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_293 7 (6, 7)).mono (by decide +kernel) + · exact row_works_620_i0.mono (by decide +kernel) +theorem row_works_620 : Template HasSnaky 7 required_620 envelope_620 := by + refine compose HasSnaky 6 childrenC_620 childrenD_620 children_work_620 (4, 5) + required_620 envelope_620 pivot_mem_620 child_required_sub_620 child_envelope_sub_620 ?_ + intro b hb + exact common_sub_620 (mem_commonEnvelope childrenD_620 b hb) +def required_621_i0 : Finset Cell := ⟨(([(2, 4), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_621_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_621_i0 : Fin 3 → Finset Cell := ![(placed21 7 (5, 4) required_15), (placed21 1 (1, 2) required_159), (placed21 6 (4, 6) required_164)] +def childrenD_621_i0 : Fin 3 → Finset Cell := ![(placed21 7 (5, 4) envelope_15), (placed21 1 (1, 2) envelope_159), (placed21 6 (4, 6) envelope_164)] +theorem common_sub_621_i0 : commonEnvelope childrenD_621_i0 ⊆ insert (2, 3) required_621_i0 := by decide +kernel +theorem child_required_sub_621_i0 : ∀ j, childrenC_621_i0 j ⊆ insert (2, 3) required_621_i0 := by decide +kernel +theorem child_envelope_sub_621_i0 : ∀ j, childrenD_621_i0 j ⊆ envelope_621_i0 := by decide +kernel +theorem pivot_mem_621_i0 : (2, 3) ∈ envelope_621_i0 := by decide +kernel +theorem children_work_621_i0 : ∀ j, Template HasSnaky 5 (childrenC_621_i0 j) (childrenD_621_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 7 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_159 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_164 6 (4, 6)).mono (by decide +kernel) +theorem row_works_621_i0 : Template HasSnaky 6 required_621_i0 envelope_621_i0 := by + refine compose HasSnaky 5 childrenC_621_i0 childrenD_621_i0 children_work_621_i0 (2, 3) + required_621_i0 envelope_621_i0 pivot_mem_621_i0 child_required_sub_621_i0 child_envelope_sub_621_i0 ?_ + intro b hb + exact common_sub_621_i0 (mem_commonEnvelope childrenD_621_i0 b hb) +def required_621_i1 : Finset Cell := ⟨(([(2, 4), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_621_i1 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 3), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_621_i1 : Fin 2 → Finset Cell := ![(placed21 4 (0, 4) required_0), (placed21 4 (0, 6) required_133)] +def childrenD_621_i1 : Fin 2 → Finset Cell := ![(placed21 4 (0, 4) envelope_0), (placed21 4 (0, 6) envelope_133)] +theorem common_sub_621_i1 : commonEnvelope childrenD_621_i1 ⊆ insert (1, 4) required_621_i1 := by decide +kernel +theorem child_required_sub_621_i1 : ∀ j, childrenC_621_i1 j ⊆ insert (1, 4) required_621_i1 := by decide +kernel +theorem child_envelope_sub_621_i1 : ∀ j, childrenD_621_i1 j ⊆ envelope_621_i1 := by decide +kernel +theorem pivot_mem_621_i1 : (1, 4) ∈ envelope_621_i1 := by decide +kernel +theorem children_work_621_i1 : ∀ j, Template HasSnaky 5 (childrenC_621_i1 j) (childrenD_621_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 4 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_133 4 (0, 6)).mono (by decide +kernel) +theorem row_works_621_i1 : Template HasSnaky 6 required_621_i1 envelope_621_i1 := by + refine compose HasSnaky 5 childrenC_621_i1 childrenD_621_i1 children_work_621_i1 (1, 4) + required_621_i1 envelope_621_i1 pivot_mem_621_i1 child_required_sub_621_i1 child_envelope_sub_621_i1 ?_ + intro b hb + exact common_sub_621_i1 (mem_commonEnvelope childrenD_621_i1 b hb) +def required_621 : Finset Cell := ⟨(([(3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_621 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (5, 4), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_621 : Fin 6 → Finset Cell := ![(placed21 1 (0, 3) required_206), (placed21 5 (5, 2) required_238), (placed21 7 (5, 5) required_414), (placed21 6 (4, 6) required_417), required_621_i0, required_621_i1] +def childrenD_621 : Fin 6 → Finset Cell := ![(placed21 1 (0, 3) envelope_206), (placed21 5 (5, 2) envelope_238), (placed21 7 (5, 5) envelope_414), (placed21 6 (4, 6) envelope_417), envelope_621_i0, envelope_621_i1] +theorem common_sub_621 : commonEnvelope childrenD_621 ⊆ insert (2, 4) required_621 := by decide +kernel +theorem child_required_sub_621 : ∀ j, childrenC_621 j ⊆ insert (2, 4) required_621 := by decide +kernel +theorem child_envelope_sub_621 : ∀ j, childrenD_621 j ⊆ envelope_621 := by decide +kernel +theorem pivot_mem_621 : (2, 4) ∈ envelope_621 := by decide +kernel +theorem children_work_621 : ∀ j, Template HasSnaky 6 (childrenC_621 j) (childrenD_621 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_206 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_238 5 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_414 7 (5, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_417 6 (4, 6)).mono (by decide +kernel) + · exact row_works_621_i0.mono (by decide +kernel) + · exact row_works_621_i1.mono (by decide +kernel) +theorem row_works_621 : Template HasSnaky 7 required_621 envelope_621 := by + refine compose HasSnaky 6 childrenC_621 childrenD_621 children_work_621 (2, 4) + required_621 envelope_621 pivot_mem_621 child_required_sub_621 child_envelope_sub_621 ?_ + intro b hb + exact common_sub_621 (mem_commonEnvelope childrenD_621 b hb) +def required_628_i0 : Finset Cell := ⟨(([(1, 2), (1, 3), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_628_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_628_i0 : Fin 2 → Finset Cell := ![(placed21 7 (4, 3) required_36), (placed21 0 (3, 0) required_53)] +def childrenD_628_i0 : Fin 2 → Finset Cell := ![(placed21 7 (4, 3) envelope_36), (placed21 0 (3, 0) envelope_53)] +theorem common_sub_628_i0 : commonEnvelope childrenD_628_i0 ⊆ insert (3, 2) required_628_i0 := by decide +kernel +theorem child_required_sub_628_i0 : ∀ j, childrenC_628_i0 j ⊆ insert (3, 2) required_628_i0 := by decide +kernel +theorem child_envelope_sub_628_i0 : ∀ j, childrenD_628_i0 j ⊆ envelope_628_i0 := by decide +kernel +theorem pivot_mem_628_i0 : (3, 2) ∈ envelope_628_i0 := by decide +kernel +theorem children_work_628_i0 : ∀ j, Template HasSnaky 3 (childrenC_628_i0 j) (childrenD_628_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_36 7 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_53 0 (3, 0)).mono (by decide +kernel) +theorem row_works_628_i0 : Template HasSnaky 4 required_628_i0 envelope_628_i0 := by + refine compose HasSnaky 3 childrenC_628_i0 childrenD_628_i0 children_work_628_i0 (3, 2) + required_628_i0 envelope_628_i0 pivot_mem_628_i0 child_required_sub_628_i0 child_envelope_sub_628_i0 ?_ + intro b hb + exact common_sub_628_i0 (mem_commonEnvelope childrenD_628_i0 b hb) +def required_628_i1 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_628_i1 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_628_i1 : Fin 2 → Finset Cell := ![(placed21 7 (5, 4) required_34), (placed21 2 (4, 0) required_464)] +def childrenD_628_i1 : Fin 2 → Finset Cell := ![(placed21 7 (5, 4) envelope_34), (placed21 2 (4, 0) envelope_464)] +theorem common_sub_628_i1 : commonEnvelope childrenD_628_i1 ⊆ insert (3, 4) required_628_i1 := by decide +kernel +theorem child_required_sub_628_i1 : ∀ j, childrenC_628_i1 j ⊆ insert (3, 4) required_628_i1 := by decide +kernel +theorem child_envelope_sub_628_i1 : ∀ j, childrenD_628_i1 j ⊆ envelope_628_i1 := by decide +kernel +theorem pivot_mem_628_i1 : (3, 4) ∈ envelope_628_i1 := by decide +kernel +theorem children_work_628_i1 : ∀ j, Template HasSnaky 5 (childrenC_628_i1 j) (childrenD_628_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_34 7 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_464 2 (4, 0)).mono (by decide +kernel) +theorem row_works_628_i1 : Template HasSnaky 6 required_628_i1 envelope_628_i1 := by + refine compose HasSnaky 5 childrenC_628_i1 childrenD_628_i1 children_work_628_i1 (3, 4) + required_628_i1 envelope_628_i1 pivot_mem_628_i1 child_required_sub_628_i1 child_envelope_sub_628_i1 ?_ + intro b hb + exact common_sub_628_i1 (mem_commonEnvelope childrenD_628_i1 b hb) +def required_628_i2 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_628_i2 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4), (4, 3), (4, 4), (5, 2), (5, 3), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_628_i2 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_5), (placed21 3 (1, 4) required_265)] +def childrenD_628_i2 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_5), (placed21 3 (1, 4) envelope_265)] +theorem common_sub_628_i2 : commonEnvelope childrenD_628_i2 ⊆ insert (2, 3) required_628_i2 := by decide +kernel +theorem child_required_sub_628_i2 : ∀ j, childrenC_628_i2 j ⊆ insert (2, 3) required_628_i2 := by decide +kernel +theorem child_envelope_sub_628_i2 : ∀ j, childrenD_628_i2 j ⊆ envelope_628_i2 := by decide +kernel +theorem pivot_mem_628_i2 : (2, 3) ∈ envelope_628_i2 := by decide +kernel +theorem children_work_628_i2 : ∀ j, Template HasSnaky 5 (childrenC_628_i2 j) (childrenD_628_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_265 3 (1, 4)).mono (by decide +kernel) +theorem row_works_628_i2 : Template HasSnaky 6 required_628_i2 envelope_628_i2 := by + refine compose HasSnaky 5 childrenC_628_i2 childrenD_628_i2 children_work_628_i2 (2, 3) + required_628_i2 envelope_628_i2 pivot_mem_628_i2 child_required_sub_628_i2 child_envelope_sub_628_i2 ?_ + intro b hb + exact common_sub_628_i2 (mem_commonEnvelope childrenD_628_i2 b hb) +def required_628 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_628 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4), (8, 2), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_628 : Fin 5 → Finset Cell := ![(placed21 1 (0, 2) required_126), (placed21 4 (1, 5) required_270), required_628_i0, required_628_i1, required_628_i2] +def childrenD_628 : Fin 5 → Finset Cell := ![(placed21 1 (0, 2) envelope_126), (placed21 4 (1, 5) envelope_270), envelope_628_i0, envelope_628_i1, envelope_628_i2] +theorem common_sub_628 : commonEnvelope childrenD_628 ⊆ insert (3, 3) required_628 := by decide +kernel +theorem child_required_sub_628 : ∀ j, childrenC_628 j ⊆ insert (3, 3) required_628 := by decide +kernel +theorem child_envelope_sub_628 : ∀ j, childrenD_628 j ⊆ envelope_628 := by decide +kernel +theorem pivot_mem_628 : (3, 3) ∈ envelope_628 := by decide +kernel +theorem children_work_628 : ∀ j, Template HasSnaky 6 (childrenC_628 j) (childrenD_628 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_126 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_270 4 (1, 5)).mono (by decide +kernel) + · exact row_works_628_i0.mono (by decide +kernel) + · exact row_works_628_i1.mono (by decide +kernel) + · exact row_works_628_i2.mono (by decide +kernel) +theorem row_works_628 : Template HasSnaky 7 required_628 envelope_628 := by + refine compose HasSnaky 6 childrenC_628 childrenD_628 children_work_628 (3, 3) + required_628 envelope_628 pivot_mem_628 child_required_sub_628 child_envelope_sub_628 ?_ + intro b hb + exact common_sub_628 (mem_commonEnvelope childrenD_628 b hb) +def required_633_i1 : Finset Cell := ⟨(([(4, 4), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_633_i1 : Finset Cell := ⟨(([(4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 6), (6, 7), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_633_i1 : Fin 2 → Finset Cell := ![(placed21 1 (4, 3) required_8), (placed21 3 (4, 6) required_93)] +def childrenD_633_i1 : Fin 2 → Finset Cell := ![(placed21 1 (4, 3) envelope_8), (placed21 3 (4, 6) envelope_93)] +theorem common_sub_633_i1 : commonEnvelope childrenD_633_i1 ⊆ insert (5, 3) required_633_i1 := by decide +kernel +theorem child_required_sub_633_i1 : ∀ j, childrenC_633_i1 j ⊆ insert (5, 3) required_633_i1 := by decide +kernel +theorem child_envelope_sub_633_i1 : ∀ j, childrenD_633_i1 j ⊆ envelope_633_i1 := by decide +kernel +theorem pivot_mem_633_i1 : (5, 3) ∈ envelope_633_i1 := by decide +kernel +theorem children_work_633_i1 : ∀ j, Template HasSnaky 4 (childrenC_633_i1 j) (childrenD_633_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_93 3 (4, 6)).mono (by decide +kernel) +theorem row_works_633_i1 : Template HasSnaky 5 required_633_i1 envelope_633_i1 := by + refine compose HasSnaky 4 childrenC_633_i1 childrenD_633_i1 children_work_633_i1 (5, 3) + required_633_i1 envelope_633_i1 pivot_mem_633_i1 child_required_sub_633_i1 child_envelope_sub_633_i1 ?_ + intro b hb + exact common_sub_633_i1 (mem_commonEnvelope childrenD_633_i1 b hb) +def required_633_i0 : Finset Cell := ⟨(([(4, 4), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_633_i0 : Finset Cell := ⟨(([(3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 6), (6, 7), (6, 8), (7, 3), (8, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_633_i0 : Fin 4 → Finset Cell := ![(placed21 2 (5, 3) required_27), (placed21 6 (5, 7) required_52), (placed21 3 (3, 6) required_144), required_633_i1] +def childrenD_633_i0 : Fin 4 → Finset Cell := ![(placed21 2 (5, 3) envelope_27), (placed21 6 (5, 7) envelope_52), (placed21 3 (3, 6) envelope_144), envelope_633_i1] +theorem common_sub_633_i0 : commonEnvelope childrenD_633_i0 ⊆ insert (5, 6) required_633_i0 := by decide +kernel +theorem child_required_sub_633_i0 : ∀ j, childrenC_633_i0 j ⊆ insert (5, 6) required_633_i0 := by decide +kernel +theorem child_envelope_sub_633_i0 : ∀ j, childrenD_633_i0 j ⊆ envelope_633_i0 := by decide +kernel +theorem pivot_mem_633_i0 : (5, 6) ∈ envelope_633_i0 := by decide +kernel +theorem children_work_633_i0 : ∀ j, Template HasSnaky 5 (childrenC_633_i0 j) (childrenD_633_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_27 2 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_144 3 (3, 6)).mono (by decide +kernel) + · exact row_works_633_i1.mono (by decide +kernel) +theorem row_works_633_i0 : Template HasSnaky 6 required_633_i0 envelope_633_i0 := by + refine compose HasSnaky 5 childrenC_633_i0 childrenD_633_i0 children_work_633_i0 (5, 6) + required_633_i0 envelope_633_i0 pivot_mem_633_i0 child_required_sub_633_i0 child_envelope_sub_633_i0 ?_ + intro b hb + exact common_sub_633_i0 (mem_commonEnvelope childrenD_633_i0 b hb) +def required_633 : Finset Cell := ⟨(([(3, 4), (3, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_633 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 6), (6, 7), (6, 8), (7, 3), (8, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_633 : Fin 3 → Finset Cell := ![(placed21 6 (6, 6) required_47), (placed21 6 (5, 6) required_144), required_633_i0] +def childrenD_633 : Fin 3 → Finset Cell := ![(placed21 6 (6, 6) envelope_47), (placed21 6 (5, 6) envelope_144), envelope_633_i0] +theorem common_sub_633 : commonEnvelope childrenD_633 ⊆ insert (4, 4) required_633 := by decide +kernel +theorem child_required_sub_633 : ∀ j, childrenC_633 j ⊆ insert (4, 4) required_633 := by decide +kernel +theorem child_envelope_sub_633 : ∀ j, childrenD_633 j ⊆ envelope_633 := by decide +kernel +theorem pivot_mem_633 : (4, 4) ∈ envelope_633 := by decide +kernel +theorem children_work_633 : ∀ j, Template HasSnaky 6 (childrenC_633 j) (childrenD_633 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_47 6 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_144 6 (5, 6)).mono (by decide +kernel) + · exact row_works_633_i0.mono (by decide +kernel) +theorem row_works_633 : Template HasSnaky 7 required_633 envelope_633 := by + refine compose HasSnaky 6 childrenC_633 childrenD_633 children_work_633 (4, 4) + required_633 envelope_633 pivot_mem_633 child_required_sub_633 child_envelope_sub_633 ?_ + intro b hb + exact common_sub_633 (mem_commonEnvelope childrenD_633 b hb) +def required_637_i2 : Finset Cell := ⟨(([(2, 3), (3, 2), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_637_i2 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_637_i2 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) required_15), (placed21 1 (1, 3) required_44)] +def childrenD_637_i2 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) envelope_15), (placed21 1 (1, 3) envelope_44)] +theorem common_sub_637_i2 : commonEnvelope childrenD_637_i2 ⊆ insert (4, 4) required_637_i2 := by decide +kernel +theorem child_required_sub_637_i2 : ∀ j, childrenC_637_i2 j ⊆ insert (4, 4) required_637_i2 := by decide +kernel +theorem child_envelope_sub_637_i2 : ∀ j, childrenD_637_i2 j ⊆ envelope_637_i2 := by decide +kernel +theorem pivot_mem_637_i2 : (4, 4) ∈ envelope_637_i2 := by decide +kernel +theorem children_work_637_i2 : ∀ j, Template HasSnaky 3 (childrenC_637_i2 j) (childrenD_637_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 6 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_44 1 (1, 3)).mono (by decide +kernel) +theorem row_works_637_i2 : Template HasSnaky 4 required_637_i2 envelope_637_i2 := by + refine compose HasSnaky 3 childrenC_637_i2 childrenD_637_i2 children_work_637_i2 (4, 4) + required_637_i2 envelope_637_i2 pivot_mem_637_i2 child_required_sub_637_i2 child_envelope_sub_637_i2 ?_ + intro b hb + exact common_sub_637_i2 (mem_commonEnvelope childrenD_637_i2 b hb) +def required_637_i1 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 2), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_637_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_637_i1 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_0), required_637_i2] +def childrenD_637_i1 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_0), envelope_637_i2] +theorem common_sub_637_i1 : commonEnvelope childrenD_637_i1 ⊆ insert (3, 3) required_637_i1 := by decide +kernel +theorem child_required_sub_637_i1 : ∀ j, childrenC_637_i1 j ⊆ insert (3, 3) required_637_i1 := by decide +kernel +theorem child_envelope_sub_637_i1 : ∀ j, childrenD_637_i1 j ⊆ envelope_637_i1 := by decide +kernel +theorem pivot_mem_637_i1 : (3, 3) ∈ envelope_637_i1 := by decide +kernel +theorem children_work_637_i1 : ∀ j, Template HasSnaky 4 (childrenC_637_i1 j) (childrenD_637_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 0 (0, 2)).mono (by decide +kernel) + · exact row_works_637_i2.mono (by decide +kernel) +theorem row_works_637_i1 : Template HasSnaky 5 required_637_i1 envelope_637_i1 := by + refine compose HasSnaky 4 childrenC_637_i1 childrenD_637_i1 children_work_637_i1 (3, 3) + required_637_i1 envelope_637_i1 pivot_mem_637_i1 child_required_sub_637_i1 child_envelope_sub_637_i1 ?_ + intro b hb + exact common_sub_637_i1 (mem_commonEnvelope childrenD_637_i1 b hb) +def required_637_i0 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_637_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_637_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) required_5), required_637_i1] +def childrenD_637_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) envelope_5), envelope_637_i1] +theorem common_sub_637_i0 : commonEnvelope childrenD_637_i0 ⊆ insert (4, 3) required_637_i0 := by decide +kernel +theorem child_required_sub_637_i0 : ∀ j, childrenC_637_i0 j ⊆ insert (4, 3) required_637_i0 := by decide +kernel +theorem child_envelope_sub_637_i0 : ∀ j, childrenD_637_i0 j ⊆ envelope_637_i0 := by decide +kernel +theorem pivot_mem_637_i0 : (4, 3) ∈ envelope_637_i0 := by decide +kernel +theorem children_work_637_i0 : ∀ j, Template HasSnaky 5 (childrenC_637_i0 j) (childrenD_637_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 2)).mono (by decide +kernel) + · exact row_works_637_i1.mono (by decide +kernel) +theorem row_works_637_i0 : Template HasSnaky 6 required_637_i0 envelope_637_i0 := by + refine compose HasSnaky 5 childrenC_637_i0 childrenD_637_i0 children_work_637_i0 (4, 3) + required_637_i0 envelope_637_i0 pivot_mem_637_i0 child_required_sub_637_i0 child_envelope_sub_637_i0 ?_ + intro b hb + exact common_sub_637_i0 (mem_commonEnvelope childrenD_637_i0 b hb) +def required_637 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_637 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (6, 1), (6, 2), (6, 3), (6, 4), (7, 1), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_637 : Fin 4 → Finset Cell := ![(placed21 1 (1, 2) required_21), (placed21 3 (1, 3) required_41), (placed21 3 (1, 3) required_48), required_637_i0] +def childrenD_637 : Fin 4 → Finset Cell := ![(placed21 1 (1, 2) envelope_21), (placed21 3 (1, 3) envelope_41), (placed21 3 (1, 3) envelope_48), envelope_637_i0] +theorem common_sub_637 : commonEnvelope childrenD_637 ⊆ insert (4, 2) required_637 := by decide +kernel +theorem child_required_sub_637 : ∀ j, childrenC_637 j ⊆ insert (4, 2) required_637 := by decide +kernel +theorem child_envelope_sub_637 : ∀ j, childrenD_637 j ⊆ envelope_637 := by decide +kernel +theorem pivot_mem_637 : (4, 2) ∈ envelope_637 := by decide +kernel +theorem children_work_637 : ∀ j, Template HasSnaky 6 (childrenC_637 j) (childrenD_637 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_41 3 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_48 3 (1, 3)).mono (by decide +kernel) + · exact row_works_637_i0.mono (by decide +kernel) +theorem row_works_637 : Template HasSnaky 7 required_637 envelope_637 := by + refine compose HasSnaky 6 childrenC_637 childrenD_637 children_work_637 (4, 2) + required_637 envelope_637 pivot_mem_637 child_required_sub_637 child_envelope_sub_637 ?_ + intro b hb + exact common_sub_637 (mem_commonEnvelope childrenD_637 b hb) +def required_671_i0 : Finset Cell := ⟨(([(1, 2), (1, 4), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_671_i0 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_671_i0 : Fin 2 → Finset Cell := ![(placed21 7 (5, 4) required_22), (placed21 2 (4, 0) required_464)] +def childrenD_671_i0 : Fin 2 → Finset Cell := ![(placed21 7 (5, 4) envelope_22), (placed21 2 (4, 0) envelope_464)] +theorem common_sub_671_i0 : commonEnvelope childrenD_671_i0 ⊆ insert (3, 4) required_671_i0 := by decide +kernel +theorem child_required_sub_671_i0 : ∀ j, childrenC_671_i0 j ⊆ insert (3, 4) required_671_i0 := by decide +kernel +theorem child_envelope_sub_671_i0 : ∀ j, childrenD_671_i0 j ⊆ envelope_671_i0 := by decide +kernel +theorem pivot_mem_671_i0 : (3, 4) ∈ envelope_671_i0 := by decide +kernel +theorem children_work_671_i0 : ∀ j, Template HasSnaky 5 (childrenC_671_i0 j) (childrenD_671_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 7 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_464 2 (4, 0)).mono (by decide +kernel) +theorem row_works_671_i0 : Template HasSnaky 6 required_671_i0 envelope_671_i0 := by + refine compose HasSnaky 5 childrenC_671_i0 childrenD_671_i0 children_work_671_i0 (3, 4) + required_671_i0 envelope_671_i0 pivot_mem_671_i0 child_required_sub_671_i0 child_envelope_sub_671_i0 ?_ + intro b hb + exact common_sub_671_i0 (mem_commonEnvelope childrenD_671_i0 b hb) +def required_671 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_671 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_671 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) required_28), (placed21 1 (0, 2) required_126), (placed21 3 (0, 4) required_126), required_671_i0] +def childrenD_671 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) envelope_28), (placed21 1 (0, 2) envelope_126), (placed21 3 (0, 4) envelope_126), envelope_671_i0] +theorem common_sub_671 : commonEnvelope childrenD_671 ⊆ insert (3, 3) required_671 := by decide +kernel +theorem child_required_sub_671 : ∀ j, childrenC_671 j ⊆ insert (3, 3) required_671 := by decide +kernel +theorem child_envelope_sub_671 : ∀ j, childrenD_671 j ⊆ envelope_671 := by decide +kernel +theorem pivot_mem_671 : (3, 3) ∈ envelope_671 := by decide +kernel +theorem children_work_671 : ∀ j, Template HasSnaky 6 (childrenC_671 j) (childrenD_671 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_28 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_126 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_126 3 (0, 4)).mono (by decide +kernel) + · exact row_works_671_i0.mono (by decide +kernel) +theorem row_works_671 : Template HasSnaky 7 required_671 envelope_671 := by + refine compose HasSnaky 6 childrenC_671 childrenD_671 children_work_671 (3, 3) + required_671 envelope_671 pivot_mem_671 child_required_sub_671 child_envelope_sub_671 ?_ + intro b hb + exact common_sub_671 (mem_commonEnvelope childrenD_671 b hb) +def required_680_i0 : Finset Cell := ⟨(([(2, 2), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_680_i0 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_680_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 0) required_56), (placed21 6 (5, 5) required_179)] +def childrenD_680_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 0) envelope_56), (placed21 6 (5, 5) envelope_179)] +theorem common_sub_680_i0 : commonEnvelope childrenD_680_i0 ⊆ insert (1, 3) required_680_i0 := by decide +kernel +theorem child_required_sub_680_i0 : ∀ j, childrenC_680_i0 j ⊆ insert (1, 3) required_680_i0 := by decide +kernel +theorem child_envelope_sub_680_i0 : ∀ j, childrenD_680_i0 j ⊆ envelope_680_i0 := by decide +kernel +theorem pivot_mem_680_i0 : (1, 3) ∈ envelope_680_i0 := by decide +kernel +theorem children_work_680_i0 : ∀ j, Template HasSnaky 5 (childrenC_680_i0 j) (childrenD_680_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_56 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_179 6 (5, 5)).mono (by decide +kernel) +theorem row_works_680_i0 : Template HasSnaky 6 required_680_i0 envelope_680_i0 := by + refine compose HasSnaky 5 childrenC_680_i0 childrenD_680_i0 children_work_680_i0 (1, 3) + required_680_i0 envelope_680_i0 pivot_mem_680_i0 child_required_sub_680_i0 child_envelope_sub_680_i0 ?_ + intro b hb + exact common_sub_680_i0 (mem_commonEnvelope childrenD_680_i0 b hb) +def required_680 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_680 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_680 : Fin 2 → Finset Cell := ![(placed21 6 (5, 3) required_0), required_680_i0] +def childrenD_680 : Fin 2 → Finset Cell := ![(placed21 6 (5, 3) envelope_0), envelope_680_i0] +theorem common_sub_680 : commonEnvelope childrenD_680 ⊆ insert (3, 3) required_680 := by decide +kernel +theorem child_required_sub_680 : ∀ j, childrenC_680 j ⊆ insert (3, 3) required_680 := by decide +kernel +theorem child_envelope_sub_680 : ∀ j, childrenD_680 j ⊆ envelope_680 := by decide +kernel +theorem pivot_mem_680 : (3, 3) ∈ envelope_680 := by decide +kernel +theorem children_work_680 : ∀ j, Template HasSnaky 6 (childrenC_680 j) (childrenD_680 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 3)).mono (by decide +kernel) + · exact row_works_680_i0.mono (by decide +kernel) +theorem row_works_680 : Template HasSnaky 7 required_680 envelope_680 := by + refine compose HasSnaky 6 childrenC_680 childrenD_680 children_work_680 (3, 3) + required_680 envelope_680 pivot_mem_680 child_required_sub_680 child_envelope_sub_680 ?_ + intro b hb + exact common_sub_680 (mem_commonEnvelope childrenD_680 b hb) +def height_593_i0 : ℕ := 6 +def childrenH_593_i0 : Fin 4 → ℕ := ![height_36, height_105, height_250, height_592] +theorem height_exact_593_i0 : height_593_i0 = 1 + Finset.univ.sup childrenH_593_i0 := by decide +kernel +theorem required_origin_593_i0 : ∀ x ∈ required_593_i0, + (∃ j, x ∈ childrenC_593_i0 j) ∨ ∀ j, x ∈ childrenD_593_i0 j := by decide +kernel +theorem required_exact_593_i0 : required_593_i0 = + ((Finset.univ.biUnion childrenC_593_i0) ∪ commonEnvelope childrenD_593_i0).erase (4, 5) := by + exact required_eq_combination childrenC_593_i0 childrenD_593_i0 (4, 5) required_593_i0 + (by decide +kernel) child_required_sub_593_i0 common_sub_593_i0 required_origin_593_i0 +theorem envelope_origin_593_i0 : ∀ x ∈ envelope_593_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_593_i0 j := by decide +kernel +theorem envelope_exact_593_i0 : envelope_593_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_593_i0) := by + exact envelope_eq_combination childrenD_593_i0 (4, 5) envelope_593_i0 + pivot_mem_593_i0 child_envelope_sub_593_i0 envelope_origin_593_i0 +def checked_593_i0 : CheckedCard where + required := required_593_i0 + envelope := envelope_593_i0 + height := height_593_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_593_i0 +def height_593 : ℕ := 7 +def childrenH_593 : Fin 2 → ℕ := ![height_2, height_593_i0] +theorem height_exact_593 : height_593 = 1 + Finset.univ.sup childrenH_593 := by decide +kernel +theorem required_origin_593 : ∀ x ∈ required_593, + (∃ j, x ∈ childrenC_593 j) ∨ ∀ j, x ∈ childrenD_593 j := by decide +kernel +theorem required_exact_593 : required_593 = + ((Finset.univ.biUnion childrenC_593) ∪ commonEnvelope childrenD_593).erase (4, 3) := by + exact required_eq_combination childrenC_593 childrenD_593 (4, 3) required_593 + (by decide +kernel) child_required_sub_593 common_sub_593 required_origin_593 +theorem envelope_origin_593 : ∀ x ∈ envelope_593, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_593 j := by decide +kernel +theorem envelope_exact_593 : envelope_593 = + insert (4, 3) (Finset.univ.biUnion childrenD_593) := by + exact envelope_eq_combination childrenD_593 (4, 3) envelope_593 + pivot_mem_593 child_envelope_sub_593 envelope_origin_593 +def checked_593 : CheckedCard where + required := required_593 + envelope := envelope_593 + height := height_593 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_593 +def height_610 : ℕ := 7 +def childrenH_610 : Fin 4 → ℕ := ![height_19, height_197, height_225, height_609] +theorem height_exact_610 : height_610 = 1 + Finset.univ.sup childrenH_610 := by decide +kernel +theorem required_origin_610 : ∀ x ∈ required_610, + (∃ j, x ∈ childrenC_610 j) ∨ ∀ j, x ∈ childrenD_610 j := by decide +kernel +theorem required_exact_610 : required_610 = + ((Finset.univ.biUnion childrenC_610) ∪ commonEnvelope childrenD_610).erase (1, 5) := by + exact required_eq_combination childrenC_610 childrenD_610 (1, 5) required_610 + (by decide +kernel) child_required_sub_610 common_sub_610 required_origin_610 +theorem envelope_origin_610 : ∀ x ∈ envelope_610, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_610 j := by decide +kernel +theorem envelope_exact_610 : envelope_610 = + insert (1, 5) (Finset.univ.biUnion childrenD_610) := by + exact envelope_eq_combination childrenD_610 (1, 5) envelope_610 + pivot_mem_610 child_envelope_sub_610 envelope_origin_610 +def checked_610 : CheckedCard where + required := required_610 + envelope := envelope_610 + height := height_610 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_610 +def height_620_i0 : ℕ := 6 +def childrenH_620_i0 : Fin 3 → ℕ := ![height_17, height_37, height_233] +theorem height_exact_620_i0 : height_620_i0 = 1 + Finset.univ.sup childrenH_620_i0 := by decide +kernel +theorem required_origin_620_i0 : ∀ x ∈ required_620_i0, + (∃ j, x ∈ childrenC_620_i0 j) ∨ ∀ j, x ∈ childrenD_620_i0 j := by decide +kernel +theorem required_exact_620_i0 : required_620_i0 = + ((Finset.univ.biUnion childrenC_620_i0) ∪ commonEnvelope childrenD_620_i0).erase (3, 3) := by + exact required_eq_combination childrenC_620_i0 childrenD_620_i0 (3, 3) required_620_i0 + (by decide +kernel) child_required_sub_620_i0 common_sub_620_i0 required_origin_620_i0 +theorem envelope_origin_620_i0 : ∀ x ∈ envelope_620_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_620_i0 j := by decide +kernel +theorem envelope_exact_620_i0 : envelope_620_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_620_i0) := by + exact envelope_eq_combination childrenD_620_i0 (3, 3) envelope_620_i0 + pivot_mem_620_i0 child_envelope_sub_620_i0 envelope_origin_620_i0 +def checked_620_i0 : CheckedCard where + required := required_620_i0 + envelope := envelope_620_i0 + height := height_620_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_620_i0 +def height_620 : ℕ := 7 +def childrenH_620 : Fin 5 → ℕ := ![height_57, height_57, height_293, height_293, height_620_i0] +theorem height_exact_620 : height_620 = 1 + Finset.univ.sup childrenH_620 := by decide +kernel +theorem required_origin_620 : ∀ x ∈ required_620, + (∃ j, x ∈ childrenC_620 j) ∨ ∀ j, x ∈ childrenD_620 j := by decide +kernel +theorem required_exact_620 : required_620 = + ((Finset.univ.biUnion childrenC_620) ∪ commonEnvelope childrenD_620).erase (4, 5) := by + exact required_eq_combination childrenC_620 childrenD_620 (4, 5) required_620 + (by decide +kernel) child_required_sub_620 common_sub_620 required_origin_620 +theorem envelope_origin_620 : ∀ x ∈ envelope_620, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_620 j := by decide +kernel +theorem envelope_exact_620 : envelope_620 = + insert (4, 5) (Finset.univ.biUnion childrenD_620) := by + exact envelope_eq_combination childrenD_620 (4, 5) envelope_620 + pivot_mem_620 child_envelope_sub_620 envelope_origin_620 +def checked_620 : CheckedCard where + required := required_620 + envelope := envelope_620 + height := height_620 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_620 +def height_621_i0 : ℕ := 6 +def childrenH_621_i0 : Fin 3 → ℕ := ![height_15, height_159, height_164] +theorem height_exact_621_i0 : height_621_i0 = 1 + Finset.univ.sup childrenH_621_i0 := by decide +kernel +theorem required_origin_621_i0 : ∀ x ∈ required_621_i0, + (∃ j, x ∈ childrenC_621_i0 j) ∨ ∀ j, x ∈ childrenD_621_i0 j := by decide +kernel +theorem required_exact_621_i0 : required_621_i0 = + ((Finset.univ.biUnion childrenC_621_i0) ∪ commonEnvelope childrenD_621_i0).erase (2, 3) := by + exact required_eq_combination childrenC_621_i0 childrenD_621_i0 (2, 3) required_621_i0 + (by decide +kernel) child_required_sub_621_i0 common_sub_621_i0 required_origin_621_i0 +theorem envelope_origin_621_i0 : ∀ x ∈ envelope_621_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_621_i0 j := by decide +kernel +theorem envelope_exact_621_i0 : envelope_621_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_621_i0) := by + exact envelope_eq_combination childrenD_621_i0 (2, 3) envelope_621_i0 + pivot_mem_621_i0 child_envelope_sub_621_i0 envelope_origin_621_i0 +def checked_621_i0 : CheckedCard where + required := required_621_i0 + envelope := envelope_621_i0 + height := height_621_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_621_i0 +def height_621_i1 : ℕ := 6 +def childrenH_621_i1 : Fin 2 → ℕ := ![height_0, height_133] +theorem height_exact_621_i1 : height_621_i1 = 1 + Finset.univ.sup childrenH_621_i1 := by decide +kernel +theorem required_origin_621_i1 : ∀ x ∈ required_621_i1, + (∃ j, x ∈ childrenC_621_i1 j) ∨ ∀ j, x ∈ childrenD_621_i1 j := by decide +kernel +theorem required_exact_621_i1 : required_621_i1 = + ((Finset.univ.biUnion childrenC_621_i1) ∪ commonEnvelope childrenD_621_i1).erase (1, 4) := by + exact required_eq_combination childrenC_621_i1 childrenD_621_i1 (1, 4) required_621_i1 + (by decide +kernel) child_required_sub_621_i1 common_sub_621_i1 required_origin_621_i1 +theorem envelope_origin_621_i1 : ∀ x ∈ envelope_621_i1, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_621_i1 j := by decide +kernel +theorem envelope_exact_621_i1 : envelope_621_i1 = + insert (1, 4) (Finset.univ.biUnion childrenD_621_i1) := by + exact envelope_eq_combination childrenD_621_i1 (1, 4) envelope_621_i1 + pivot_mem_621_i1 child_envelope_sub_621_i1 envelope_origin_621_i1 +def checked_621_i1 : CheckedCard where + required := required_621_i1 + envelope := envelope_621_i1 + height := height_621_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_621_i1 +def height_621 : ℕ := 7 +def childrenH_621 : Fin 6 → ℕ := ![height_206, height_238, height_414, height_417, height_621_i0, height_621_i1] +theorem height_exact_621 : height_621 = 1 + Finset.univ.sup childrenH_621 := by decide +kernel +theorem required_origin_621 : ∀ x ∈ required_621, + (∃ j, x ∈ childrenC_621 j) ∨ ∀ j, x ∈ childrenD_621 j := by decide +kernel +theorem required_exact_621 : required_621 = + ((Finset.univ.biUnion childrenC_621) ∪ commonEnvelope childrenD_621).erase (2, 4) := by + exact required_eq_combination childrenC_621 childrenD_621 (2, 4) required_621 + (by decide +kernel) child_required_sub_621 common_sub_621 required_origin_621 +theorem envelope_origin_621 : ∀ x ∈ envelope_621, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_621 j := by decide +kernel +theorem envelope_exact_621 : envelope_621 = + insert (2, 4) (Finset.univ.biUnion childrenD_621) := by + exact envelope_eq_combination childrenD_621 (2, 4) envelope_621 + pivot_mem_621 child_envelope_sub_621 envelope_origin_621 +def checked_621 : CheckedCard where + required := required_621 + envelope := envelope_621 + height := height_621 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_621 +def height_628_i0 : ℕ := 4 +def childrenH_628_i0 : Fin 2 → ℕ := ![height_36, height_53] +theorem height_exact_628_i0 : height_628_i0 = 1 + Finset.univ.sup childrenH_628_i0 := by decide +kernel +theorem required_origin_628_i0 : ∀ x ∈ required_628_i0, + (∃ j, x ∈ childrenC_628_i0 j) ∨ ∀ j, x ∈ childrenD_628_i0 j := by decide +kernel +theorem required_exact_628_i0 : required_628_i0 = + ((Finset.univ.biUnion childrenC_628_i0) ∪ commonEnvelope childrenD_628_i0).erase (3, 2) := by + exact required_eq_combination childrenC_628_i0 childrenD_628_i0 (3, 2) required_628_i0 + (by decide +kernel) child_required_sub_628_i0 common_sub_628_i0 required_origin_628_i0 +theorem envelope_origin_628_i0 : ∀ x ∈ envelope_628_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_628_i0 j := by decide +kernel +theorem envelope_exact_628_i0 : envelope_628_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_628_i0) := by + exact envelope_eq_combination childrenD_628_i0 (3, 2) envelope_628_i0 + pivot_mem_628_i0 child_envelope_sub_628_i0 envelope_origin_628_i0 +def checked_628_i0 : CheckedCard where + required := required_628_i0 + envelope := envelope_628_i0 + height := height_628_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_628_i0 +def height_628_i1 : ℕ := 6 +def childrenH_628_i1 : Fin 2 → ℕ := ![height_34, height_464] +theorem height_exact_628_i1 : height_628_i1 = 1 + Finset.univ.sup childrenH_628_i1 := by decide +kernel +theorem required_origin_628_i1 : ∀ x ∈ required_628_i1, + (∃ j, x ∈ childrenC_628_i1 j) ∨ ∀ j, x ∈ childrenD_628_i1 j := by decide +kernel +theorem required_exact_628_i1 : required_628_i1 = + ((Finset.univ.biUnion childrenC_628_i1) ∪ commonEnvelope childrenD_628_i1).erase (3, 4) := by + exact required_eq_combination childrenC_628_i1 childrenD_628_i1 (3, 4) required_628_i1 + (by decide +kernel) child_required_sub_628_i1 common_sub_628_i1 required_origin_628_i1 +theorem envelope_origin_628_i1 : ∀ x ∈ envelope_628_i1, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_628_i1 j := by decide +kernel +theorem envelope_exact_628_i1 : envelope_628_i1 = + insert (3, 4) (Finset.univ.biUnion childrenD_628_i1) := by + exact envelope_eq_combination childrenD_628_i1 (3, 4) envelope_628_i1 + pivot_mem_628_i1 child_envelope_sub_628_i1 envelope_origin_628_i1 +def checked_628_i1 : CheckedCard where + required := required_628_i1 + envelope := envelope_628_i1 + height := height_628_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_628_i1 +def height_628_i2 : ℕ := 6 +def childrenH_628_i2 : Fin 2 → ℕ := ![height_5, height_265] +theorem height_exact_628_i2 : height_628_i2 = 1 + Finset.univ.sup childrenH_628_i2 := by decide +kernel +theorem required_origin_628_i2 : ∀ x ∈ required_628_i2, + (∃ j, x ∈ childrenC_628_i2 j) ∨ ∀ j, x ∈ childrenD_628_i2 j := by decide +kernel +theorem required_exact_628_i2 : required_628_i2 = + ((Finset.univ.biUnion childrenC_628_i2) ∪ commonEnvelope childrenD_628_i2).erase (2, 3) := by + exact required_eq_combination childrenC_628_i2 childrenD_628_i2 (2, 3) required_628_i2 + (by decide +kernel) child_required_sub_628_i2 common_sub_628_i2 required_origin_628_i2 +theorem envelope_origin_628_i2 : ∀ x ∈ envelope_628_i2, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_628_i2 j := by decide +kernel +theorem envelope_exact_628_i2 : envelope_628_i2 = + insert (2, 3) (Finset.univ.biUnion childrenD_628_i2) := by + exact envelope_eq_combination childrenD_628_i2 (2, 3) envelope_628_i2 + pivot_mem_628_i2 child_envelope_sub_628_i2 envelope_origin_628_i2 +def checked_628_i2 : CheckedCard where + required := required_628_i2 + envelope := envelope_628_i2 + height := height_628_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_628_i2 +def height_628 : ℕ := 7 +def childrenH_628 : Fin 5 → ℕ := ![height_126, height_270, height_628_i0, height_628_i1, height_628_i2] +theorem height_exact_628 : height_628 = 1 + Finset.univ.sup childrenH_628 := by decide +kernel +theorem required_origin_628 : ∀ x ∈ required_628, + (∃ j, x ∈ childrenC_628 j) ∨ ∀ j, x ∈ childrenD_628 j := by decide +kernel +theorem required_exact_628 : required_628 = + ((Finset.univ.biUnion childrenC_628) ∪ commonEnvelope childrenD_628).erase (3, 3) := by + exact required_eq_combination childrenC_628 childrenD_628 (3, 3) required_628 + (by decide +kernel) child_required_sub_628 common_sub_628 required_origin_628 +theorem envelope_origin_628 : ∀ x ∈ envelope_628, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_628 j := by decide +kernel +theorem envelope_exact_628 : envelope_628 = + insert (3, 3) (Finset.univ.biUnion childrenD_628) := by + exact envelope_eq_combination childrenD_628 (3, 3) envelope_628 + pivot_mem_628 child_envelope_sub_628 envelope_origin_628 +def checked_628 : CheckedCard where + required := required_628 + envelope := envelope_628 + height := height_628 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_628 +def height_633_i1 : ℕ := 5 +def childrenH_633_i1 : Fin 2 → ℕ := ![height_8, height_93] +theorem height_exact_633_i1 : height_633_i1 = 1 + Finset.univ.sup childrenH_633_i1 := by decide +kernel +theorem required_origin_633_i1 : ∀ x ∈ required_633_i1, + (∃ j, x ∈ childrenC_633_i1 j) ∨ ∀ j, x ∈ childrenD_633_i1 j := by decide +kernel +theorem required_exact_633_i1 : required_633_i1 = + ((Finset.univ.biUnion childrenC_633_i1) ∪ commonEnvelope childrenD_633_i1).erase (5, 3) := by + exact required_eq_combination childrenC_633_i1 childrenD_633_i1 (5, 3) required_633_i1 + (by decide +kernel) child_required_sub_633_i1 common_sub_633_i1 required_origin_633_i1 +theorem envelope_origin_633_i1 : ∀ x ∈ envelope_633_i1, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_633_i1 j := by decide +kernel +theorem envelope_exact_633_i1 : envelope_633_i1 = + insert (5, 3) (Finset.univ.biUnion childrenD_633_i1) := by + exact envelope_eq_combination childrenD_633_i1 (5, 3) envelope_633_i1 + pivot_mem_633_i1 child_envelope_sub_633_i1 envelope_origin_633_i1 +def checked_633_i1 : CheckedCard where + required := required_633_i1 + envelope := envelope_633_i1 + height := height_633_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_633_i1 +def height_633_i0 : ℕ := 6 +def childrenH_633_i0 : Fin 4 → ℕ := ![height_27, height_52, height_144, height_633_i1] +theorem height_exact_633_i0 : height_633_i0 = 1 + Finset.univ.sup childrenH_633_i0 := by decide +kernel +theorem required_origin_633_i0 : ∀ x ∈ required_633_i0, + (∃ j, x ∈ childrenC_633_i0 j) ∨ ∀ j, x ∈ childrenD_633_i0 j := by decide +kernel +theorem required_exact_633_i0 : required_633_i0 = + ((Finset.univ.biUnion childrenC_633_i0) ∪ commonEnvelope childrenD_633_i0).erase (5, 6) := by + exact required_eq_combination childrenC_633_i0 childrenD_633_i0 (5, 6) required_633_i0 + (by decide +kernel) child_required_sub_633_i0 common_sub_633_i0 required_origin_633_i0 +theorem envelope_origin_633_i0 : ∀ x ∈ envelope_633_i0, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_633_i0 j := by decide +kernel +theorem envelope_exact_633_i0 : envelope_633_i0 = + insert (5, 6) (Finset.univ.biUnion childrenD_633_i0) := by + exact envelope_eq_combination childrenD_633_i0 (5, 6) envelope_633_i0 + pivot_mem_633_i0 child_envelope_sub_633_i0 envelope_origin_633_i0 +def checked_633_i0 : CheckedCard where + required := required_633_i0 + envelope := envelope_633_i0 + height := height_633_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_633_i0 +def height_633 : ℕ := 7 +def childrenH_633 : Fin 3 → ℕ := ![height_47, height_144, height_633_i0] +theorem height_exact_633 : height_633 = 1 + Finset.univ.sup childrenH_633 := by decide +kernel +theorem required_origin_633 : ∀ x ∈ required_633, + (∃ j, x ∈ childrenC_633 j) ∨ ∀ j, x ∈ childrenD_633 j := by decide +kernel +theorem required_exact_633 : required_633 = + ((Finset.univ.biUnion childrenC_633) ∪ commonEnvelope childrenD_633).erase (4, 4) := by + exact required_eq_combination childrenC_633 childrenD_633 (4, 4) required_633 + (by decide +kernel) child_required_sub_633 common_sub_633 required_origin_633 +theorem envelope_origin_633 : ∀ x ∈ envelope_633, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_633 j := by decide +kernel +theorem envelope_exact_633 : envelope_633 = + insert (4, 4) (Finset.univ.biUnion childrenD_633) := by + exact envelope_eq_combination childrenD_633 (4, 4) envelope_633 + pivot_mem_633 child_envelope_sub_633 envelope_origin_633 +def checked_633 : CheckedCard where + required := required_633 + envelope := envelope_633 + height := height_633 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_633 +def height_637_i2 : ℕ := 4 +def childrenH_637_i2 : Fin 2 → ℕ := ![height_15, height_44] +theorem height_exact_637_i2 : height_637_i2 = 1 + Finset.univ.sup childrenH_637_i2 := by decide +kernel +theorem required_origin_637_i2 : ∀ x ∈ required_637_i2, + (∃ j, x ∈ childrenC_637_i2 j) ∨ ∀ j, x ∈ childrenD_637_i2 j := by decide +kernel +theorem required_exact_637_i2 : required_637_i2 = + ((Finset.univ.biUnion childrenC_637_i2) ∪ commonEnvelope childrenD_637_i2).erase (4, 4) := by + exact required_eq_combination childrenC_637_i2 childrenD_637_i2 (4, 4) required_637_i2 + (by decide +kernel) child_required_sub_637_i2 common_sub_637_i2 required_origin_637_i2 +theorem envelope_origin_637_i2 : ∀ x ∈ envelope_637_i2, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_637_i2 j := by decide +kernel +theorem envelope_exact_637_i2 : envelope_637_i2 = + insert (4, 4) (Finset.univ.biUnion childrenD_637_i2) := by + exact envelope_eq_combination childrenD_637_i2 (4, 4) envelope_637_i2 + pivot_mem_637_i2 child_envelope_sub_637_i2 envelope_origin_637_i2 +def checked_637_i2 : CheckedCard where + required := required_637_i2 + envelope := envelope_637_i2 + height := height_637_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_637_i2 +def height_637_i1 : ℕ := 5 +def childrenH_637_i1 : Fin 2 → ℕ := ![height_0, height_637_i2] +theorem height_exact_637_i1 : height_637_i1 = 1 + Finset.univ.sup childrenH_637_i1 := by decide +kernel +theorem required_origin_637_i1 : ∀ x ∈ required_637_i1, + (∃ j, x ∈ childrenC_637_i1 j) ∨ ∀ j, x ∈ childrenD_637_i1 j := by decide +kernel +theorem required_exact_637_i1 : required_637_i1 = + ((Finset.univ.biUnion childrenC_637_i1) ∪ commonEnvelope childrenD_637_i1).erase (3, 3) := by + exact required_eq_combination childrenC_637_i1 childrenD_637_i1 (3, 3) required_637_i1 + (by decide +kernel) child_required_sub_637_i1 common_sub_637_i1 required_origin_637_i1 +theorem envelope_origin_637_i1 : ∀ x ∈ envelope_637_i1, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_637_i1 j := by decide +kernel +theorem envelope_exact_637_i1 : envelope_637_i1 = + insert (3, 3) (Finset.univ.biUnion childrenD_637_i1) := by + exact envelope_eq_combination childrenD_637_i1 (3, 3) envelope_637_i1 + pivot_mem_637_i1 child_envelope_sub_637_i1 envelope_origin_637_i1 +def checked_637_i1 : CheckedCard where + required := required_637_i1 + envelope := envelope_637_i1 + height := height_637_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_637_i1 +def height_637_i0 : ℕ := 6 +def childrenH_637_i0 : Fin 2 → ℕ := ![height_5, height_637_i1] +theorem height_exact_637_i0 : height_637_i0 = 1 + Finset.univ.sup childrenH_637_i0 := by decide +kernel +theorem required_origin_637_i0 : ∀ x ∈ required_637_i0, + (∃ j, x ∈ childrenC_637_i0 j) ∨ ∀ j, x ∈ childrenD_637_i0 j := by decide +kernel +theorem required_exact_637_i0 : required_637_i0 = + ((Finset.univ.biUnion childrenC_637_i0) ∪ commonEnvelope childrenD_637_i0).erase (4, 3) := by + exact required_eq_combination childrenC_637_i0 childrenD_637_i0 (4, 3) required_637_i0 + (by decide +kernel) child_required_sub_637_i0 common_sub_637_i0 required_origin_637_i0 +theorem envelope_origin_637_i0 : ∀ x ∈ envelope_637_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_637_i0 j := by decide +kernel +theorem envelope_exact_637_i0 : envelope_637_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_637_i0) := by + exact envelope_eq_combination childrenD_637_i0 (4, 3) envelope_637_i0 + pivot_mem_637_i0 child_envelope_sub_637_i0 envelope_origin_637_i0 +def checked_637_i0 : CheckedCard where + required := required_637_i0 + envelope := envelope_637_i0 + height := height_637_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_637_i0 +def height_637 : ℕ := 7 +def childrenH_637 : Fin 4 → ℕ := ![height_21, height_41, height_48, height_637_i0] +theorem height_exact_637 : height_637 = 1 + Finset.univ.sup childrenH_637 := by decide +kernel +theorem required_origin_637 : ∀ x ∈ required_637, + (∃ j, x ∈ childrenC_637 j) ∨ ∀ j, x ∈ childrenD_637 j := by decide +kernel +theorem required_exact_637 : required_637 = + ((Finset.univ.biUnion childrenC_637) ∪ commonEnvelope childrenD_637).erase (4, 2) := by + exact required_eq_combination childrenC_637 childrenD_637 (4, 2) required_637 + (by decide +kernel) child_required_sub_637 common_sub_637 required_origin_637 +theorem envelope_origin_637 : ∀ x ∈ envelope_637, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_637 j := by decide +kernel +theorem envelope_exact_637 : envelope_637 = + insert (4, 2) (Finset.univ.biUnion childrenD_637) := by + exact envelope_eq_combination childrenD_637 (4, 2) envelope_637 + pivot_mem_637 child_envelope_sub_637 envelope_origin_637 +def checked_637 : CheckedCard where + required := required_637 + envelope := envelope_637 + height := height_637 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_637 +def height_671_i0 : ℕ := 6 +def childrenH_671_i0 : Fin 2 → ℕ := ![height_22, height_464] +theorem height_exact_671_i0 : height_671_i0 = 1 + Finset.univ.sup childrenH_671_i0 := by decide +kernel +theorem required_origin_671_i0 : ∀ x ∈ required_671_i0, + (∃ j, x ∈ childrenC_671_i0 j) ∨ ∀ j, x ∈ childrenD_671_i0 j := by decide +kernel +theorem required_exact_671_i0 : required_671_i0 = + ((Finset.univ.biUnion childrenC_671_i0) ∪ commonEnvelope childrenD_671_i0).erase (3, 4) := by + exact required_eq_combination childrenC_671_i0 childrenD_671_i0 (3, 4) required_671_i0 + (by decide +kernel) child_required_sub_671_i0 common_sub_671_i0 required_origin_671_i0 +theorem envelope_origin_671_i0 : ∀ x ∈ envelope_671_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_671_i0 j := by decide +kernel +theorem envelope_exact_671_i0 : envelope_671_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_671_i0) := by + exact envelope_eq_combination childrenD_671_i0 (3, 4) envelope_671_i0 + pivot_mem_671_i0 child_envelope_sub_671_i0 envelope_origin_671_i0 +def checked_671_i0 : CheckedCard where + required := required_671_i0 + envelope := envelope_671_i0 + height := height_671_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_671_i0 +def height_671 : ℕ := 7 +def childrenH_671 : Fin 4 → ℕ := ![height_28, height_126, height_126, height_671_i0] +theorem height_exact_671 : height_671 = 1 + Finset.univ.sup childrenH_671 := by decide +kernel +theorem required_origin_671 : ∀ x ∈ required_671, + (∃ j, x ∈ childrenC_671 j) ∨ ∀ j, x ∈ childrenD_671 j := by decide +kernel +theorem required_exact_671 : required_671 = + ((Finset.univ.biUnion childrenC_671) ∪ commonEnvelope childrenD_671).erase (3, 3) := by + exact required_eq_combination childrenC_671 childrenD_671 (3, 3) required_671 + (by decide +kernel) child_required_sub_671 common_sub_671 required_origin_671 +theorem envelope_origin_671 : ∀ x ∈ envelope_671, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_671 j := by decide +kernel +theorem envelope_exact_671 : envelope_671 = + insert (3, 3) (Finset.univ.biUnion childrenD_671) := by + exact envelope_eq_combination childrenD_671 (3, 3) envelope_671 + pivot_mem_671 child_envelope_sub_671 envelope_origin_671 +def checked_671 : CheckedCard where + required := required_671 + envelope := envelope_671 + height := height_671 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_671 +def height_680_i0 : ℕ := 6 +def childrenH_680_i0 : Fin 2 → ℕ := ![height_56, height_179] +theorem height_exact_680_i0 : height_680_i0 = 1 + Finset.univ.sup childrenH_680_i0 := by decide +kernel +theorem required_origin_680_i0 : ∀ x ∈ required_680_i0, + (∃ j, x ∈ childrenC_680_i0 j) ∨ ∀ j, x ∈ childrenD_680_i0 j := by decide +kernel +theorem required_exact_680_i0 : required_680_i0 = + ((Finset.univ.biUnion childrenC_680_i0) ∪ commonEnvelope childrenD_680_i0).erase (1, 3) := by + exact required_eq_combination childrenC_680_i0 childrenD_680_i0 (1, 3) required_680_i0 + (by decide +kernel) child_required_sub_680_i0 common_sub_680_i0 required_origin_680_i0 +theorem envelope_origin_680_i0 : ∀ x ∈ envelope_680_i0, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_680_i0 j := by decide +kernel +theorem envelope_exact_680_i0 : envelope_680_i0 = + insert (1, 3) (Finset.univ.biUnion childrenD_680_i0) := by + exact envelope_eq_combination childrenD_680_i0 (1, 3) envelope_680_i0 + pivot_mem_680_i0 child_envelope_sub_680_i0 envelope_origin_680_i0 +def checked_680_i0 : CheckedCard where + required := required_680_i0 + envelope := envelope_680_i0 + height := height_680_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_680_i0 +def height_680 : ℕ := 7 +def childrenH_680 : Fin 2 → ℕ := ![height_0, height_680_i0] +theorem height_exact_680 : height_680 = 1 + Finset.univ.sup childrenH_680 := by decide +kernel +theorem required_origin_680 : ∀ x ∈ required_680, + (∃ j, x ∈ childrenC_680 j) ∨ ∀ j, x ∈ childrenD_680 j := by decide +kernel +theorem required_exact_680 : required_680 = + ((Finset.univ.biUnion childrenC_680) ∪ commonEnvelope childrenD_680).erase (3, 3) := by + exact required_eq_combination childrenC_680 childrenD_680 (3, 3) required_680 + (by decide +kernel) child_required_sub_680 common_sub_680 required_origin_680 +theorem envelope_origin_680 : ∀ x ∈ envelope_680, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_680 j := by decide +kernel +theorem envelope_exact_680 : envelope_680 = + insert (3, 3) (Finset.univ.biUnion childrenD_680) := by + exact envelope_eq_combination childrenD_680 (3, 3) envelope_680 + pivot_mem_680 child_envelope_sub_680 envelope_origin_680 +def checked_680 : CheckedCard where + required := required_680 + envelope := envelope_680 + height := height_680 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_680 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part06.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part06.lean new file mode 100644 index 0000000..ff60814 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part06.lean @@ -0,0 +1,181 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_681_i1 : Finset Cell := ⟨(([(2, 4), (3, 4), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_681_i1 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (6, 3), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_681_i1 : Fin 3 → Finset Cell := ![(placed21 7 (5, 6) required_32), (placed21 3 (1, 4) required_44), (placed21 3 (3, 6) required_90)] +def childrenD_681_i1 : Fin 3 → Finset Cell := ![(placed21 7 (5, 6) envelope_32), (placed21 3 (1, 4) envelope_44), (placed21 3 (3, 6) envelope_90)] +theorem common_sub_681_i1 : commonEnvelope childrenD_681_i1 ⊆ insert (4, 3) required_681_i1 := by decide +kernel +theorem child_required_sub_681_i1 : ∀ j, childrenC_681_i1 j ⊆ insert (4, 3) required_681_i1 := by decide +kernel +theorem child_envelope_sub_681_i1 : ∀ j, childrenD_681_i1 j ⊆ envelope_681_i1 := by decide +kernel +theorem pivot_mem_681_i1 : (4, 3) ∈ envelope_681_i1 := by decide +kernel +theorem children_work_681_i1 : ∀ j, Template HasSnaky 4 (childrenC_681_i1 j) (childrenD_681_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_32 7 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_44 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_90 3 (3, 6)).mono (by decide +kernel) +theorem row_works_681_i1 : Template HasSnaky 5 required_681_i1 envelope_681_i1 := by + refine compose HasSnaky 4 childrenC_681_i1 childrenD_681_i1 children_work_681_i1 (4, 3) + required_681_i1 envelope_681_i1 pivot_mem_681_i1 child_required_sub_681_i1 child_envelope_sub_681_i1 ?_ + intro b hb + exact common_sub_681_i1 (mem_commonEnvelope childrenD_681_i1 b hb) +def required_681_i2 : Finset Cell := ⟨(([(2, 4), (3, 4), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_681_i2 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_681_i2 : Fin 2 → Finset Cell := ![(placed21 0 (3, 3) required_17), (placed21 7 (5, 6) required_32)] +def childrenD_681_i2 : Fin 2 → Finset Cell := ![(placed21 0 (3, 3) envelope_17), (placed21 7 (5, 6) envelope_32)] +theorem common_sub_681_i2 : commonEnvelope childrenD_681_i2 ⊆ insert (4, 3) required_681_i2 := by decide +kernel +theorem child_required_sub_681_i2 : ∀ j, childrenC_681_i2 j ⊆ insert (4, 3) required_681_i2 := by decide +kernel +theorem child_envelope_sub_681_i2 : ∀ j, childrenD_681_i2 j ⊆ envelope_681_i2 := by decide +kernel +theorem pivot_mem_681_i2 : (4, 3) ∈ envelope_681_i2 := by decide +kernel +theorem children_work_681_i2 : ∀ j, Template HasSnaky 4 (childrenC_681_i2 j) (childrenD_681_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_17 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_32 7 (5, 6)).mono (by decide +kernel) +theorem row_works_681_i2 : Template HasSnaky 5 required_681_i2 envelope_681_i2 := by + refine compose HasSnaky 4 childrenC_681_i2 childrenD_681_i2 children_work_681_i2 (4, 3) + required_681_i2 envelope_681_i2 pivot_mem_681_i2 child_required_sub_681_i2 child_envelope_sub_681_i2 ?_ + intro b hb + exact common_sub_681_i2 (mem_commonEnvelope childrenD_681_i2 b hb) +def required_681_i0 : Finset Cell := ⟨(([(2, 4), (3, 4), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_681_i0 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 6), (5, 7), (5, 8), (6, 3), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_681_i0 : Fin 4 → Finset Cell := ![(placed21 6 (4, 7) required_44), (placed21 6 (4, 7) required_52), required_681_i1, required_681_i2] +def childrenD_681_i0 : Fin 4 → Finset Cell := ![(placed21 6 (4, 7) envelope_44), (placed21 6 (4, 7) envelope_52), envelope_681_i1, envelope_681_i2] +theorem common_sub_681_i0 : commonEnvelope childrenD_681_i0 ⊆ insert (4, 6) required_681_i0 := by decide +kernel +theorem child_required_sub_681_i0 : ∀ j, childrenC_681_i0 j ⊆ insert (4, 6) required_681_i0 := by decide +kernel +theorem child_envelope_sub_681_i0 : ∀ j, childrenD_681_i0 j ⊆ envelope_681_i0 := by decide +kernel +theorem pivot_mem_681_i0 : (4, 6) ∈ envelope_681_i0 := by decide +kernel +theorem children_work_681_i0 : ∀ j, Template HasSnaky 5 (childrenC_681_i0 j) (childrenD_681_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (4, 7)).mono (by decide +kernel) + · exact row_works_681_i1.mono (by decide +kernel) + · exact row_works_681_i2.mono (by decide +kernel) +theorem row_works_681_i0 : Template HasSnaky 6 required_681_i0 envelope_681_i0 := by + refine compose HasSnaky 5 childrenC_681_i0 childrenD_681_i0 children_work_681_i0 (4, 6) + required_681_i0 envelope_681_i0 pivot_mem_681_i0 child_required_sub_681_i0 child_envelope_sub_681_i0 ?_ + intro b hb + exact common_sub_681_i0 (mem_commonEnvelope childrenD_681_i0 b hb) +def required_681 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_681 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (6, 3), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_681 : Fin 2 → Finset Cell := ![(placed21 1 (0, 4) required_11), required_681_i0] +def childrenD_681 : Fin 2 → Finset Cell := ![(placed21 1 (0, 4) envelope_11), envelope_681_i0] +theorem common_sub_681 : commonEnvelope childrenD_681 ⊆ insert (3, 4) required_681 := by decide +kernel +theorem child_required_sub_681 : ∀ j, childrenC_681 j ⊆ insert (3, 4) required_681 := by decide +kernel +theorem child_envelope_sub_681 : ∀ j, childrenD_681 j ⊆ envelope_681 := by decide +kernel +theorem pivot_mem_681 : (3, 4) ∈ envelope_681 := by decide +kernel +theorem children_work_681 : ∀ j, Template HasSnaky 6 (childrenC_681 j) (childrenD_681 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 1 (0, 4)).mono (by decide +kernel) + · exact row_works_681_i0.mono (by decide +kernel) +theorem row_works_681 : Template HasSnaky 7 required_681 envelope_681 := by + refine compose HasSnaky 6 childrenC_681 childrenD_681 children_work_681 (3, 4) + required_681 envelope_681 pivot_mem_681 child_required_sub_681 child_envelope_sub_681 ?_ + intro b hb + exact common_sub_681 (mem_commonEnvelope childrenD_681 b hb) +def height_681_i1 : ℕ := 5 +def childrenH_681_i1 : Fin 3 → ℕ := ![height_32, height_44, height_90] +theorem height_exact_681_i1 : height_681_i1 = 1 + Finset.univ.sup childrenH_681_i1 := by decide +kernel +theorem required_origin_681_i1 : ∀ x ∈ required_681_i1, + (∃ j, x ∈ childrenC_681_i1 j) ∨ ∀ j, x ∈ childrenD_681_i1 j := by decide +kernel +theorem required_exact_681_i1 : required_681_i1 = + ((Finset.univ.biUnion childrenC_681_i1) ∪ commonEnvelope childrenD_681_i1).erase (4, 3) := by + exact required_eq_combination childrenC_681_i1 childrenD_681_i1 (4, 3) required_681_i1 + (by decide +kernel) child_required_sub_681_i1 common_sub_681_i1 required_origin_681_i1 +theorem envelope_origin_681_i1 : ∀ x ∈ envelope_681_i1, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_681_i1 j := by decide +kernel +theorem envelope_exact_681_i1 : envelope_681_i1 = + insert (4, 3) (Finset.univ.biUnion childrenD_681_i1) := by + exact envelope_eq_combination childrenD_681_i1 (4, 3) envelope_681_i1 + pivot_mem_681_i1 child_envelope_sub_681_i1 envelope_origin_681_i1 +def checked_681_i1 : CheckedCard where + required := required_681_i1 + envelope := envelope_681_i1 + height := height_681_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_681_i1 +def height_681_i2 : ℕ := 5 +def childrenH_681_i2 : Fin 2 → ℕ := ![height_17, height_32] +theorem height_exact_681_i2 : height_681_i2 = 1 + Finset.univ.sup childrenH_681_i2 := by decide +kernel +theorem required_origin_681_i2 : ∀ x ∈ required_681_i2, + (∃ j, x ∈ childrenC_681_i2 j) ∨ ∀ j, x ∈ childrenD_681_i2 j := by decide +kernel +theorem required_exact_681_i2 : required_681_i2 = + ((Finset.univ.biUnion childrenC_681_i2) ∪ commonEnvelope childrenD_681_i2).erase (4, 3) := by + exact required_eq_combination childrenC_681_i2 childrenD_681_i2 (4, 3) required_681_i2 + (by decide +kernel) child_required_sub_681_i2 common_sub_681_i2 required_origin_681_i2 +theorem envelope_origin_681_i2 : ∀ x ∈ envelope_681_i2, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_681_i2 j := by decide +kernel +theorem envelope_exact_681_i2 : envelope_681_i2 = + insert (4, 3) (Finset.univ.biUnion childrenD_681_i2) := by + exact envelope_eq_combination childrenD_681_i2 (4, 3) envelope_681_i2 + pivot_mem_681_i2 child_envelope_sub_681_i2 envelope_origin_681_i2 +def checked_681_i2 : CheckedCard where + required := required_681_i2 + envelope := envelope_681_i2 + height := height_681_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_681_i2 +def height_681_i0 : ℕ := 6 +def childrenH_681_i0 : Fin 4 → ℕ := ![height_44, height_52, height_681_i1, height_681_i2] +theorem height_exact_681_i0 : height_681_i0 = 1 + Finset.univ.sup childrenH_681_i0 := by decide +kernel +theorem required_origin_681_i0 : ∀ x ∈ required_681_i0, + (∃ j, x ∈ childrenC_681_i0 j) ∨ ∀ j, x ∈ childrenD_681_i0 j := by decide +kernel +theorem required_exact_681_i0 : required_681_i0 = + ((Finset.univ.biUnion childrenC_681_i0) ∪ commonEnvelope childrenD_681_i0).erase (4, 6) := by + exact required_eq_combination childrenC_681_i0 childrenD_681_i0 (4, 6) required_681_i0 + (by decide +kernel) child_required_sub_681_i0 common_sub_681_i0 required_origin_681_i0 +theorem envelope_origin_681_i0 : ∀ x ∈ envelope_681_i0, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_681_i0 j := by decide +kernel +theorem envelope_exact_681_i0 : envelope_681_i0 = + insert (4, 6) (Finset.univ.biUnion childrenD_681_i0) := by + exact envelope_eq_combination childrenD_681_i0 (4, 6) envelope_681_i0 + pivot_mem_681_i0 child_envelope_sub_681_i0 envelope_origin_681_i0 +def checked_681_i0 : CheckedCard where + required := required_681_i0 + envelope := envelope_681_i0 + height := height_681_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_681_i0 +def height_681 : ℕ := 7 +def childrenH_681 : Fin 2 → ℕ := ![height_11, height_681_i0] +theorem height_exact_681 : height_681 = 1 + Finset.univ.sup childrenH_681 := by decide +kernel +theorem required_origin_681 : ∀ x ∈ required_681, + (∃ j, x ∈ childrenC_681 j) ∨ ∀ j, x ∈ childrenD_681 j := by decide +kernel +theorem required_exact_681 : required_681 = + ((Finset.univ.biUnion childrenC_681) ∪ commonEnvelope childrenD_681).erase (3, 4) := by + exact required_eq_combination childrenC_681 childrenD_681 (3, 4) required_681 + (by decide +kernel) child_required_sub_681 common_sub_681 required_origin_681 +theorem envelope_origin_681 : ∀ x ∈ envelope_681, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_681 j := by decide +kernel +theorem envelope_exact_681 : envelope_681 = + insert (3, 4) (Finset.univ.biUnion childrenD_681) := by + exact envelope_eq_combination childrenD_681 (3, 4) envelope_681 + pivot_mem_681 child_envelope_sub_681 envelope_origin_681 +def checked_681 : CheckedCard where + required := required_681 + envelope := envelope_681 + height := height_681 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_681 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part01.lean new file mode 100644 index 0000000..8569f30 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part01.lean @@ -0,0 +1,978 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_120 : Finset Cell := ⟨(([(1, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_120 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_120 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) required_44), (placed21 3 (0, 3) required_52), required_116] +def childrenD_120 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) envelope_44), (placed21 3 (0, 3) envelope_52), envelope_116] +theorem common_sub_120 : commonEnvelope childrenD_120 ⊆ insert (2, 3) required_120 := by decide +kernel +theorem child_required_sub_120 : ∀ j, childrenC_120 j ⊆ insert (2, 3) required_120 := by decide +kernel +theorem child_envelope_sub_120 : ∀ j, childrenD_120 j ⊆ envelope_120 := by decide +kernel +theorem pivot_mem_120 : (2, 3) ∈ envelope_120 := by decide +kernel +theorem children_work_120 : ∀ j, Template HasSnaky 7 (childrenC_120 j) (childrenD_120 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_52 3 (0, 3)).mono (by decide +kernel) + · exact row_works_116.mono (by decide +kernel) +theorem row_works_120 : Template HasSnaky 8 required_120 envelope_120 := by + refine compose HasSnaky 7 childrenC_120 childrenD_120 children_work_120 (2, 3) + required_120 envelope_120 pivot_mem_120 child_required_sub_120 child_envelope_sub_120 ?_ + intro b hb + exact common_sub_120 (mem_commonEnvelope childrenD_120 b hb) +def required_171 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_171 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_171 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) required_6), (placed21 4 (1, 4) required_26), (placed21 0 (1, 0) required_116)] +def childrenD_171 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) envelope_6), (placed21 4 (1, 4) envelope_26), (placed21 0 (1, 0) envelope_116)] +theorem common_sub_171 : commonEnvelope childrenD_171 ⊆ insert (4, 3) required_171 := by decide +kernel +theorem child_required_sub_171 : ∀ j, childrenC_171 j ⊆ insert (4, 3) required_171 := by decide +kernel +theorem child_envelope_sub_171 : ∀ j, childrenD_171 j ⊆ envelope_171 := by decide +kernel +theorem pivot_mem_171 : (4, 3) ∈ envelope_171 := by decide +kernel +theorem children_work_171 : ∀ j, Template HasSnaky 7 (childrenC_171 j) (childrenD_171 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_26 4 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_116 0 (1, 0)).mono (by decide +kernel) +theorem row_works_171 : Template HasSnaky 8 required_171 envelope_171 := by + refine compose HasSnaky 7 childrenC_171 childrenD_171 children_work_171 (4, 3) + required_171 envelope_171 pivot_mem_171 child_required_sub_171 child_envelope_sub_171 ?_ + intro b hb + exact common_sub_171 (mem_commonEnvelope childrenD_171 b hb) +def required_174 : Finset Cell := ⟨(([(3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_174 : Finset Cell := ⟨(([(0, 2), (0, 4), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_174 : Fin 6 → Finset Cell := ![(placed21 1 (0, 2) required_116), (placed21 3 (0, 6) required_117), (placed21 0 (1, 1) required_135), (placed21 6 (5, 7) required_135), (placed21 3 (0, 6) required_173), (placed21 5 (6, 2) required_173)] +def childrenD_174 : Fin 6 → Finset Cell := ![(placed21 1 (0, 2) envelope_116), (placed21 3 (0, 6) envelope_117), (placed21 0 (1, 1) envelope_135), (placed21 6 (5, 7) envelope_135), (placed21 3 (0, 6) envelope_173), (placed21 5 (6, 2) envelope_173)] +theorem common_sub_174 : commonEnvelope childrenD_174 ⊆ insert (3, 5) required_174 := by decide +kernel +theorem child_required_sub_174 : ∀ j, childrenC_174 j ⊆ insert (3, 5) required_174 := by decide +kernel +theorem child_envelope_sub_174 : ∀ j, childrenD_174 j ⊆ envelope_174 := by decide +kernel +theorem pivot_mem_174 : (3, 5) ∈ envelope_174 := by decide +kernel +theorem children_work_174 : ∀ j, Template HasSnaky 7 (childrenC_174 j) (childrenD_174 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_116 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_117 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_135 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_135 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_173 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_173 5 (6, 2)).mono (by decide +kernel) +theorem row_works_174 : Template HasSnaky 8 required_174 envelope_174 := by + refine compose HasSnaky 7 childrenC_174 childrenD_174 children_work_174 (3, 5) + required_174 envelope_174 pivot_mem_174 child_required_sub_174 child_envelope_sub_174 ?_ + intro b hb + exact common_sub_174 (mem_commonEnvelope childrenD_174 b hb) +def required_257 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_257 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_257 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) required_7), (placed21 3 (0, 4) required_9), (placed21 0 (1, 0) required_256)] +def childrenD_257 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) envelope_7), (placed21 3 (0, 4) envelope_9), (placed21 0 (1, 0) envelope_256)] +theorem common_sub_257 : commonEnvelope childrenD_257 ⊆ insert (4, 3) required_257 := by decide +kernel +theorem child_required_sub_257 : ∀ j, childrenC_257 j ⊆ insert (4, 3) required_257 := by decide +kernel +theorem child_envelope_sub_257 : ∀ j, childrenD_257 j ⊆ envelope_257 := by decide +kernel +theorem pivot_mem_257 : (4, 3) ∈ envelope_257 := by decide +kernel +theorem children_work_257 : ∀ j, Template HasSnaky 7 (childrenC_257 j) (childrenD_257 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_256 0 (1, 0)).mono (by decide +kernel) +theorem row_works_257 : Template HasSnaky 8 required_257 envelope_257 := by + refine compose HasSnaky 7 childrenC_257 childrenD_257 children_work_257 (4, 3) + required_257 envelope_257 pivot_mem_257 child_required_sub_257 child_envelope_sub_257 ?_ + intro b hb + exact common_sub_257 (mem_commonEnvelope childrenD_257 b hb) +def required_258 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_258 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_258 : Fin 4 → Finset Cell := ![(placed21 0 (0, 2) required_8), (placed21 4 (0, 6) required_161), (placed21 4 (0, 6) required_162), required_256] +def childrenD_258 : Fin 4 → Finset Cell := ![(placed21 0 (0, 2) envelope_8), (placed21 4 (0, 6) envelope_161), (placed21 4 (0, 6) envelope_162), envelope_256] +theorem common_sub_258 : commonEnvelope childrenD_258 ⊆ insert (3, 3) required_258 := by decide +kernel +theorem child_required_sub_258 : ∀ j, childrenC_258 j ⊆ insert (3, 3) required_258 := by decide +kernel +theorem child_envelope_sub_258 : ∀ j, childrenD_258 j ⊆ envelope_258 := by decide +kernel +theorem pivot_mem_258 : (3, 3) ∈ envelope_258 := by decide +kernel +theorem children_work_258 : ∀ j, Template HasSnaky 7 (childrenC_258 j) (childrenD_258 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_161 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_162 4 (0, 6)).mono (by decide +kernel) + · exact row_works_256.mono (by decide +kernel) +theorem row_works_258 : Template HasSnaky 8 required_258 envelope_258 := by + refine compose HasSnaky 7 childrenC_258 childrenD_258 children_work_258 (3, 3) + required_258 envelope_258 pivot_mem_258 child_required_sub_258 child_envelope_sub_258 ?_ + intro b hb + exact common_sub_258 (mem_commonEnvelope childrenD_258 b hb) +def required_285 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_285 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_285 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) required_6), (placed21 0 (1, 2) required_26), (placed21 0 (1, 0) required_117)] +def childrenD_285 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) envelope_6), (placed21 0 (1, 2) envelope_26), (placed21 0 (1, 0) envelope_117)] +theorem common_sub_285 : commonEnvelope childrenD_285 ⊆ insert (4, 3) required_285 := by decide +kernel +theorem child_required_sub_285 : ∀ j, childrenC_285 j ⊆ insert (4, 3) required_285 := by decide +kernel +theorem child_envelope_sub_285 : ∀ j, childrenD_285 j ⊆ envelope_285 := by decide +kernel +theorem pivot_mem_285 : (4, 3) ∈ envelope_285 := by decide +kernel +theorem children_work_285 : ∀ j, Template HasSnaky 7 (childrenC_285 j) (childrenD_285 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_26 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_117 0 (1, 0)).mono (by decide +kernel) +theorem row_works_285 : Template HasSnaky 8 required_285 envelope_285 := by + refine compose HasSnaky 7 childrenC_285 childrenD_285 children_work_285 (4, 3) + required_285 envelope_285 pivot_mem_285 child_required_sub_285 child_envelope_sub_285 ?_ + intro b hb + exact common_sub_285 (mem_commonEnvelope childrenD_285 b hb) +def required_319 : Finset Cell := ⟨(([(1, 5), (2, 3), (2, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_319 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_319 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) required_52), (placed21 0 (2, 0) required_318)] +def childrenD_319 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) envelope_52), (placed21 0 (2, 0) envelope_318)] +theorem common_sub_319 : commonEnvelope childrenD_319 ⊆ insert (3, 4) required_319 := by decide +kernel +theorem child_required_sub_319 : ∀ j, childrenC_319 j ⊆ insert (3, 4) required_319 := by decide +kernel +theorem child_envelope_sub_319 : ∀ j, childrenD_319 j ⊆ envelope_319 := by decide +kernel +theorem pivot_mem_319 : (3, 4) ∈ envelope_319 := by decide +kernel +theorem children_work_319 : ∀ j, Template HasSnaky 7 (childrenC_319 j) (childrenD_319 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_318 0 (2, 0)).mono (by decide +kernel) +theorem row_works_319 : Template HasSnaky 8 required_319 envelope_319 := by + refine compose HasSnaky 7 childrenC_319 childrenD_319 children_work_319 (3, 4) + required_319 envelope_319 pivot_mem_319 child_required_sub_319 child_envelope_sub_319 ?_ + intro b hb + exact common_sub_319 (mem_commonEnvelope childrenD_319 b hb) +def required_321 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_321 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_321 : Fin 2 → Finset Cell := ![(placed21 4 (0, 4) required_5), required_320] +def childrenD_321 : Fin 2 → Finset Cell := ![(placed21 4 (0, 4) envelope_5), envelope_320] +theorem common_sub_321 : commonEnvelope childrenD_321 ⊆ insert (3, 3) required_321 := by decide +kernel +theorem child_required_sub_321 : ∀ j, childrenC_321 j ⊆ insert (3, 3) required_321 := by decide +kernel +theorem child_envelope_sub_321 : ∀ j, childrenD_321 j ⊆ envelope_321 := by decide +kernel +theorem pivot_mem_321 : (3, 3) ∈ envelope_321 := by decide +kernel +theorem children_work_321 : ∀ j, Template HasSnaky 7 (childrenC_321 j) (childrenD_321 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 4)).mono (by decide +kernel) + · exact row_works_320.mono (by decide +kernel) +theorem row_works_321 : Template HasSnaky 8 required_321 envelope_321 := by + refine compose HasSnaky 7 childrenC_321 childrenD_321 children_work_321 (3, 3) + required_321 envelope_321 pivot_mem_321 child_required_sub_321 child_envelope_sub_321 ?_ + intro b hb + exact common_sub_321 (mem_commonEnvelope childrenD_321 b hb) +def required_323 : Finset Cell := ⟨(([(1, 3), (1, 4), (3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_323 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (4, 3), (4, 4), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_323 : Fin 2 → Finset Cell := ![(placed21 7 (5, 4) required_11), (placed21 2 (4, 0) required_320)] +def childrenD_323 : Fin 2 → Finset Cell := ![(placed21 7 (5, 4) envelope_11), (placed21 2 (4, 0) envelope_320)] +theorem common_sub_323 : commonEnvelope childrenD_323 ⊆ insert (2, 4) required_323 := by decide +kernel +theorem child_required_sub_323 : ∀ j, childrenC_323 j ⊆ insert (2, 4) required_323 := by decide +kernel +theorem child_envelope_sub_323 : ∀ j, childrenD_323 j ⊆ envelope_323 := by decide +kernel +theorem pivot_mem_323 : (2, 4) ∈ envelope_323 := by decide +kernel +theorem children_work_323 : ∀ j, Template HasSnaky 7 (childrenC_323 j) (childrenD_323 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 7 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_320 2 (4, 0)).mono (by decide +kernel) +theorem row_works_323 : Template HasSnaky 8 required_323 envelope_323 := by + refine compose HasSnaky 7 childrenC_323 childrenD_323 children_work_323 (2, 4) + required_323 envelope_323 pivot_mem_323 child_required_sub_323 child_envelope_sub_323 ?_ + intro b hb + exact common_sub_323 (mem_commonEnvelope childrenD_323 b hb) +def required_338 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_338 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_338 : Fin 3 → Finset Cell := ![(placed21 6 (2, 6) required_44), (placed21 3 (0, 6) required_47), (placed21 0 (1, 0) required_337)] +def childrenD_338 : Fin 3 → Finset Cell := ![(placed21 6 (2, 6) envelope_44), (placed21 3 (0, 6) envelope_47), (placed21 0 (1, 0) envelope_337)] +theorem common_sub_338 : commonEnvelope childrenD_338 ⊆ insert (2, 4) required_338 := by decide +kernel +theorem child_required_sub_338 : ∀ j, childrenC_338 j ⊆ insert (2, 4) required_338 := by decide +kernel +theorem child_envelope_sub_338 : ∀ j, childrenD_338 j ⊆ envelope_338 := by decide +kernel +theorem pivot_mem_338 : (2, 4) ∈ envelope_338 := by decide +kernel +theorem children_work_338 : ∀ j, Template HasSnaky 7 (childrenC_338 j) (childrenD_338 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_47 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_337 0 (1, 0)).mono (by decide +kernel) +theorem row_works_338 : Template HasSnaky 8 required_338 envelope_338 := by + refine compose HasSnaky 7 childrenC_338 childrenD_338 children_work_338 (2, 4) + required_338 envelope_338 pivot_mem_338 child_required_sub_338 child_envelope_sub_338 ?_ + intro b hb + exact common_sub_338 (mem_commonEnvelope childrenD_338 b hb) +def required_345 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_345 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_345 : Fin 3 → Finset Cell := ![(placed21 0 (1, 1) required_8), (placed21 1 (0, 2) required_11), required_344] +def childrenD_345 : Fin 3 → Finset Cell := ![(placed21 0 (1, 1) envelope_8), (placed21 1 (0, 2) envelope_11), envelope_344] +theorem common_sub_345 : commonEnvelope childrenD_345 ⊆ insert (4, 2) required_345 := by decide +kernel +theorem child_required_sub_345 : ∀ j, childrenC_345 j ⊆ insert (4, 2) required_345 := by decide +kernel +theorem child_envelope_sub_345 : ∀ j, childrenD_345 j ⊆ envelope_345 := by decide +kernel +theorem pivot_mem_345 : (4, 2) ∈ envelope_345 := by decide +kernel +theorem children_work_345 : ∀ j, Template HasSnaky 7 (childrenC_345 j) (childrenD_345 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_11 1 (0, 2)).mono (by decide +kernel) + · exact row_works_344.mono (by decide +kernel) +theorem row_works_345 : Template HasSnaky 8 required_345 envelope_345 := by + refine compose HasSnaky 7 childrenC_345 childrenD_345 children_work_345 (4, 2) + required_345 envelope_345 pivot_mem_345 child_required_sub_345 child_envelope_sub_345 ?_ + intro b hb + exact common_sub_345 (mem_commonEnvelope childrenD_345 b hb) +def required_373 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_373 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (6, 0), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_373 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), required_372] +def childrenD_373 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), envelope_372] +theorem common_sub_373 : commonEnvelope childrenD_373 ⊆ insert (1, 4) required_373 := by decide +kernel +theorem child_required_sub_373 : ∀ j, childrenC_373 j ⊆ insert (1, 4) required_373 := by decide +kernel +theorem child_envelope_sub_373 : ∀ j, childrenD_373 j ⊆ envelope_373 := by decide +kernel +theorem pivot_mem_373 : (1, 4) ∈ envelope_373 := by decide +kernel +theorem children_work_373 : ∀ j, Template HasSnaky 7 (childrenC_373 j) (childrenD_373 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact row_works_372.mono (by decide +kernel) +theorem row_works_373 : Template HasSnaky 8 required_373 envelope_373 := by + refine compose HasSnaky 7 childrenC_373 childrenD_373 children_work_373 (1, 4) + required_373 envelope_373 pivot_mem_373 child_required_sub_373 child_envelope_sub_373 ?_ + intro b hb + exact common_sub_373 (mem_commonEnvelope childrenD_373 b hb) +def required_395_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_395_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 4), (4, 5), (4, 6), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_395_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_5), (placed21 0 (1, 0) required_217)] +def childrenD_395_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_5), (placed21 0 (1, 0) envelope_217)] +theorem common_sub_395_i0 : commonEnvelope childrenD_395_i0 ⊆ insert (3, 1) required_395_i0 := by decide +kernel +theorem child_required_sub_395_i0 : ∀ j, childrenC_395_i0 j ⊆ insert (3, 1) required_395_i0 := by decide +kernel +theorem child_envelope_sub_395_i0 : ∀ j, childrenD_395_i0 j ⊆ envelope_395_i0 := by decide +kernel +theorem pivot_mem_395_i0 : (3, 1) ∈ envelope_395_i0 := by decide +kernel +theorem children_work_395_i0 : ∀ j, Template HasSnaky 6 (childrenC_395_i0 j) (childrenD_395_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_217 0 (1, 0)).mono (by decide +kernel) +theorem row_works_395_i0 : Template HasSnaky 7 required_395_i0 envelope_395_i0 := by + refine compose HasSnaky 6 childrenC_395_i0 childrenD_395_i0 children_work_395_i0 (3, 1) + required_395_i0 envelope_395_i0 pivot_mem_395_i0 child_required_sub_395_i0 child_envelope_sub_395_i0 ?_ + intro b hb + exact common_sub_395_i0 (mem_commonEnvelope childrenD_395_i0 b hb) +def required_395 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_395 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 3), (4, 4), (4, 5), (4, 6), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_395 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_5), required_395_i0] +def childrenD_395 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_5), envelope_395_i0] +theorem common_sub_395 : commonEnvelope childrenD_395 ⊆ insert (3, 3) required_395 := by decide +kernel +theorem child_required_sub_395 : ∀ j, childrenC_395 j ⊆ insert (3, 3) required_395 := by decide +kernel +theorem child_envelope_sub_395 : ∀ j, childrenD_395 j ⊆ envelope_395 := by decide +kernel +theorem pivot_mem_395 : (3, 3) ∈ envelope_395 := by decide +kernel +theorem children_work_395 : ∀ j, Template HasSnaky 7 (childrenC_395 j) (childrenD_395 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 2)).mono (by decide +kernel) + · exact row_works_395_i0.mono (by decide +kernel) +theorem row_works_395 : Template HasSnaky 8 required_395 envelope_395 := by + refine compose HasSnaky 7 childrenC_395 childrenD_395 children_work_395 (3, 3) + required_395 envelope_395 pivot_mem_395 child_required_sub_395 child_envelope_sub_395 ?_ + intro b hb + exact common_sub_395 (mem_commonEnvelope childrenD_395 b hb) +def required_405 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_405 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_405 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) required_0), required_404] +def childrenD_405 : Fin 2 → Finset Cell := ![(placed21 7 (1, 5) envelope_0), envelope_404] +theorem common_sub_405 : commonEnvelope childrenD_405 ⊆ insert (1, 4) required_405 := by decide +kernel +theorem child_required_sub_405 : ∀ j, childrenC_405 j ⊆ insert (1, 4) required_405 := by decide +kernel +theorem child_envelope_sub_405 : ∀ j, childrenD_405 j ⊆ envelope_405 := by decide +kernel +theorem pivot_mem_405 : (1, 4) ∈ envelope_405 := by decide +kernel +theorem children_work_405 : ∀ j, Template HasSnaky 7 (childrenC_405 j) (childrenD_405 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (1, 5)).mono (by decide +kernel) + · exact row_works_404.mono (by decide +kernel) +theorem row_works_405 : Template HasSnaky 8 required_405 envelope_405 := by + refine compose HasSnaky 7 childrenC_405 childrenD_405 children_work_405 (1, 4) + required_405 envelope_405 pivot_mem_405 child_required_sub_405 child_envelope_sub_405 ?_ + intro b hb + exact common_sub_405 (mem_commonEnvelope childrenD_405 b hb) +def required_412_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_412_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_412_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_0), required_358] +def childrenD_412_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_0), envelope_358] +theorem common_sub_412_i0 : commonEnvelope childrenD_412_i0 ⊆ insert (3, 1) required_412_i0 := by decide +kernel +theorem child_required_sub_412_i0 : ∀ j, childrenC_412_i0 j ⊆ insert (3, 1) required_412_i0 := by decide +kernel +theorem child_envelope_sub_412_i0 : ∀ j, childrenD_412_i0 j ⊆ envelope_412_i0 := by decide +kernel +theorem pivot_mem_412_i0 : (3, 1) ∈ envelope_412_i0 := by decide +kernel +theorem children_work_412_i0 : ∀ j, Template HasSnaky 6 (childrenC_412_i0 j) (childrenD_412_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact row_works_358.mono (by decide +kernel) +theorem row_works_412_i0 : Template HasSnaky 7 required_412_i0 envelope_412_i0 := by + refine compose HasSnaky 6 childrenC_412_i0 childrenD_412_i0 children_work_412_i0 (3, 1) + required_412_i0 envelope_412_i0 pivot_mem_412_i0 child_required_sub_412_i0 child_envelope_sub_412_i0 ?_ + intro b hb + exact common_sub_412_i0 (mem_commonEnvelope childrenD_412_i0 b hb) +def required_412 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_412 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_412 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), required_412_i0] +def childrenD_412 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), envelope_412_i0] +theorem common_sub_412 : commonEnvelope childrenD_412 ⊆ insert (2, 1) required_412 := by decide +kernel +theorem child_required_sub_412 : ∀ j, childrenC_412 j ⊆ insert (2, 1) required_412 := by decide +kernel +theorem child_envelope_sub_412 : ∀ j, childrenD_412 j ⊆ envelope_412 := by decide +kernel +theorem pivot_mem_412 : (2, 1) ∈ envelope_412 := by decide +kernel +theorem children_work_412 : ∀ j, Template HasSnaky 7 (childrenC_412 j) (childrenD_412 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact row_works_412_i0.mono (by decide +kernel) +theorem row_works_412 : Template HasSnaky 8 required_412 envelope_412 := by + refine compose HasSnaky 7 childrenC_412 childrenD_412 children_work_412 (2, 1) + required_412 envelope_412 pivot_mem_412 child_required_sub_412 child_envelope_sub_412 ?_ + intro b hb + exact common_sub_412 (mem_commonEnvelope childrenD_412 b hb) +def required_419 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_419 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_419 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), (placed21 1 (0, 1) required_418)] +def childrenD_419 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), (placed21 1 (0, 1) envelope_418)] +theorem common_sub_419 : commonEnvelope childrenD_419 ⊆ insert (2, 1) required_419 := by decide +kernel +theorem child_required_sub_419 : ∀ j, childrenC_419 j ⊆ insert (2, 1) required_419 := by decide +kernel +theorem child_envelope_sub_419 : ∀ j, childrenD_419 j ⊆ envelope_419 := by decide +kernel +theorem pivot_mem_419 : (2, 1) ∈ envelope_419 := by decide +kernel +theorem children_work_419 : ∀ j, Template HasSnaky 7 (childrenC_419 j) (childrenD_419 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_418 1 (0, 1)).mono (by decide +kernel) +theorem row_works_419 : Template HasSnaky 8 required_419 envelope_419 := by + refine compose HasSnaky 7 childrenC_419 childrenD_419 children_work_419 (2, 1) + required_419 envelope_419 pivot_mem_419 child_required_sub_419 child_envelope_sub_419 ?_ + intro b hb + exact common_sub_419 (mem_commonEnvelope childrenD_419 b hb) +def required_420 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_420 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_420 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_0), required_418] +def childrenD_420 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_0), envelope_418] +theorem common_sub_420 : commonEnvelope childrenD_420 ⊆ insert (3, 1) required_420 := by decide +kernel +theorem child_required_sub_420 : ∀ j, childrenC_420 j ⊆ insert (3, 1) required_420 := by decide +kernel +theorem child_envelope_sub_420 : ∀ j, childrenD_420 j ⊆ envelope_420 := by decide +kernel +theorem pivot_mem_420 : (3, 1) ∈ envelope_420 := by decide +kernel +theorem children_work_420 : ∀ j, Template HasSnaky 7 (childrenC_420 j) (childrenD_420 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact row_works_418.mono (by decide +kernel) +theorem row_works_420 : Template HasSnaky 8 required_420 envelope_420 := by + refine compose HasSnaky 7 childrenC_420 childrenD_420 children_work_420 (3, 1) + required_420 envelope_420 pivot_mem_420 child_required_sub_420 child_envelope_sub_420 ?_ + intro b hb + exact common_sub_420 (mem_commonEnvelope childrenD_420 b hb) +def required_438 : Finset Cell := ⟨(([(3, 3), (3, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_438 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 2), (7, 4), (7, 6), (8, 2), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_438 : Fin 3 → Finset Cell := ![(placed21 7 (6, 4) required_10), (placed21 6 (6, 5) required_47), (placed21 0 (2, 0) required_436)] +def childrenD_438 : Fin 3 → Finset Cell := ![(placed21 7 (6, 4) envelope_10), (placed21 6 (6, 5) envelope_47), (placed21 0 (2, 0) envelope_436)] +theorem common_sub_438 : commonEnvelope childrenD_438 ⊆ insert (4, 3) required_438 := by decide +kernel +theorem child_required_sub_438 : ∀ j, childrenC_438 j ⊆ insert (4, 3) required_438 := by decide +kernel +theorem child_envelope_sub_438 : ∀ j, childrenD_438 j ⊆ envelope_438 := by decide +kernel +theorem pivot_mem_438 : (4, 3) ∈ envelope_438 := by decide +kernel +theorem children_work_438 : ∀ j, Template HasSnaky 7 (childrenC_438 j) (childrenD_438 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 7 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_47 6 (6, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_436 0 (2, 0)).mono (by decide +kernel) +theorem row_works_438 : Template HasSnaky 8 required_438 envelope_438 := by + refine compose HasSnaky 7 childrenC_438 childrenD_438 children_work_438 (4, 3) + required_438 envelope_438 pivot_mem_438 child_required_sub_438 child_envelope_sub_438 ?_ + intro b hb + exact common_sub_438 (mem_commonEnvelope childrenD_438 b hb) +def required_440_i0 : Finset Cell := ⟨(([(0, 1), (1, 2), (1, 3), (1, 4), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_440_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_440_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), (placed21 7 (5, 4) required_439)] +def childrenD_440_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), (placed21 7 (5, 4) envelope_439)] +theorem common_sub_440_i0 : commonEnvelope childrenD_440_i0 ⊆ insert (1, 1) required_440_i0 := by decide +kernel +theorem child_required_sub_440_i0 : ∀ j, childrenC_440_i0 j ⊆ insert (1, 1) required_440_i0 := by decide +kernel +theorem child_envelope_sub_440_i0 : ∀ j, childrenD_440_i0 j ⊆ envelope_440_i0 := by decide +kernel +theorem pivot_mem_440_i0 : (1, 1) ∈ envelope_440_i0 := by decide +kernel +theorem children_work_440_i0 : ∀ j, Template HasSnaky 6 (childrenC_440_i0 j) (childrenD_440_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_439 7 (5, 4)).mono (by decide +kernel) +theorem row_works_440_i0 : Template HasSnaky 7 required_440_i0 envelope_440_i0 := by + refine compose HasSnaky 6 childrenC_440_i0 childrenD_440_i0 children_work_440_i0 (1, 1) + required_440_i0 envelope_440_i0 pivot_mem_440_i0 child_required_sub_440_i0 child_envelope_sub_440_i0 ?_ + intro b hb + exact common_sub_440_i0 (mem_commonEnvelope childrenD_440_i0 b hb) +def required_440 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_440 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_440 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_18), required_440_i0] +def childrenD_440 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_18), envelope_440_i0] +theorem common_sub_440 : commonEnvelope childrenD_440 ⊆ insert (0, 1) required_440 := by decide +kernel +theorem child_required_sub_440 : ∀ j, childrenC_440 j ⊆ insert (0, 1) required_440 := by decide +kernel +theorem child_envelope_sub_440 : ∀ j, childrenD_440 j ⊆ envelope_440 := by decide +kernel +theorem pivot_mem_440 : (0, 1) ∈ envelope_440 := by decide +kernel +theorem children_work_440 : ∀ j, Template HasSnaky 7 (childrenC_440 j) (childrenD_440 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 0 (0, 1)).mono (by decide +kernel) + · exact row_works_440_i0.mono (by decide +kernel) +theorem row_works_440 : Template HasSnaky 8 required_440 envelope_440 := by + refine compose HasSnaky 7 childrenC_440 childrenD_440 children_work_440 (0, 1) + required_440 envelope_440 pivot_mem_440 child_required_sub_440 child_envelope_sub_440 ?_ + intro b hb + exact common_sub_440 (mem_commonEnvelope childrenD_440 b hb) +def required_448 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_448 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_448 : Fin 2 → Finset Cell := ![(placed21 6 (4, 6) required_56), (placed21 1 (0, 2) required_447)] +def childrenD_448 : Fin 2 → Finset Cell := ![(placed21 6 (4, 6) envelope_56), (placed21 1 (0, 2) envelope_447)] +theorem common_sub_448 : commonEnvelope childrenD_448 ⊆ insert (1, 3) required_448 := by decide +kernel +theorem child_required_sub_448 : ∀ j, childrenC_448 j ⊆ insert (1, 3) required_448 := by decide +kernel +theorem child_envelope_sub_448 : ∀ j, childrenD_448 j ⊆ envelope_448 := by decide +kernel +theorem pivot_mem_448 : (1, 3) ∈ envelope_448 := by decide +kernel +theorem children_work_448 : ∀ j, Template HasSnaky 7 (childrenC_448 j) (childrenD_448 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_56 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_447 1 (0, 2)).mono (by decide +kernel) +theorem row_works_448 : Template HasSnaky 8 required_448 envelope_448 := by + refine compose HasSnaky 7 childrenC_448 childrenD_448 children_work_448 (1, 3) + required_448 envelope_448 pivot_mem_448 child_required_sub_448 child_envelope_sub_448 ?_ + intro b hb + exact common_sub_448 (mem_commonEnvelope childrenD_448 b hb) +def height_120 : ℕ := 8 +def childrenH_120 : Fin 3 → ℕ := ![height_44, height_52, height_116] +theorem height_exact_120 : height_120 = 1 + Finset.univ.sup childrenH_120 := by decide +kernel +theorem required_origin_120 : ∀ x ∈ required_120, + (∃ j, x ∈ childrenC_120 j) ∨ ∀ j, x ∈ childrenD_120 j := by decide +kernel +theorem required_exact_120 : required_120 = + ((Finset.univ.biUnion childrenC_120) ∪ commonEnvelope childrenD_120).erase (2, 3) := by + exact required_eq_combination childrenC_120 childrenD_120 (2, 3) required_120 + (by decide +kernel) child_required_sub_120 common_sub_120 required_origin_120 +theorem envelope_origin_120 : ∀ x ∈ envelope_120, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_120 j := by decide +kernel +theorem envelope_exact_120 : envelope_120 = + insert (2, 3) (Finset.univ.biUnion childrenD_120) := by + exact envelope_eq_combination childrenD_120 (2, 3) envelope_120 + pivot_mem_120 child_envelope_sub_120 envelope_origin_120 +def checked_120 : CheckedCard where + required := required_120 + envelope := envelope_120 + height := height_120 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_120 +def height_171 : ℕ := 8 +def childrenH_171 : Fin 3 → ℕ := ![height_6, height_26, height_116] +theorem height_exact_171 : height_171 = 1 + Finset.univ.sup childrenH_171 := by decide +kernel +theorem required_origin_171 : ∀ x ∈ required_171, + (∃ j, x ∈ childrenC_171 j) ∨ ∀ j, x ∈ childrenD_171 j := by decide +kernel +theorem required_exact_171 : required_171 = + ((Finset.univ.biUnion childrenC_171) ∪ commonEnvelope childrenD_171).erase (4, 3) := by + exact required_eq_combination childrenC_171 childrenD_171 (4, 3) required_171 + (by decide +kernel) child_required_sub_171 common_sub_171 required_origin_171 +theorem envelope_origin_171 : ∀ x ∈ envelope_171, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_171 j := by decide +kernel +theorem envelope_exact_171 : envelope_171 = + insert (4, 3) (Finset.univ.biUnion childrenD_171) := by + exact envelope_eq_combination childrenD_171 (4, 3) envelope_171 + pivot_mem_171 child_envelope_sub_171 envelope_origin_171 +def checked_171 : CheckedCard where + required := required_171 + envelope := envelope_171 + height := height_171 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_171 +def height_174 : ℕ := 8 +def childrenH_174 : Fin 6 → ℕ := ![height_116, height_117, height_135, height_135, height_173, height_173] +theorem height_exact_174 : height_174 = 1 + Finset.univ.sup childrenH_174 := by decide +kernel +theorem required_origin_174 : ∀ x ∈ required_174, + (∃ j, x ∈ childrenC_174 j) ∨ ∀ j, x ∈ childrenD_174 j := by decide +kernel +theorem required_exact_174 : required_174 = + ((Finset.univ.biUnion childrenC_174) ∪ commonEnvelope childrenD_174).erase (3, 5) := by + exact required_eq_combination childrenC_174 childrenD_174 (3, 5) required_174 + (by decide +kernel) child_required_sub_174 common_sub_174 required_origin_174 +theorem envelope_origin_174 : ∀ x ∈ envelope_174, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_174 j := by decide +kernel +theorem envelope_exact_174 : envelope_174 = + insert (3, 5) (Finset.univ.biUnion childrenD_174) := by + exact envelope_eq_combination childrenD_174 (3, 5) envelope_174 + pivot_mem_174 child_envelope_sub_174 envelope_origin_174 +def checked_174 : CheckedCard where + required := required_174 + envelope := envelope_174 + height := height_174 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_174 +def height_257 : ℕ := 8 +def childrenH_257 : Fin 3 → ℕ := ![height_7, height_9, height_256] +theorem height_exact_257 : height_257 = 1 + Finset.univ.sup childrenH_257 := by decide +kernel +theorem required_origin_257 : ∀ x ∈ required_257, + (∃ j, x ∈ childrenC_257 j) ∨ ∀ j, x ∈ childrenD_257 j := by decide +kernel +theorem required_exact_257 : required_257 = + ((Finset.univ.biUnion childrenC_257) ∪ commonEnvelope childrenD_257).erase (4, 3) := by + exact required_eq_combination childrenC_257 childrenD_257 (4, 3) required_257 + (by decide +kernel) child_required_sub_257 common_sub_257 required_origin_257 +theorem envelope_origin_257 : ∀ x ∈ envelope_257, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_257 j := by decide +kernel +theorem envelope_exact_257 : envelope_257 = + insert (4, 3) (Finset.univ.biUnion childrenD_257) := by + exact envelope_eq_combination childrenD_257 (4, 3) envelope_257 + pivot_mem_257 child_envelope_sub_257 envelope_origin_257 +def checked_257 : CheckedCard where + required := required_257 + envelope := envelope_257 + height := height_257 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_257 +def height_258 : ℕ := 8 +def childrenH_258 : Fin 4 → ℕ := ![height_8, height_161, height_162, height_256] +theorem height_exact_258 : height_258 = 1 + Finset.univ.sup childrenH_258 := by decide +kernel +theorem required_origin_258 : ∀ x ∈ required_258, + (∃ j, x ∈ childrenC_258 j) ∨ ∀ j, x ∈ childrenD_258 j := by decide +kernel +theorem required_exact_258 : required_258 = + ((Finset.univ.biUnion childrenC_258) ∪ commonEnvelope childrenD_258).erase (3, 3) := by + exact required_eq_combination childrenC_258 childrenD_258 (3, 3) required_258 + (by decide +kernel) child_required_sub_258 common_sub_258 required_origin_258 +theorem envelope_origin_258 : ∀ x ∈ envelope_258, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_258 j := by decide +kernel +theorem envelope_exact_258 : envelope_258 = + insert (3, 3) (Finset.univ.biUnion childrenD_258) := by + exact envelope_eq_combination childrenD_258 (3, 3) envelope_258 + pivot_mem_258 child_envelope_sub_258 envelope_origin_258 +def checked_258 : CheckedCard where + required := required_258 + envelope := envelope_258 + height := height_258 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_258 +def height_285 : ℕ := 8 +def childrenH_285 : Fin 3 → ℕ := ![height_6, height_26, height_117] +theorem height_exact_285 : height_285 = 1 + Finset.univ.sup childrenH_285 := by decide +kernel +theorem required_origin_285 : ∀ x ∈ required_285, + (∃ j, x ∈ childrenC_285 j) ∨ ∀ j, x ∈ childrenD_285 j := by decide +kernel +theorem required_exact_285 : required_285 = + ((Finset.univ.biUnion childrenC_285) ∪ commonEnvelope childrenD_285).erase (4, 3) := by + exact required_eq_combination childrenC_285 childrenD_285 (4, 3) required_285 + (by decide +kernel) child_required_sub_285 common_sub_285 required_origin_285 +theorem envelope_origin_285 : ∀ x ∈ envelope_285, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_285 j := by decide +kernel +theorem envelope_exact_285 : envelope_285 = + insert (4, 3) (Finset.univ.biUnion childrenD_285) := by + exact envelope_eq_combination childrenD_285 (4, 3) envelope_285 + pivot_mem_285 child_envelope_sub_285 envelope_origin_285 +def checked_285 : CheckedCard where + required := required_285 + envelope := envelope_285 + height := height_285 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_285 +def height_319 : ℕ := 8 +def childrenH_319 : Fin 2 → ℕ := ![height_52, height_318] +theorem height_exact_319 : height_319 = 1 + Finset.univ.sup childrenH_319 := by decide +kernel +theorem required_origin_319 : ∀ x ∈ required_319, + (∃ j, x ∈ childrenC_319 j) ∨ ∀ j, x ∈ childrenD_319 j := by decide +kernel +theorem required_exact_319 : required_319 = + ((Finset.univ.biUnion childrenC_319) ∪ commonEnvelope childrenD_319).erase (3, 4) := by + exact required_eq_combination childrenC_319 childrenD_319 (3, 4) required_319 + (by decide +kernel) child_required_sub_319 common_sub_319 required_origin_319 +theorem envelope_origin_319 : ∀ x ∈ envelope_319, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_319 j := by decide +kernel +theorem envelope_exact_319 : envelope_319 = + insert (3, 4) (Finset.univ.biUnion childrenD_319) := by + exact envelope_eq_combination childrenD_319 (3, 4) envelope_319 + pivot_mem_319 child_envelope_sub_319 envelope_origin_319 +def checked_319 : CheckedCard where + required := required_319 + envelope := envelope_319 + height := height_319 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_319 +def height_321 : ℕ := 8 +def childrenH_321 : Fin 2 → ℕ := ![height_5, height_320] +theorem height_exact_321 : height_321 = 1 + Finset.univ.sup childrenH_321 := by decide +kernel +theorem required_origin_321 : ∀ x ∈ required_321, + (∃ j, x ∈ childrenC_321 j) ∨ ∀ j, x ∈ childrenD_321 j := by decide +kernel +theorem required_exact_321 : required_321 = + ((Finset.univ.biUnion childrenC_321) ∪ commonEnvelope childrenD_321).erase (3, 3) := by + exact required_eq_combination childrenC_321 childrenD_321 (3, 3) required_321 + (by decide +kernel) child_required_sub_321 common_sub_321 required_origin_321 +theorem envelope_origin_321 : ∀ x ∈ envelope_321, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_321 j := by decide +kernel +theorem envelope_exact_321 : envelope_321 = + insert (3, 3) (Finset.univ.biUnion childrenD_321) := by + exact envelope_eq_combination childrenD_321 (3, 3) envelope_321 + pivot_mem_321 child_envelope_sub_321 envelope_origin_321 +def checked_321 : CheckedCard where + required := required_321 + envelope := envelope_321 + height := height_321 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_321 +def height_323 : ℕ := 8 +def childrenH_323 : Fin 2 → ℕ := ![height_11, height_320] +theorem height_exact_323 : height_323 = 1 + Finset.univ.sup childrenH_323 := by decide +kernel +theorem required_origin_323 : ∀ x ∈ required_323, + (∃ j, x ∈ childrenC_323 j) ∨ ∀ j, x ∈ childrenD_323 j := by decide +kernel +theorem required_exact_323 : required_323 = + ((Finset.univ.biUnion childrenC_323) ∪ commonEnvelope childrenD_323).erase (2, 4) := by + exact required_eq_combination childrenC_323 childrenD_323 (2, 4) required_323 + (by decide +kernel) child_required_sub_323 common_sub_323 required_origin_323 +theorem envelope_origin_323 : ∀ x ∈ envelope_323, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_323 j := by decide +kernel +theorem envelope_exact_323 : envelope_323 = + insert (2, 4) (Finset.univ.biUnion childrenD_323) := by + exact envelope_eq_combination childrenD_323 (2, 4) envelope_323 + pivot_mem_323 child_envelope_sub_323 envelope_origin_323 +def checked_323 : CheckedCard where + required := required_323 + envelope := envelope_323 + height := height_323 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_323 +def height_338 : ℕ := 8 +def childrenH_338 : Fin 3 → ℕ := ![height_44, height_47, height_337] +theorem height_exact_338 : height_338 = 1 + Finset.univ.sup childrenH_338 := by decide +kernel +theorem required_origin_338 : ∀ x ∈ required_338, + (∃ j, x ∈ childrenC_338 j) ∨ ∀ j, x ∈ childrenD_338 j := by decide +kernel +theorem required_exact_338 : required_338 = + ((Finset.univ.biUnion childrenC_338) ∪ commonEnvelope childrenD_338).erase (2, 4) := by + exact required_eq_combination childrenC_338 childrenD_338 (2, 4) required_338 + (by decide +kernel) child_required_sub_338 common_sub_338 required_origin_338 +theorem envelope_origin_338 : ∀ x ∈ envelope_338, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_338 j := by decide +kernel +theorem envelope_exact_338 : envelope_338 = + insert (2, 4) (Finset.univ.biUnion childrenD_338) := by + exact envelope_eq_combination childrenD_338 (2, 4) envelope_338 + pivot_mem_338 child_envelope_sub_338 envelope_origin_338 +def checked_338 : CheckedCard where + required := required_338 + envelope := envelope_338 + height := height_338 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_338 +def height_345 : ℕ := 8 +def childrenH_345 : Fin 3 → ℕ := ![height_8, height_11, height_344] +theorem height_exact_345 : height_345 = 1 + Finset.univ.sup childrenH_345 := by decide +kernel +theorem required_origin_345 : ∀ x ∈ required_345, + (∃ j, x ∈ childrenC_345 j) ∨ ∀ j, x ∈ childrenD_345 j := by decide +kernel +theorem required_exact_345 : required_345 = + ((Finset.univ.biUnion childrenC_345) ∪ commonEnvelope childrenD_345).erase (4, 2) := by + exact required_eq_combination childrenC_345 childrenD_345 (4, 2) required_345 + (by decide +kernel) child_required_sub_345 common_sub_345 required_origin_345 +theorem envelope_origin_345 : ∀ x ∈ envelope_345, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_345 j := by decide +kernel +theorem envelope_exact_345 : envelope_345 = + insert (4, 2) (Finset.univ.biUnion childrenD_345) := by + exact envelope_eq_combination childrenD_345 (4, 2) envelope_345 + pivot_mem_345 child_envelope_sub_345 envelope_origin_345 +def checked_345 : CheckedCard where + required := required_345 + envelope := envelope_345 + height := height_345 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_345 +def height_373 : ℕ := 8 +def childrenH_373 : Fin 2 → ℕ := ![height_5, height_372] +theorem height_exact_373 : height_373 = 1 + Finset.univ.sup childrenH_373 := by decide +kernel +theorem required_origin_373 : ∀ x ∈ required_373, + (∃ j, x ∈ childrenC_373 j) ∨ ∀ j, x ∈ childrenD_373 j := by decide +kernel +theorem required_exact_373 : required_373 = + ((Finset.univ.biUnion childrenC_373) ∪ commonEnvelope childrenD_373).erase (1, 4) := by + exact required_eq_combination childrenC_373 childrenD_373 (1, 4) required_373 + (by decide +kernel) child_required_sub_373 common_sub_373 required_origin_373 +theorem envelope_origin_373 : ∀ x ∈ envelope_373, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_373 j := by decide +kernel +theorem envelope_exact_373 : envelope_373 = + insert (1, 4) (Finset.univ.biUnion childrenD_373) := by + exact envelope_eq_combination childrenD_373 (1, 4) envelope_373 + pivot_mem_373 child_envelope_sub_373 envelope_origin_373 +def checked_373 : CheckedCard where + required := required_373 + envelope := envelope_373 + height := height_373 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_373 +def height_395_i0 : ℕ := 7 +def childrenH_395_i0 : Fin 2 → ℕ := ![height_5, height_217] +theorem height_exact_395_i0 : height_395_i0 = 1 + Finset.univ.sup childrenH_395_i0 := by decide +kernel +theorem required_origin_395_i0 : ∀ x ∈ required_395_i0, + (∃ j, x ∈ childrenC_395_i0 j) ∨ ∀ j, x ∈ childrenD_395_i0 j := by decide +kernel +theorem required_exact_395_i0 : required_395_i0 = + ((Finset.univ.biUnion childrenC_395_i0) ∪ commonEnvelope childrenD_395_i0).erase (3, 1) := by + exact required_eq_combination childrenC_395_i0 childrenD_395_i0 (3, 1) required_395_i0 + (by decide +kernel) child_required_sub_395_i0 common_sub_395_i0 required_origin_395_i0 +theorem envelope_origin_395_i0 : ∀ x ∈ envelope_395_i0, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_395_i0 j := by decide +kernel +theorem envelope_exact_395_i0 : envelope_395_i0 = + insert (3, 1) (Finset.univ.biUnion childrenD_395_i0) := by + exact envelope_eq_combination childrenD_395_i0 (3, 1) envelope_395_i0 + pivot_mem_395_i0 child_envelope_sub_395_i0 envelope_origin_395_i0 +def checked_395_i0 : CheckedCard where + required := required_395_i0 + envelope := envelope_395_i0 + height := height_395_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_395_i0 +def height_395 : ℕ := 8 +def childrenH_395 : Fin 2 → ℕ := ![height_5, height_395_i0] +theorem height_exact_395 : height_395 = 1 + Finset.univ.sup childrenH_395 := by decide +kernel +theorem required_origin_395 : ∀ x ∈ required_395, + (∃ j, x ∈ childrenC_395 j) ∨ ∀ j, x ∈ childrenD_395 j := by decide +kernel +theorem required_exact_395 : required_395 = + ((Finset.univ.biUnion childrenC_395) ∪ commonEnvelope childrenD_395).erase (3, 3) := by + exact required_eq_combination childrenC_395 childrenD_395 (3, 3) required_395 + (by decide +kernel) child_required_sub_395 common_sub_395 required_origin_395 +theorem envelope_origin_395 : ∀ x ∈ envelope_395, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_395 j := by decide +kernel +theorem envelope_exact_395 : envelope_395 = + insert (3, 3) (Finset.univ.biUnion childrenD_395) := by + exact envelope_eq_combination childrenD_395 (3, 3) envelope_395 + pivot_mem_395 child_envelope_sub_395 envelope_origin_395 +def checked_395 : CheckedCard where + required := required_395 + envelope := envelope_395 + height := height_395 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_395 +def height_405 : ℕ := 8 +def childrenH_405 : Fin 2 → ℕ := ![height_0, height_404] +theorem height_exact_405 : height_405 = 1 + Finset.univ.sup childrenH_405 := by decide +kernel +theorem required_origin_405 : ∀ x ∈ required_405, + (∃ j, x ∈ childrenC_405 j) ∨ ∀ j, x ∈ childrenD_405 j := by decide +kernel +theorem required_exact_405 : required_405 = + ((Finset.univ.biUnion childrenC_405) ∪ commonEnvelope childrenD_405).erase (1, 4) := by + exact required_eq_combination childrenC_405 childrenD_405 (1, 4) required_405 + (by decide +kernel) child_required_sub_405 common_sub_405 required_origin_405 +theorem envelope_origin_405 : ∀ x ∈ envelope_405, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_405 j := by decide +kernel +theorem envelope_exact_405 : envelope_405 = + insert (1, 4) (Finset.univ.biUnion childrenD_405) := by + exact envelope_eq_combination childrenD_405 (1, 4) envelope_405 + pivot_mem_405 child_envelope_sub_405 envelope_origin_405 +def checked_405 : CheckedCard where + required := required_405 + envelope := envelope_405 + height := height_405 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_405 +def height_412_i0 : ℕ := 7 +def childrenH_412_i0 : Fin 2 → ℕ := ![height_0, height_358] +theorem height_exact_412_i0 : height_412_i0 = 1 + Finset.univ.sup childrenH_412_i0 := by decide +kernel +theorem required_origin_412_i0 : ∀ x ∈ required_412_i0, + (∃ j, x ∈ childrenC_412_i0 j) ∨ ∀ j, x ∈ childrenD_412_i0 j := by decide +kernel +theorem required_exact_412_i0 : required_412_i0 = + ((Finset.univ.biUnion childrenC_412_i0) ∪ commonEnvelope childrenD_412_i0).erase (3, 1) := by + exact required_eq_combination childrenC_412_i0 childrenD_412_i0 (3, 1) required_412_i0 + (by decide +kernel) child_required_sub_412_i0 common_sub_412_i0 required_origin_412_i0 +theorem envelope_origin_412_i0 : ∀ x ∈ envelope_412_i0, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_412_i0 j := by decide +kernel +theorem envelope_exact_412_i0 : envelope_412_i0 = + insert (3, 1) (Finset.univ.biUnion childrenD_412_i0) := by + exact envelope_eq_combination childrenD_412_i0 (3, 1) envelope_412_i0 + pivot_mem_412_i0 child_envelope_sub_412_i0 envelope_origin_412_i0 +def checked_412_i0 : CheckedCard where + required := required_412_i0 + envelope := envelope_412_i0 + height := height_412_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_412_i0 +def height_412 : ℕ := 8 +def childrenH_412 : Fin 2 → ℕ := ![height_5, height_412_i0] +theorem height_exact_412 : height_412 = 1 + Finset.univ.sup childrenH_412 := by decide +kernel +theorem required_origin_412 : ∀ x ∈ required_412, + (∃ j, x ∈ childrenC_412 j) ∨ ∀ j, x ∈ childrenD_412 j := by decide +kernel +theorem required_exact_412 : required_412 = + ((Finset.univ.biUnion childrenC_412) ∪ commonEnvelope childrenD_412).erase (2, 1) := by + exact required_eq_combination childrenC_412 childrenD_412 (2, 1) required_412 + (by decide +kernel) child_required_sub_412 common_sub_412 required_origin_412 +theorem envelope_origin_412 : ∀ x ∈ envelope_412, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_412 j := by decide +kernel +theorem envelope_exact_412 : envelope_412 = + insert (2, 1) (Finset.univ.biUnion childrenD_412) := by + exact envelope_eq_combination childrenD_412 (2, 1) envelope_412 + pivot_mem_412 child_envelope_sub_412 envelope_origin_412 +def checked_412 : CheckedCard where + required := required_412 + envelope := envelope_412 + height := height_412 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_412 +def height_419 : ℕ := 8 +def childrenH_419 : Fin 2 → ℕ := ![height_5, height_418] +theorem height_exact_419 : height_419 = 1 + Finset.univ.sup childrenH_419 := by decide +kernel +theorem required_origin_419 : ∀ x ∈ required_419, + (∃ j, x ∈ childrenC_419 j) ∨ ∀ j, x ∈ childrenD_419 j := by decide +kernel +theorem required_exact_419 : required_419 = + ((Finset.univ.biUnion childrenC_419) ∪ commonEnvelope childrenD_419).erase (2, 1) := by + exact required_eq_combination childrenC_419 childrenD_419 (2, 1) required_419 + (by decide +kernel) child_required_sub_419 common_sub_419 required_origin_419 +theorem envelope_origin_419 : ∀ x ∈ envelope_419, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_419 j := by decide +kernel +theorem envelope_exact_419 : envelope_419 = + insert (2, 1) (Finset.univ.biUnion childrenD_419) := by + exact envelope_eq_combination childrenD_419 (2, 1) envelope_419 + pivot_mem_419 child_envelope_sub_419 envelope_origin_419 +def checked_419 : CheckedCard where + required := required_419 + envelope := envelope_419 + height := height_419 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_419 +def height_420 : ℕ := 8 +def childrenH_420 : Fin 2 → ℕ := ![height_0, height_418] +theorem height_exact_420 : height_420 = 1 + Finset.univ.sup childrenH_420 := by decide +kernel +theorem required_origin_420 : ∀ x ∈ required_420, + (∃ j, x ∈ childrenC_420 j) ∨ ∀ j, x ∈ childrenD_420 j := by decide +kernel +theorem required_exact_420 : required_420 = + ((Finset.univ.biUnion childrenC_420) ∪ commonEnvelope childrenD_420).erase (3, 1) := by + exact required_eq_combination childrenC_420 childrenD_420 (3, 1) required_420 + (by decide +kernel) child_required_sub_420 common_sub_420 required_origin_420 +theorem envelope_origin_420 : ∀ x ∈ envelope_420, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_420 j := by decide +kernel +theorem envelope_exact_420 : envelope_420 = + insert (3, 1) (Finset.univ.biUnion childrenD_420) := by + exact envelope_eq_combination childrenD_420 (3, 1) envelope_420 + pivot_mem_420 child_envelope_sub_420 envelope_origin_420 +def checked_420 : CheckedCard where + required := required_420 + envelope := envelope_420 + height := height_420 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_420 +def height_438 : ℕ := 8 +def childrenH_438 : Fin 3 → ℕ := ![height_10, height_47, height_436] +theorem height_exact_438 : height_438 = 1 + Finset.univ.sup childrenH_438 := by decide +kernel +theorem required_origin_438 : ∀ x ∈ required_438, + (∃ j, x ∈ childrenC_438 j) ∨ ∀ j, x ∈ childrenD_438 j := by decide +kernel +theorem required_exact_438 : required_438 = + ((Finset.univ.biUnion childrenC_438) ∪ commonEnvelope childrenD_438).erase (4, 3) := by + exact required_eq_combination childrenC_438 childrenD_438 (4, 3) required_438 + (by decide +kernel) child_required_sub_438 common_sub_438 required_origin_438 +theorem envelope_origin_438 : ∀ x ∈ envelope_438, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_438 j := by decide +kernel +theorem envelope_exact_438 : envelope_438 = + insert (4, 3) (Finset.univ.biUnion childrenD_438) := by + exact envelope_eq_combination childrenD_438 (4, 3) envelope_438 + pivot_mem_438 child_envelope_sub_438 envelope_origin_438 +def checked_438 : CheckedCard where + required := required_438 + envelope := envelope_438 + height := height_438 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_438 +def height_440_i0 : ℕ := 7 +def childrenH_440_i0 : Fin 2 → ℕ := ![height_5, height_439] +theorem height_exact_440_i0 : height_440_i0 = 1 + Finset.univ.sup childrenH_440_i0 := by decide +kernel +theorem required_origin_440_i0 : ∀ x ∈ required_440_i0, + (∃ j, x ∈ childrenC_440_i0 j) ∨ ∀ j, x ∈ childrenD_440_i0 j := by decide +kernel +theorem required_exact_440_i0 : required_440_i0 = + ((Finset.univ.biUnion childrenC_440_i0) ∪ commonEnvelope childrenD_440_i0).erase (1, 1) := by + exact required_eq_combination childrenC_440_i0 childrenD_440_i0 (1, 1) required_440_i0 + (by decide +kernel) child_required_sub_440_i0 common_sub_440_i0 required_origin_440_i0 +theorem envelope_origin_440_i0 : ∀ x ∈ envelope_440_i0, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_440_i0 j := by decide +kernel +theorem envelope_exact_440_i0 : envelope_440_i0 = + insert (1, 1) (Finset.univ.biUnion childrenD_440_i0) := by + exact envelope_eq_combination childrenD_440_i0 (1, 1) envelope_440_i0 + pivot_mem_440_i0 child_envelope_sub_440_i0 envelope_origin_440_i0 +def checked_440_i0 : CheckedCard where + required := required_440_i0 + envelope := envelope_440_i0 + height := height_440_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_440_i0 +def height_440 : ℕ := 8 +def childrenH_440 : Fin 2 → ℕ := ![height_18, height_440_i0] +theorem height_exact_440 : height_440 = 1 + Finset.univ.sup childrenH_440 := by decide +kernel +theorem required_origin_440 : ∀ x ∈ required_440, + (∃ j, x ∈ childrenC_440 j) ∨ ∀ j, x ∈ childrenD_440 j := by decide +kernel +theorem required_exact_440 : required_440 = + ((Finset.univ.biUnion childrenC_440) ∪ commonEnvelope childrenD_440).erase (0, 1) := by + exact required_eq_combination childrenC_440 childrenD_440 (0, 1) required_440 + (by decide +kernel) child_required_sub_440 common_sub_440 required_origin_440 +theorem envelope_origin_440 : ∀ x ∈ envelope_440, + x = (0, 1) ∨ ∃ j, x ∈ childrenD_440 j := by decide +kernel +theorem envelope_exact_440 : envelope_440 = + insert (0, 1) (Finset.univ.biUnion childrenD_440) := by + exact envelope_eq_combination childrenD_440 (0, 1) envelope_440 + pivot_mem_440 child_envelope_sub_440 envelope_origin_440 +def checked_440 : CheckedCard where + required := required_440 + envelope := envelope_440 + height := height_440 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_440 +def height_448 : ℕ := 8 +def childrenH_448 : Fin 2 → ℕ := ![height_56, height_447] +theorem height_exact_448 : height_448 = 1 + Finset.univ.sup childrenH_448 := by decide +kernel +theorem required_origin_448 : ∀ x ∈ required_448, + (∃ j, x ∈ childrenC_448 j) ∨ ∀ j, x ∈ childrenD_448 j := by decide +kernel +theorem required_exact_448 : required_448 = + ((Finset.univ.biUnion childrenC_448) ∪ commonEnvelope childrenD_448).erase (1, 3) := by + exact required_eq_combination childrenC_448 childrenD_448 (1, 3) required_448 + (by decide +kernel) child_required_sub_448 common_sub_448 required_origin_448 +theorem envelope_origin_448 : ∀ x ∈ envelope_448, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_448 j := by decide +kernel +theorem envelope_exact_448 : envelope_448 = + insert (1, 3) (Finset.univ.biUnion childrenD_448) := by + exact envelope_eq_combination childrenD_448 (1, 3) envelope_448 + pivot_mem_448 child_envelope_sub_448 envelope_origin_448 +def checked_448 : CheckedCard where + required := required_448 + envelope := envelope_448 + height := height_448 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_448 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part02.lean new file mode 100644 index 0000000..843ef21 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part02.lean @@ -0,0 +1,901 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_452_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (4, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_452_i0 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 4), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 4), (6, 5), (6, 6), (6, 7), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_452_i0 : Fin 2 → Finset Cell := ![(placed21 6 (6, 4) required_5), (placed21 0 (3, 1) required_55)] +def childrenD_452_i0 : Fin 2 → Finset Cell := ![(placed21 6 (6, 4) envelope_5), (placed21 0 (3, 1) envelope_55)] +theorem common_sub_452_i0 : commonEnvelope childrenD_452_i0 ⊆ insert (6, 4) required_452_i0 := by decide +kernel +theorem child_required_sub_452_i0 : ∀ j, childrenC_452_i0 j ⊆ insert (6, 4) required_452_i0 := by decide +kernel +theorem child_envelope_sub_452_i0 : ∀ j, childrenD_452_i0 j ⊆ envelope_452_i0 := by decide +kernel +theorem pivot_mem_452_i0 : (6, 4) ∈ envelope_452_i0 := by decide +kernel +theorem children_work_452_i0 : ∀ j, Template HasSnaky 4 (childrenC_452_i0 j) (childrenD_452_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_55 0 (3, 1)).mono (by decide +kernel) +theorem row_works_452_i0 : Template HasSnaky 5 required_452_i0 envelope_452_i0 := by + refine compose HasSnaky 4 childrenC_452_i0 childrenD_452_i0 children_work_452_i0 (6, 4) + required_452_i0 envelope_452_i0 pivot_mem_452_i0 child_required_sub_452_i0 child_envelope_sub_452_i0 ?_ + intro b hb + exact common_sub_452_i0 (mem_commonEnvelope childrenD_452_i0 b hb) +def required_452 : Finset Cell := ⟨(([(3, 3), (3, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_452 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 4), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 5), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_452 : Fin 3 → Finset Cell := ![(placed21 7 (6, 4) required_52), (placed21 0 (2, 0) required_317), required_452_i0] +def childrenD_452 : Fin 3 → Finset Cell := ![(placed21 7 (6, 4) envelope_52), (placed21 0 (2, 0) envelope_317), envelope_452_i0] +theorem common_sub_452 : commonEnvelope childrenD_452 ⊆ insert (4, 4) required_452 := by decide +kernel +theorem child_required_sub_452 : ∀ j, childrenC_452 j ⊆ insert (4, 4) required_452 := by decide +kernel +theorem child_envelope_sub_452 : ∀ j, childrenD_452 j ⊆ envelope_452 := by decide +kernel +theorem pivot_mem_452 : (4, 4) ∈ envelope_452 := by decide +kernel +theorem children_work_452 : ∀ j, Template HasSnaky 7 (childrenC_452 j) (childrenD_452 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 7 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_317 0 (2, 0)).mono (by decide +kernel) + · exact row_works_452_i0.mono (by decide +kernel) +theorem row_works_452 : Template HasSnaky 8 required_452 envelope_452 := by + refine compose HasSnaky 7 childrenC_452 childrenD_452 children_work_452 (4, 4) + required_452 envelope_452 pivot_mem_452 child_required_sub_452 child_envelope_sub_452 ?_ + intro b hb + exact common_sub_452 (mem_commonEnvelope childrenD_452 b hb) +def required_454 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 4), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_454 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_454 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), (placed21 3 (0, 4) required_453)] +def childrenD_454 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), (placed21 3 (0, 4) envelope_453)] +theorem common_sub_454 : commonEnvelope childrenD_454 ⊆ insert (1, 3) required_454 := by decide +kernel +theorem child_required_sub_454 : ∀ j, childrenC_454 j ⊆ insert (1, 3) required_454 := by decide +kernel +theorem child_envelope_sub_454 : ∀ j, childrenD_454 j ⊆ envelope_454 := by decide +kernel +theorem pivot_mem_454 : (1, 3) ∈ envelope_454 := by decide +kernel +theorem children_work_454 : ∀ j, Template HasSnaky 7 (childrenC_454 j) (childrenD_454 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_453 3 (0, 4)).mono (by decide +kernel) +theorem row_works_454 : Template HasSnaky 8 required_454 envelope_454 := by + refine compose HasSnaky 7 childrenC_454 childrenD_454 children_work_454 (1, 3) + required_454 envelope_454 pivot_mem_454 child_required_sub_454 child_envelope_sub_454 ?_ + intro b hb + exact common_sub_454 (mem_commonEnvelope childrenD_454 b hb) +def required_455 : Finset Cell := ⟨(([(0, 1), (0, 2), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_455 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_455 : Fin 4 → Finset Cell := ![required_8, (placed21 1 (0, 1) required_16), (placed21 4 (0, 2) required_24), required_453] +def childrenD_455 : Fin 4 → Finset Cell := ![envelope_8, (placed21 1 (0, 1) envelope_16), (placed21 4 (0, 2) envelope_24), envelope_453] +theorem common_sub_455 : commonEnvelope childrenD_455 ⊆ insert (1, 1) required_455 := by decide +kernel +theorem child_required_sub_455 : ∀ j, childrenC_455 j ⊆ insert (1, 1) required_455 := by decide +kernel +theorem child_envelope_sub_455 : ∀ j, childrenD_455 j ⊆ envelope_455 := by decide +kernel +theorem pivot_mem_455 : (1, 1) ∈ envelope_455 := by decide +kernel +theorem children_work_455 : ∀ j, Template HasSnaky 7 (childrenC_455 j) (childrenD_455 j) := by + intro j + fin_cases j + · exact row_works_8.mono (by decide +kernel) + · exact (placed21_template row_works_16 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_24 4 (0, 2)).mono (by decide +kernel) + · exact row_works_453.mono (by decide +kernel) +theorem row_works_455 : Template HasSnaky 8 required_455 envelope_455 := by + refine compose HasSnaky 7 childrenC_455 childrenD_455 children_work_455 (1, 1) + required_455 envelope_455 pivot_mem_455 child_required_sub_455 child_envelope_sub_455 ?_ + intro b hb + exact common_sub_455 (mem_commonEnvelope childrenD_455 b hb) +def required_456 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_456 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_456 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), (placed21 3 (0, 4) required_453)] +def childrenD_456 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), (placed21 3 (0, 4) envelope_453)] +theorem common_sub_456 : commonEnvelope childrenD_456 ⊆ insert (2, 4) required_456 := by decide +kernel +theorem child_required_sub_456 : ∀ j, childrenC_456 j ⊆ insert (2, 4) required_456 := by decide +kernel +theorem child_envelope_sub_456 : ∀ j, childrenD_456 j ⊆ envelope_456 := by decide +kernel +theorem pivot_mem_456 : (2, 4) ∈ envelope_456 := by decide +kernel +theorem children_work_456 : ∀ j, Template HasSnaky 7 (childrenC_456 j) (childrenD_456 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_453 3 (0, 4)).mono (by decide +kernel) +theorem row_works_456 : Template HasSnaky 8 required_456 envelope_456 := by + refine compose HasSnaky 7 childrenC_456 childrenD_456 children_work_456 (2, 4) + required_456 envelope_456 pivot_mem_456 child_required_sub_456 child_envelope_sub_456 ?_ + intro b hb + exact common_sub_456 (mem_commonEnvelope childrenD_456 b hb) +def required_473 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_473 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_473 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_5), required_472] +def childrenD_473 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_5), envelope_472] +theorem common_sub_473 : commonEnvelope childrenD_473 ⊆ insert (1, 1) required_473 := by decide +kernel +theorem child_required_sub_473 : ∀ j, childrenC_473 j ⊆ insert (1, 1) required_473 := by decide +kernel +theorem child_envelope_sub_473 : ∀ j, childrenD_473 j ⊆ envelope_473 := by decide +kernel +theorem pivot_mem_473 : (1, 1) ∈ envelope_473 := by decide +kernel +theorem children_work_473 : ∀ j, Template HasSnaky 7 (childrenC_473 j) (childrenD_473 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact row_works_472.mono (by decide +kernel) +theorem row_works_473 : Template HasSnaky 8 required_473 envelope_473 := by + refine compose HasSnaky 7 childrenC_473 childrenD_473 children_work_473 (1, 1) + required_473 envelope_473 pivot_mem_473 child_required_sub_473 child_envelope_sub_473 ?_ + intro b hb + exact common_sub_473 (mem_commonEnvelope childrenD_473 b hb) +def required_478 : Finset Cell := ⟨(([(1, 1), (1, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_478 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_478 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_5), required_472] +def childrenD_478 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_5), envelope_472] +theorem common_sub_478 : commonEnvelope childrenD_478 ⊆ insert (2, 2) required_478 := by decide +kernel +theorem child_required_sub_478 : ∀ j, childrenC_478 j ⊆ insert (2, 2) required_478 := by decide +kernel +theorem child_envelope_sub_478 : ∀ j, childrenD_478 j ⊆ envelope_478 := by decide +kernel +theorem pivot_mem_478 : (2, 2) ∈ envelope_478 := by decide +kernel +theorem children_work_478 : ∀ j, Template HasSnaky 7 (childrenC_478 j) (childrenD_478 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact row_works_472.mono (by decide +kernel) +theorem row_works_478 : Template HasSnaky 8 required_478 envelope_478 := by + refine compose HasSnaky 7 childrenC_478 childrenD_478 children_work_478 (2, 2) + required_478 envelope_478 pivot_mem_478 child_required_sub_478 child_envelope_sub_478 ?_ + intro b hb + exact common_sub_478 (mem_commonEnvelope childrenD_478 b hb) +def required_482 : Finset Cell := ⟨(([(1, 1), (1, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_482 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (5, 2), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_482 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) required_7), (placed21 0 (1, 1) required_24), (placed21 1 (0, 1) required_124), required_472] +def childrenD_482 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) envelope_7), (placed21 0 (1, 1) envelope_24), (placed21 1 (0, 1) envelope_124), envelope_472] +theorem common_sub_482 : commonEnvelope childrenD_482 ⊆ insert (2, 2) required_482 := by decide +kernel +theorem child_required_sub_482 : ∀ j, childrenC_482 j ⊆ insert (2, 2) required_482 := by decide +kernel +theorem child_envelope_sub_482 : ∀ j, childrenD_482 j ⊆ envelope_482 := by decide +kernel +theorem pivot_mem_482 : (2, 2) ∈ envelope_482 := by decide +kernel +theorem children_work_482 : ∀ j, Template HasSnaky 7 (childrenC_482 j) (childrenD_482 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_24 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_124 1 (0, 1)).mono (by decide +kernel) + · exact row_works_472.mono (by decide +kernel) +theorem row_works_482 : Template HasSnaky 8 required_482 envelope_482 := by + refine compose HasSnaky 7 childrenC_482 childrenD_482 children_work_482 (2, 2) + required_482 envelope_482 pivot_mem_482 child_required_sub_482 child_envelope_sub_482 ?_ + intro b hb + exact common_sub_482 (mem_commonEnvelope childrenD_482 b hb) +def required_484_i1 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (3, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_484_i1 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_484_i1 : Fin 2 → Finset Cell := ![(placed21 3 (1, 5) required_5), (placed21 3 (0, 5) required_96)] +def childrenD_484_i1 : Fin 2 → Finset Cell := ![(placed21 3 (1, 5) envelope_5), (placed21 3 (0, 5) envelope_96)] +theorem common_sub_484_i1 : commonEnvelope childrenD_484_i1 ⊆ insert (2, 2) required_484_i1 := by decide +kernel +theorem child_required_sub_484_i1 : ∀ j, childrenC_484_i1 j ⊆ insert (2, 2) required_484_i1 := by decide +kernel +theorem child_envelope_sub_484_i1 : ∀ j, childrenD_484_i1 j ⊆ envelope_484_i1 := by decide +kernel +theorem pivot_mem_484_i1 : (2, 2) ∈ envelope_484_i1 := by decide +kernel +theorem children_work_484_i1 : ∀ j, Template HasSnaky 2 (childrenC_484_i1 j) (childrenD_484_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_96 3 (0, 5)).mono (by decide +kernel) +theorem row_works_484_i1 : Template HasSnaky 3 required_484_i1 envelope_484_i1 := by + refine compose HasSnaky 2 childrenC_484_i1 childrenD_484_i1 children_work_484_i1 (2, 2) + required_484_i1 envelope_484_i1 pivot_mem_484_i1 child_required_sub_484_i1 child_envelope_sub_484_i1 ?_ + intro b hb + exact common_sub_484_i1 (mem_commonEnvelope childrenD_484_i1 b hb) +def required_484_i2 : Finset Cell := ⟨(([(3, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_484_i2 : Finset Cell := ⟨(([(3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_484_i2 : Fin 3 → Finset Cell := ![(placed21 0 (3, 2) required_18), (placed21 4 (3, 7) required_33), (placed21 6 (4, 5) required_130)] +def childrenD_484_i2 : Fin 3 → Finset Cell := ![(placed21 0 (3, 2) envelope_18), (placed21 4 (3, 7) envelope_33), (placed21 6 (4, 5) envelope_130)] +theorem common_sub_484_i2 : commonEnvelope childrenD_484_i2 ⊆ insert (4, 4) required_484_i2 := by decide +kernel +theorem child_required_sub_484_i2 : ∀ j, childrenC_484_i2 j ⊆ insert (4, 4) required_484_i2 := by decide +kernel +theorem child_envelope_sub_484_i2 : ∀ j, childrenD_484_i2 j ⊆ envelope_484_i2 := by decide +kernel +theorem pivot_mem_484_i2 : (4, 4) ∈ envelope_484_i2 := by decide +kernel +theorem children_work_484_i2 : ∀ j, Template HasSnaky 4 (childrenC_484_i2 j) (childrenD_484_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_33 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_130 6 (4, 5)).mono (by decide +kernel) +theorem row_works_484_i2 : Template HasSnaky 5 required_484_i2 envelope_484_i2 := by + refine compose HasSnaky 4 childrenC_484_i2 childrenD_484_i2 children_work_484_i2 (4, 4) + required_484_i2 envelope_484_i2 pivot_mem_484_i2 child_required_sub_484_i2 child_envelope_sub_484_i2 ?_ + intro b hb + exact common_sub_484_i2 (mem_commonEnvelope childrenD_484_i2 b hb) +def required_484_i4 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_484_i4 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (3, 1), (3, 2), (4, 1), (4, 2), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_484_i4 : Fin 2 → Finset Cell := ![(placed21 3 (1, 5) required_5), (placed21 3 (0, 5) required_223)] +def childrenD_484_i4 : Fin 2 → Finset Cell := ![(placed21 3 (1, 5) envelope_5), (placed21 3 (0, 5) envelope_223)] +theorem common_sub_484_i4 : commonEnvelope childrenD_484_i4 ⊆ insert (2, 2) required_484_i4 := by decide +kernel +theorem child_required_sub_484_i4 : ∀ j, childrenC_484_i4 j ⊆ insert (2, 2) required_484_i4 := by decide +kernel +theorem child_envelope_sub_484_i4 : ∀ j, childrenD_484_i4 j ⊆ envelope_484_i4 := by decide +kernel +theorem pivot_mem_484_i4 : (2, 2) ∈ envelope_484_i4 := by decide +kernel +theorem children_work_484_i4 : ∀ j, Template HasSnaky 3 (childrenC_484_i4 j) (childrenD_484_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_223 3 (0, 5)).mono (by decide +kernel) +theorem row_works_484_i4 : Template HasSnaky 4 required_484_i4 envelope_484_i4 := by + refine compose HasSnaky 3 childrenC_484_i4 childrenD_484_i4 children_work_484_i4 (2, 2) + required_484_i4 envelope_484_i4 pivot_mem_484_i4 child_required_sub_484_i4 child_envelope_sub_484_i4 ?_ + intro b hb + exact common_sub_484_i4 (mem_commonEnvelope childrenD_484_i4 b hb) +def required_484_i3 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (3, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_484_i3 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_484_i3 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) required_39), (placed21 2 (5, 0) required_268), required_484_i4] +def childrenD_484_i3 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) envelope_39), (placed21 2 (5, 0) envelope_268), envelope_484_i4] +theorem common_sub_484_i3 : commonEnvelope childrenD_484_i3 ⊆ insert (4, 2) required_484_i3 := by decide +kernel +theorem child_required_sub_484_i3 : ∀ j, childrenC_484_i3 j ⊆ insert (4, 2) required_484_i3 := by decide +kernel +theorem child_envelope_sub_484_i3 : ∀ j, childrenD_484_i3 j ⊆ envelope_484_i3 := by decide +kernel +theorem pivot_mem_484_i3 : (4, 2) ∈ envelope_484_i3 := by decide +kernel +theorem children_work_484_i3 : ∀ j, Template HasSnaky 4 (childrenC_484_i3 j) (childrenD_484_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_39 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_268 2 (5, 0)).mono (by decide +kernel) + · exact row_works_484_i4.mono (by decide +kernel) +theorem row_works_484_i3 : Template HasSnaky 5 required_484_i3 envelope_484_i3 := by + refine compose HasSnaky 4 childrenC_484_i3 childrenD_484_i3 children_work_484_i3 (4, 2) + required_484_i3 envelope_484_i3 pivot_mem_484_i3 child_required_sub_484_i3 child_envelope_sub_484_i3 ?_ + intro b hb + exact common_sub_484_i3 (mem_commonEnvelope childrenD_484_i3 b hb) +def required_484_i0 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_484_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_484_i0 : Fin 3 → Finset Cell := ![required_484_i1, required_484_i2, required_484_i3] +def childrenD_484_i0 : Fin 3 → Finset Cell := ![envelope_484_i1, envelope_484_i2, envelope_484_i3] +theorem common_sub_484_i0 : commonEnvelope childrenD_484_i0 ⊆ insert (3, 2) required_484_i0 := by decide +kernel +theorem child_required_sub_484_i0 : ∀ j, childrenC_484_i0 j ⊆ insert (3, 2) required_484_i0 := by decide +kernel +theorem child_envelope_sub_484_i0 : ∀ j, childrenD_484_i0 j ⊆ envelope_484_i0 := by decide +kernel +theorem pivot_mem_484_i0 : (3, 2) ∈ envelope_484_i0 := by decide +kernel +theorem children_work_484_i0 : ∀ j, Template HasSnaky 5 (childrenC_484_i0 j) (childrenD_484_i0 j) := by + intro j + fin_cases j + · exact row_works_484_i1.mono (by decide +kernel) + · exact row_works_484_i2.mono (by decide +kernel) + · exact row_works_484_i3.mono (by decide +kernel) +theorem row_works_484_i0 : Template HasSnaky 6 required_484_i0 envelope_484_i0 := by + refine compose HasSnaky 5 childrenC_484_i0 childrenD_484_i0 children_work_484_i0 (3, 2) + required_484_i0 envelope_484_i0 pivot_mem_484_i0 child_required_sub_484_i0 child_envelope_sub_484_i0 ?_ + intro b hb + exact common_sub_484_i0 (mem_commonEnvelope childrenD_484_i0 b hb) +def required_484_i6 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_484_i6 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_484_i6 : Fin 3 → Finset Cell := ![(placed21 0 (1, 2) required_58), (placed21 6 (5, 6) required_168), (placed21 6 (4, 5) required_357)] +def childrenD_484_i6 : Fin 3 → Finset Cell := ![(placed21 0 (1, 2) envelope_58), (placed21 6 (5, 6) envelope_168), (placed21 6 (4, 5) envelope_357)] +theorem common_sub_484_i6 : commonEnvelope childrenD_484_i6 ⊆ insert (4, 4) required_484_i6 := by decide +kernel +theorem child_required_sub_484_i6 : ∀ j, childrenC_484_i6 j ⊆ insert (4, 4) required_484_i6 := by decide +kernel +theorem child_envelope_sub_484_i6 : ∀ j, childrenD_484_i6 j ⊆ envelope_484_i6 := by decide +kernel +theorem pivot_mem_484_i6 : (4, 4) ∈ envelope_484_i6 := by decide +kernel +theorem children_work_484_i6 : ∀ j, Template HasSnaky 5 (childrenC_484_i6 j) (childrenD_484_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_58 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_168 6 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_357 6 (4, 5)).mono (by decide +kernel) +theorem row_works_484_i6 : Template HasSnaky 6 required_484_i6 envelope_484_i6 := by + refine compose HasSnaky 5 childrenC_484_i6 childrenD_484_i6 children_work_484_i6 (4, 4) + required_484_i6 envelope_484_i6 pivot_mem_484_i6 child_required_sub_484_i6 child_envelope_sub_484_i6 ?_ + intro b hb + exact common_sub_484_i6 (mem_commonEnvelope childrenD_484_i6 b hb) +def required_484_i5 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_484_i5 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 6), (0, 7), (0, 8), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_484_i5 : Fin 2 → Finset Cell := ![(placed21 5 (2, 2) required_314), required_484_i6] +def childrenD_484_i5 : Fin 2 → Finset Cell := ![(placed21 5 (2, 2) envelope_314), envelope_484_i6] +theorem common_sub_484_i5 : commonEnvelope childrenD_484_i5 ⊆ insert (2, 4) required_484_i5 := by decide +kernel +theorem child_required_sub_484_i5 : ∀ j, childrenC_484_i5 j ⊆ insert (2, 4) required_484_i5 := by decide +kernel +theorem child_envelope_sub_484_i5 : ∀ j, childrenD_484_i5 j ⊆ envelope_484_i5 := by decide +kernel +theorem pivot_mem_484_i5 : (2, 4) ∈ envelope_484_i5 := by decide +kernel +theorem children_work_484_i5 : ∀ j, Template HasSnaky 6 (childrenC_484_i5 j) (childrenD_484_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_314 5 (2, 2)).mono (by decide +kernel) + · exact row_works_484_i6.mono (by decide +kernel) +theorem row_works_484_i5 : Template HasSnaky 7 required_484_i5 envelope_484_i5 := by + refine compose HasSnaky 6 childrenC_484_i5 childrenD_484_i5 children_work_484_i5 (2, 4) + required_484_i5 envelope_484_i5 pivot_mem_484_i5 child_required_sub_484_i5 child_envelope_sub_484_i5 ?_ + intro b hb + exact common_sub_484_i5 (mem_commonEnvelope childrenD_484_i5 b hb) +def required_484 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_484 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 6), (0, 7), (0, 8), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_484 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) required_81), (placed21 4 (0, 8) required_204), required_484_i0, required_484_i5] +def childrenD_484 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) envelope_81), (placed21 4 (0, 8) envelope_204), envelope_484_i0, envelope_484_i5] +theorem common_sub_484 : commonEnvelope childrenD_484 ⊆ insert (4, 5) required_484 := by decide +kernel +theorem child_required_sub_484 : ∀ j, childrenC_484 j ⊆ insert (4, 5) required_484 := by decide +kernel +theorem child_envelope_sub_484 : ∀ j, childrenD_484 j ⊆ envelope_484 := by decide +kernel +theorem pivot_mem_484 : (4, 5) ∈ envelope_484 := by decide +kernel +theorem children_work_484 : ∀ j, Template HasSnaky 7 (childrenC_484 j) (childrenD_484 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_81 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_204 4 (0, 8)).mono (by decide +kernel) + · exact row_works_484_i0.mono (by decide +kernel) + · exact row_works_484_i5.mono (by decide +kernel) +theorem row_works_484 : Template HasSnaky 8 required_484 envelope_484 := by + refine compose HasSnaky 7 childrenC_484 childrenD_484 children_work_484 (4, 5) + required_484 envelope_484 pivot_mem_484 child_required_sub_484 child_envelope_sub_484 ?_ + intro b hb + exact common_sub_484 (mem_commonEnvelope childrenD_484 b hb) +def required_494 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (3, 1), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_494 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_494 : Fin 4 → Finset Cell := ![(placed21 0 (3, 0) required_7), required_87, required_286, required_492] +def childrenD_494 : Fin 4 → Finset Cell := ![(placed21 0 (3, 0) envelope_7), envelope_87, envelope_286, envelope_492] +theorem common_sub_494 : commonEnvelope childrenD_494 ⊆ insert (3, 3) required_494 := by decide +kernel +theorem child_required_sub_494 : ∀ j, childrenC_494 j ⊆ insert (3, 3) required_494 := by decide +kernel +theorem child_envelope_sub_494 : ∀ j, childrenD_494 j ⊆ envelope_494 := by decide +kernel +theorem pivot_mem_494 : (3, 3) ∈ envelope_494 := by decide +kernel +theorem children_work_494 : ∀ j, Template HasSnaky 7 (childrenC_494 j) (childrenD_494 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (3, 0)).mono (by decide +kernel) + · exact row_works_87.mono (by decide +kernel) + · exact row_works_286.mono (by decide +kernel) + · exact row_works_492.mono (by decide +kernel) +theorem row_works_494 : Template HasSnaky 8 required_494 envelope_494 := by + refine compose HasSnaky 7 childrenC_494 childrenD_494 children_work_494 (3, 3) + required_494 envelope_494 pivot_mem_494 child_required_sub_494 child_envelope_sub_494 ?_ + intro b hb + exact common_sub_494 (mem_commonEnvelope childrenD_494 b hb) +def required_510_i0 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_510_i0 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_510_i0 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) required_0), (placed21 5 (4, 3) required_138)] +def childrenD_510_i0 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) envelope_0), (placed21 5 (4, 3) envelope_138)] +theorem common_sub_510_i0 : commonEnvelope childrenD_510_i0 ⊆ insert (1, 4) required_510_i0 := by decide +kernel +theorem child_required_sub_510_i0 : ∀ j, childrenC_510_i0 j ⊆ insert (1, 4) required_510_i0 := by decide +kernel +theorem child_envelope_sub_510_i0 : ∀ j, childrenD_510_i0 j ⊆ envelope_510_i0 := by decide +kernel +theorem pivot_mem_510_i0 : (1, 4) ∈ envelope_510_i0 := by decide +kernel +theorem children_work_510_i0 : ∀ j, Template HasSnaky 2 (childrenC_510_i0 j) (childrenD_510_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_138 5 (4, 3)).mono (by decide +kernel) +theorem row_works_510_i0 : Template HasSnaky 3 required_510_i0 envelope_510_i0 := by + refine compose HasSnaky 2 childrenC_510_i0 childrenD_510_i0 children_work_510_i0 (1, 4) + required_510_i0 envelope_510_i0 pivot_mem_510_i0 child_required_sub_510_i0 child_envelope_sub_510_i0 ?_ + intro b hb + exact common_sub_510_i0 (mem_commonEnvelope childrenD_510_i0 b hb) +def required_510 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_510 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_510 : Fin 3 → Finset Cell := ![(placed21 3 (1, 4) required_10), required_510_i0, (placed21 0 (1, 0) required_507)] +def childrenD_510 : Fin 3 → Finset Cell := ![(placed21 3 (1, 4) envelope_10), envelope_510_i0, (placed21 0 (1, 0) envelope_507)] +theorem common_sub_510 : commonEnvelope childrenD_510 ⊆ insert (4, 3) required_510 := by decide +kernel +theorem child_required_sub_510 : ∀ j, childrenC_510 j ⊆ insert (4, 3) required_510 := by decide +kernel +theorem child_envelope_sub_510 : ∀ j, childrenD_510 j ⊆ envelope_510 := by decide +kernel +theorem pivot_mem_510 : (4, 3) ∈ envelope_510 := by decide +kernel +theorem children_work_510 : ∀ j, Template HasSnaky 7 (childrenC_510 j) (childrenD_510 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 3 (1, 4)).mono (by decide +kernel) + · exact row_works_510_i0.mono (by decide +kernel) + · exact (placed21_template row_works_507 0 (1, 0)).mono (by decide +kernel) +theorem row_works_510 : Template HasSnaky 8 required_510 envelope_510 := by + refine compose HasSnaky 7 childrenC_510 childrenD_510 children_work_510 (4, 3) + required_510 envelope_510 pivot_mem_510 child_required_sub_510 child_envelope_sub_510 ?_ + intro b hb + exact common_sub_510 (mem_commonEnvelope childrenD_510 b hb) +def required_513_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (3, 2), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_513_i0 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_513_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 1) required_5), (placed21 5 (5, 1) required_439)] +def childrenD_513_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 1) envelope_5), (placed21 5 (5, 1) envelope_439)] +theorem common_sub_513_i0 : commonEnvelope childrenD_513_i0 ⊆ insert (0, 4) required_513_i0 := by decide +kernel +theorem child_required_sub_513_i0 : ∀ j, childrenC_513_i0 j ⊆ insert (0, 4) required_513_i0 := by decide +kernel +theorem child_envelope_sub_513_i0 : ∀ j, childrenD_513_i0 j ⊆ envelope_513_i0 := by decide +kernel +theorem pivot_mem_513_i0 : (0, 4) ∈ envelope_513_i0 := by decide +kernel +theorem children_work_513_i0 : ∀ j, Template HasSnaky 6 (childrenC_513_i0 j) (childrenD_513_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_439 5 (5, 1)).mono (by decide +kernel) +theorem row_works_513_i0 : Template HasSnaky 7 required_513_i0 envelope_513_i0 := by + refine compose HasSnaky 6 childrenC_513_i0 childrenD_513_i0 children_work_513_i0 (0, 4) + required_513_i0 envelope_513_i0 pivot_mem_513_i0 child_required_sub_513_i0 child_envelope_sub_513_i0 ?_ + intro b hb + exact common_sub_513_i0 (mem_commonEnvelope childrenD_513_i0 b hb) +def required_513 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (3, 2), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_513 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_513 : Fin 3 → Finset Cell := ![(placed21 2 (1, 0) required_7), required_9, required_513_i0] +def childrenD_513 : Fin 3 → Finset Cell := ![(placed21 2 (1, 0) envelope_7), envelope_9, envelope_513_i0] +theorem common_sub_513 : commonEnvelope childrenD_513 ⊆ insert (1, 4) required_513 := by decide +kernel +theorem child_required_sub_513 : ∀ j, childrenC_513 j ⊆ insert (1, 4) required_513 := by decide +kernel +theorem child_envelope_sub_513 : ∀ j, childrenD_513 j ⊆ envelope_513 := by decide +kernel +theorem pivot_mem_513 : (1, 4) ∈ envelope_513 := by decide +kernel +theorem children_work_513 : ∀ j, Template HasSnaky 7 (childrenC_513 j) (childrenD_513 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (1, 0)).mono (by decide +kernel) + · exact row_works_9.mono (by decide +kernel) + · exact row_works_513_i0.mono (by decide +kernel) +theorem row_works_513 : Template HasSnaky 8 required_513 envelope_513 := by + refine compose HasSnaky 7 childrenC_513 childrenD_513 children_work_513 (1, 4) + required_513 envelope_513 pivot_mem_513 child_required_sub_513 child_envelope_sub_513 ?_ + intro b hb + exact common_sub_513 (mem_commonEnvelope childrenD_513 b hb) +def height_452_i0 : ℕ := 5 +def childrenH_452_i0 : Fin 2 → ℕ := ![height_5, height_55] +theorem height_exact_452_i0 : height_452_i0 = 1 + Finset.univ.sup childrenH_452_i0 := by decide +kernel +theorem required_origin_452_i0 : ∀ x ∈ required_452_i0, + (∃ j, x ∈ childrenC_452_i0 j) ∨ ∀ j, x ∈ childrenD_452_i0 j := by decide +kernel +theorem required_exact_452_i0 : required_452_i0 = + ((Finset.univ.biUnion childrenC_452_i0) ∪ commonEnvelope childrenD_452_i0).erase (6, 4) := by + exact required_eq_combination childrenC_452_i0 childrenD_452_i0 (6, 4) required_452_i0 + (by decide +kernel) child_required_sub_452_i0 common_sub_452_i0 required_origin_452_i0 +theorem envelope_origin_452_i0 : ∀ x ∈ envelope_452_i0, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_452_i0 j := by decide +kernel +theorem envelope_exact_452_i0 : envelope_452_i0 = + insert (6, 4) (Finset.univ.biUnion childrenD_452_i0) := by + exact envelope_eq_combination childrenD_452_i0 (6, 4) envelope_452_i0 + pivot_mem_452_i0 child_envelope_sub_452_i0 envelope_origin_452_i0 +def checked_452_i0 : CheckedCard where + required := required_452_i0 + envelope := envelope_452_i0 + height := height_452_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_452_i0 +def height_452 : ℕ := 8 +def childrenH_452 : Fin 3 → ℕ := ![height_52, height_317, height_452_i0] +theorem height_exact_452 : height_452 = 1 + Finset.univ.sup childrenH_452 := by decide +kernel +theorem required_origin_452 : ∀ x ∈ required_452, + (∃ j, x ∈ childrenC_452 j) ∨ ∀ j, x ∈ childrenD_452 j := by decide +kernel +theorem required_exact_452 : required_452 = + ((Finset.univ.biUnion childrenC_452) ∪ commonEnvelope childrenD_452).erase (4, 4) := by + exact required_eq_combination childrenC_452 childrenD_452 (4, 4) required_452 + (by decide +kernel) child_required_sub_452 common_sub_452 required_origin_452 +theorem envelope_origin_452 : ∀ x ∈ envelope_452, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_452 j := by decide +kernel +theorem envelope_exact_452 : envelope_452 = + insert (4, 4) (Finset.univ.biUnion childrenD_452) := by + exact envelope_eq_combination childrenD_452 (4, 4) envelope_452 + pivot_mem_452 child_envelope_sub_452 envelope_origin_452 +def checked_452 : CheckedCard where + required := required_452 + envelope := envelope_452 + height := height_452 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_452 +def height_454 : ℕ := 8 +def childrenH_454 : Fin 2 → ℕ := ![height_5, height_453] +theorem height_exact_454 : height_454 = 1 + Finset.univ.sup childrenH_454 := by decide +kernel +theorem required_origin_454 : ∀ x ∈ required_454, + (∃ j, x ∈ childrenC_454 j) ∨ ∀ j, x ∈ childrenD_454 j := by decide +kernel +theorem required_exact_454 : required_454 = + ((Finset.univ.biUnion childrenC_454) ∪ commonEnvelope childrenD_454).erase (1, 3) := by + exact required_eq_combination childrenC_454 childrenD_454 (1, 3) required_454 + (by decide +kernel) child_required_sub_454 common_sub_454 required_origin_454 +theorem envelope_origin_454 : ∀ x ∈ envelope_454, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_454 j := by decide +kernel +theorem envelope_exact_454 : envelope_454 = + insert (1, 3) (Finset.univ.biUnion childrenD_454) := by + exact envelope_eq_combination childrenD_454 (1, 3) envelope_454 + pivot_mem_454 child_envelope_sub_454 envelope_origin_454 +def checked_454 : CheckedCard where + required := required_454 + envelope := envelope_454 + height := height_454 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_454 +def height_455 : ℕ := 8 +def childrenH_455 : Fin 4 → ℕ := ![height_8, height_16, height_24, height_453] +theorem height_exact_455 : height_455 = 1 + Finset.univ.sup childrenH_455 := by decide +kernel +theorem required_origin_455 : ∀ x ∈ required_455, + (∃ j, x ∈ childrenC_455 j) ∨ ∀ j, x ∈ childrenD_455 j := by decide +kernel +theorem required_exact_455 : required_455 = + ((Finset.univ.biUnion childrenC_455) ∪ commonEnvelope childrenD_455).erase (1, 1) := by + exact required_eq_combination childrenC_455 childrenD_455 (1, 1) required_455 + (by decide +kernel) child_required_sub_455 common_sub_455 required_origin_455 +theorem envelope_origin_455 : ∀ x ∈ envelope_455, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_455 j := by decide +kernel +theorem envelope_exact_455 : envelope_455 = + insert (1, 1) (Finset.univ.biUnion childrenD_455) := by + exact envelope_eq_combination childrenD_455 (1, 1) envelope_455 + pivot_mem_455 child_envelope_sub_455 envelope_origin_455 +def checked_455 : CheckedCard where + required := required_455 + envelope := envelope_455 + height := height_455 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_455 +def height_456 : ℕ := 8 +def childrenH_456 : Fin 2 → ℕ := ![height_5, height_453] +theorem height_exact_456 : height_456 = 1 + Finset.univ.sup childrenH_456 := by decide +kernel +theorem required_origin_456 : ∀ x ∈ required_456, + (∃ j, x ∈ childrenC_456 j) ∨ ∀ j, x ∈ childrenD_456 j := by decide +kernel +theorem required_exact_456 : required_456 = + ((Finset.univ.biUnion childrenC_456) ∪ commonEnvelope childrenD_456).erase (2, 4) := by + exact required_eq_combination childrenC_456 childrenD_456 (2, 4) required_456 + (by decide +kernel) child_required_sub_456 common_sub_456 required_origin_456 +theorem envelope_origin_456 : ∀ x ∈ envelope_456, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_456 j := by decide +kernel +theorem envelope_exact_456 : envelope_456 = + insert (2, 4) (Finset.univ.biUnion childrenD_456) := by + exact envelope_eq_combination childrenD_456 (2, 4) envelope_456 + pivot_mem_456 child_envelope_sub_456 envelope_origin_456 +def checked_456 : CheckedCard where + required := required_456 + envelope := envelope_456 + height := height_456 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_456 +def height_473 : ℕ := 8 +def childrenH_473 : Fin 2 → ℕ := ![height_5, height_472] +theorem height_exact_473 : height_473 = 1 + Finset.univ.sup childrenH_473 := by decide +kernel +theorem required_origin_473 : ∀ x ∈ required_473, + (∃ j, x ∈ childrenC_473 j) ∨ ∀ j, x ∈ childrenD_473 j := by decide +kernel +theorem required_exact_473 : required_473 = + ((Finset.univ.biUnion childrenC_473) ∪ commonEnvelope childrenD_473).erase (1, 1) := by + exact required_eq_combination childrenC_473 childrenD_473 (1, 1) required_473 + (by decide +kernel) child_required_sub_473 common_sub_473 required_origin_473 +theorem envelope_origin_473 : ∀ x ∈ envelope_473, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_473 j := by decide +kernel +theorem envelope_exact_473 : envelope_473 = + insert (1, 1) (Finset.univ.biUnion childrenD_473) := by + exact envelope_eq_combination childrenD_473 (1, 1) envelope_473 + pivot_mem_473 child_envelope_sub_473 envelope_origin_473 +def checked_473 : CheckedCard where + required := required_473 + envelope := envelope_473 + height := height_473 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_473 +def height_478 : ℕ := 8 +def childrenH_478 : Fin 2 → ℕ := ![height_5, height_472] +theorem height_exact_478 : height_478 = 1 + Finset.univ.sup childrenH_478 := by decide +kernel +theorem required_origin_478 : ∀ x ∈ required_478, + (∃ j, x ∈ childrenC_478 j) ∨ ∀ j, x ∈ childrenD_478 j := by decide +kernel +theorem required_exact_478 : required_478 = + ((Finset.univ.biUnion childrenC_478) ∪ commonEnvelope childrenD_478).erase (2, 2) := by + exact required_eq_combination childrenC_478 childrenD_478 (2, 2) required_478 + (by decide +kernel) child_required_sub_478 common_sub_478 required_origin_478 +theorem envelope_origin_478 : ∀ x ∈ envelope_478, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_478 j := by decide +kernel +theorem envelope_exact_478 : envelope_478 = + insert (2, 2) (Finset.univ.biUnion childrenD_478) := by + exact envelope_eq_combination childrenD_478 (2, 2) envelope_478 + pivot_mem_478 child_envelope_sub_478 envelope_origin_478 +def checked_478 : CheckedCard where + required := required_478 + envelope := envelope_478 + height := height_478 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_478 +def height_482 : ℕ := 8 +def childrenH_482 : Fin 4 → ℕ := ![height_7, height_24, height_124, height_472] +theorem height_exact_482 : height_482 = 1 + Finset.univ.sup childrenH_482 := by decide +kernel +theorem required_origin_482 : ∀ x ∈ required_482, + (∃ j, x ∈ childrenC_482 j) ∨ ∀ j, x ∈ childrenD_482 j := by decide +kernel +theorem required_exact_482 : required_482 = + ((Finset.univ.biUnion childrenC_482) ∪ commonEnvelope childrenD_482).erase (2, 2) := by + exact required_eq_combination childrenC_482 childrenD_482 (2, 2) required_482 + (by decide +kernel) child_required_sub_482 common_sub_482 required_origin_482 +theorem envelope_origin_482 : ∀ x ∈ envelope_482, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_482 j := by decide +kernel +theorem envelope_exact_482 : envelope_482 = + insert (2, 2) (Finset.univ.biUnion childrenD_482) := by + exact envelope_eq_combination childrenD_482 (2, 2) envelope_482 + pivot_mem_482 child_envelope_sub_482 envelope_origin_482 +def checked_482 : CheckedCard where + required := required_482 + envelope := envelope_482 + height := height_482 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_482 +def height_484_i1 : ℕ := 3 +def childrenH_484_i1 : Fin 2 → ℕ := ![height_5, height_96] +theorem height_exact_484_i1 : height_484_i1 = 1 + Finset.univ.sup childrenH_484_i1 := by decide +kernel +theorem required_origin_484_i1 : ∀ x ∈ required_484_i1, + (∃ j, x ∈ childrenC_484_i1 j) ∨ ∀ j, x ∈ childrenD_484_i1 j := by decide +kernel +theorem required_exact_484_i1 : required_484_i1 = + ((Finset.univ.biUnion childrenC_484_i1) ∪ commonEnvelope childrenD_484_i1).erase (2, 2) := by + exact required_eq_combination childrenC_484_i1 childrenD_484_i1 (2, 2) required_484_i1 + (by decide +kernel) child_required_sub_484_i1 common_sub_484_i1 required_origin_484_i1 +theorem envelope_origin_484_i1 : ∀ x ∈ envelope_484_i1, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_484_i1 j := by decide +kernel +theorem envelope_exact_484_i1 : envelope_484_i1 = + insert (2, 2) (Finset.univ.biUnion childrenD_484_i1) := by + exact envelope_eq_combination childrenD_484_i1 (2, 2) envelope_484_i1 + pivot_mem_484_i1 child_envelope_sub_484_i1 envelope_origin_484_i1 +def checked_484_i1 : CheckedCard where + required := required_484_i1 + envelope := envelope_484_i1 + height := height_484_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_484_i1 +def height_484_i2 : ℕ := 5 +def childrenH_484_i2 : Fin 3 → ℕ := ![height_18, height_33, height_130] +theorem height_exact_484_i2 : height_484_i2 = 1 + Finset.univ.sup childrenH_484_i2 := by decide +kernel +theorem required_origin_484_i2 : ∀ x ∈ required_484_i2, + (∃ j, x ∈ childrenC_484_i2 j) ∨ ∀ j, x ∈ childrenD_484_i2 j := by decide +kernel +theorem required_exact_484_i2 : required_484_i2 = + ((Finset.univ.biUnion childrenC_484_i2) ∪ commonEnvelope childrenD_484_i2).erase (4, 4) := by + exact required_eq_combination childrenC_484_i2 childrenD_484_i2 (4, 4) required_484_i2 + (by decide +kernel) child_required_sub_484_i2 common_sub_484_i2 required_origin_484_i2 +theorem envelope_origin_484_i2 : ∀ x ∈ envelope_484_i2, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_484_i2 j := by decide +kernel +theorem envelope_exact_484_i2 : envelope_484_i2 = + insert (4, 4) (Finset.univ.biUnion childrenD_484_i2) := by + exact envelope_eq_combination childrenD_484_i2 (4, 4) envelope_484_i2 + pivot_mem_484_i2 child_envelope_sub_484_i2 envelope_origin_484_i2 +def checked_484_i2 : CheckedCard where + required := required_484_i2 + envelope := envelope_484_i2 + height := height_484_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_484_i2 +def height_484_i4 : ℕ := 4 +def childrenH_484_i4 : Fin 2 → ℕ := ![height_5, height_223] +theorem height_exact_484_i4 : height_484_i4 = 1 + Finset.univ.sup childrenH_484_i4 := by decide +kernel +theorem required_origin_484_i4 : ∀ x ∈ required_484_i4, + (∃ j, x ∈ childrenC_484_i4 j) ∨ ∀ j, x ∈ childrenD_484_i4 j := by decide +kernel +theorem required_exact_484_i4 : required_484_i4 = + ((Finset.univ.biUnion childrenC_484_i4) ∪ commonEnvelope childrenD_484_i4).erase (2, 2) := by + exact required_eq_combination childrenC_484_i4 childrenD_484_i4 (2, 2) required_484_i4 + (by decide +kernel) child_required_sub_484_i4 common_sub_484_i4 required_origin_484_i4 +theorem envelope_origin_484_i4 : ∀ x ∈ envelope_484_i4, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_484_i4 j := by decide +kernel +theorem envelope_exact_484_i4 : envelope_484_i4 = + insert (2, 2) (Finset.univ.biUnion childrenD_484_i4) := by + exact envelope_eq_combination childrenD_484_i4 (2, 2) envelope_484_i4 + pivot_mem_484_i4 child_envelope_sub_484_i4 envelope_origin_484_i4 +def checked_484_i4 : CheckedCard where + required := required_484_i4 + envelope := envelope_484_i4 + height := height_484_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_484_i4 +def height_484_i3 : ℕ := 5 +def childrenH_484_i3 : Fin 3 → ℕ := ![height_39, height_268, height_484_i4] +theorem height_exact_484_i3 : height_484_i3 = 1 + Finset.univ.sup childrenH_484_i3 := by decide +kernel +theorem required_origin_484_i3 : ∀ x ∈ required_484_i3, + (∃ j, x ∈ childrenC_484_i3 j) ∨ ∀ j, x ∈ childrenD_484_i3 j := by decide +kernel +theorem required_exact_484_i3 : required_484_i3 = + ((Finset.univ.biUnion childrenC_484_i3) ∪ commonEnvelope childrenD_484_i3).erase (4, 2) := by + exact required_eq_combination childrenC_484_i3 childrenD_484_i3 (4, 2) required_484_i3 + (by decide +kernel) child_required_sub_484_i3 common_sub_484_i3 required_origin_484_i3 +theorem envelope_origin_484_i3 : ∀ x ∈ envelope_484_i3, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_484_i3 j := by decide +kernel +theorem envelope_exact_484_i3 : envelope_484_i3 = + insert (4, 2) (Finset.univ.biUnion childrenD_484_i3) := by + exact envelope_eq_combination childrenD_484_i3 (4, 2) envelope_484_i3 + pivot_mem_484_i3 child_envelope_sub_484_i3 envelope_origin_484_i3 +def checked_484_i3 : CheckedCard where + required := required_484_i3 + envelope := envelope_484_i3 + height := height_484_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_484_i3 +def height_484_i0 : ℕ := 6 +def childrenH_484_i0 : Fin 3 → ℕ := ![height_484_i1, height_484_i2, height_484_i3] +theorem height_exact_484_i0 : height_484_i0 = 1 + Finset.univ.sup childrenH_484_i0 := by decide +kernel +theorem required_origin_484_i0 : ∀ x ∈ required_484_i0, + (∃ j, x ∈ childrenC_484_i0 j) ∨ ∀ j, x ∈ childrenD_484_i0 j := by decide +kernel +theorem required_exact_484_i0 : required_484_i0 = + ((Finset.univ.biUnion childrenC_484_i0) ∪ commonEnvelope childrenD_484_i0).erase (3, 2) := by + exact required_eq_combination childrenC_484_i0 childrenD_484_i0 (3, 2) required_484_i0 + (by decide +kernel) child_required_sub_484_i0 common_sub_484_i0 required_origin_484_i0 +theorem envelope_origin_484_i0 : ∀ x ∈ envelope_484_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_484_i0 j := by decide +kernel +theorem envelope_exact_484_i0 : envelope_484_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_484_i0) := by + exact envelope_eq_combination childrenD_484_i0 (3, 2) envelope_484_i0 + pivot_mem_484_i0 child_envelope_sub_484_i0 envelope_origin_484_i0 +def checked_484_i0 : CheckedCard where + required := required_484_i0 + envelope := envelope_484_i0 + height := height_484_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_484_i0 +def height_484_i6 : ℕ := 6 +def childrenH_484_i6 : Fin 3 → ℕ := ![height_58, height_168, height_357] +theorem height_exact_484_i6 : height_484_i6 = 1 + Finset.univ.sup childrenH_484_i6 := by decide +kernel +theorem required_origin_484_i6 : ∀ x ∈ required_484_i6, + (∃ j, x ∈ childrenC_484_i6 j) ∨ ∀ j, x ∈ childrenD_484_i6 j := by decide +kernel +theorem required_exact_484_i6 : required_484_i6 = + ((Finset.univ.biUnion childrenC_484_i6) ∪ commonEnvelope childrenD_484_i6).erase (4, 4) := by + exact required_eq_combination childrenC_484_i6 childrenD_484_i6 (4, 4) required_484_i6 + (by decide +kernel) child_required_sub_484_i6 common_sub_484_i6 required_origin_484_i6 +theorem envelope_origin_484_i6 : ∀ x ∈ envelope_484_i6, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_484_i6 j := by decide +kernel +theorem envelope_exact_484_i6 : envelope_484_i6 = + insert (4, 4) (Finset.univ.biUnion childrenD_484_i6) := by + exact envelope_eq_combination childrenD_484_i6 (4, 4) envelope_484_i6 + pivot_mem_484_i6 child_envelope_sub_484_i6 envelope_origin_484_i6 +def checked_484_i6 : CheckedCard where + required := required_484_i6 + envelope := envelope_484_i6 + height := height_484_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_484_i6 +def height_484_i5 : ℕ := 7 +def childrenH_484_i5 : Fin 2 → ℕ := ![height_314, height_484_i6] +theorem height_exact_484_i5 : height_484_i5 = 1 + Finset.univ.sup childrenH_484_i5 := by decide +kernel +theorem required_origin_484_i5 : ∀ x ∈ required_484_i5, + (∃ j, x ∈ childrenC_484_i5 j) ∨ ∀ j, x ∈ childrenD_484_i5 j := by decide +kernel +theorem required_exact_484_i5 : required_484_i5 = + ((Finset.univ.biUnion childrenC_484_i5) ∪ commonEnvelope childrenD_484_i5).erase (2, 4) := by + exact required_eq_combination childrenC_484_i5 childrenD_484_i5 (2, 4) required_484_i5 + (by decide +kernel) child_required_sub_484_i5 common_sub_484_i5 required_origin_484_i5 +theorem envelope_origin_484_i5 : ∀ x ∈ envelope_484_i5, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_484_i5 j := by decide +kernel +theorem envelope_exact_484_i5 : envelope_484_i5 = + insert (2, 4) (Finset.univ.biUnion childrenD_484_i5) := by + exact envelope_eq_combination childrenD_484_i5 (2, 4) envelope_484_i5 + pivot_mem_484_i5 child_envelope_sub_484_i5 envelope_origin_484_i5 +def checked_484_i5 : CheckedCard where + required := required_484_i5 + envelope := envelope_484_i5 + height := height_484_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_484_i5 +def height_484 : ℕ := 8 +def childrenH_484 : Fin 4 → ℕ := ![height_81, height_204, height_484_i0, height_484_i5] +theorem height_exact_484 : height_484 = 1 + Finset.univ.sup childrenH_484 := by decide +kernel +theorem required_origin_484 : ∀ x ∈ required_484, + (∃ j, x ∈ childrenC_484 j) ∨ ∀ j, x ∈ childrenD_484 j := by decide +kernel +theorem required_exact_484 : required_484 = + ((Finset.univ.biUnion childrenC_484) ∪ commonEnvelope childrenD_484).erase (4, 5) := by + exact required_eq_combination childrenC_484 childrenD_484 (4, 5) required_484 + (by decide +kernel) child_required_sub_484 common_sub_484 required_origin_484 +theorem envelope_origin_484 : ∀ x ∈ envelope_484, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_484 j := by decide +kernel +theorem envelope_exact_484 : envelope_484 = + insert (4, 5) (Finset.univ.biUnion childrenD_484) := by + exact envelope_eq_combination childrenD_484 (4, 5) envelope_484 + pivot_mem_484 child_envelope_sub_484 envelope_origin_484 +def checked_484 : CheckedCard where + required := required_484 + envelope := envelope_484 + height := height_484 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_484 +def height_494 : ℕ := 8 +def childrenH_494 : Fin 4 → ℕ := ![height_7, height_87, height_286, height_492] +theorem height_exact_494 : height_494 = 1 + Finset.univ.sup childrenH_494 := by decide +kernel +theorem required_origin_494 : ∀ x ∈ required_494, + (∃ j, x ∈ childrenC_494 j) ∨ ∀ j, x ∈ childrenD_494 j := by decide +kernel +theorem required_exact_494 : required_494 = + ((Finset.univ.biUnion childrenC_494) ∪ commonEnvelope childrenD_494).erase (3, 3) := by + exact required_eq_combination childrenC_494 childrenD_494 (3, 3) required_494 + (by decide +kernel) child_required_sub_494 common_sub_494 required_origin_494 +theorem envelope_origin_494 : ∀ x ∈ envelope_494, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_494 j := by decide +kernel +theorem envelope_exact_494 : envelope_494 = + insert (3, 3) (Finset.univ.biUnion childrenD_494) := by + exact envelope_eq_combination childrenD_494 (3, 3) envelope_494 + pivot_mem_494 child_envelope_sub_494 envelope_origin_494 +def checked_494 : CheckedCard where + required := required_494 + envelope := envelope_494 + height := height_494 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_494 +def height_510_i0 : ℕ := 3 +def childrenH_510_i0 : Fin 2 → ℕ := ![height_0, height_138] +theorem height_exact_510_i0 : height_510_i0 = 1 + Finset.univ.sup childrenH_510_i0 := by decide +kernel +theorem required_origin_510_i0 : ∀ x ∈ required_510_i0, + (∃ j, x ∈ childrenC_510_i0 j) ∨ ∀ j, x ∈ childrenD_510_i0 j := by decide +kernel +theorem required_exact_510_i0 : required_510_i0 = + ((Finset.univ.biUnion childrenC_510_i0) ∪ commonEnvelope childrenD_510_i0).erase (1, 4) := by + exact required_eq_combination childrenC_510_i0 childrenD_510_i0 (1, 4) required_510_i0 + (by decide +kernel) child_required_sub_510_i0 common_sub_510_i0 required_origin_510_i0 +theorem envelope_origin_510_i0 : ∀ x ∈ envelope_510_i0, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_510_i0 j := by decide +kernel +theorem envelope_exact_510_i0 : envelope_510_i0 = + insert (1, 4) (Finset.univ.biUnion childrenD_510_i0) := by + exact envelope_eq_combination childrenD_510_i0 (1, 4) envelope_510_i0 + pivot_mem_510_i0 child_envelope_sub_510_i0 envelope_origin_510_i0 +def checked_510_i0 : CheckedCard where + required := required_510_i0 + envelope := envelope_510_i0 + height := height_510_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_510_i0 +def height_510 : ℕ := 8 +def childrenH_510 : Fin 3 → ℕ := ![height_10, height_510_i0, height_507] +theorem height_exact_510 : height_510 = 1 + Finset.univ.sup childrenH_510 := by decide +kernel +theorem required_origin_510 : ∀ x ∈ required_510, + (∃ j, x ∈ childrenC_510 j) ∨ ∀ j, x ∈ childrenD_510 j := by decide +kernel +theorem required_exact_510 : required_510 = + ((Finset.univ.biUnion childrenC_510) ∪ commonEnvelope childrenD_510).erase (4, 3) := by + exact required_eq_combination childrenC_510 childrenD_510 (4, 3) required_510 + (by decide +kernel) child_required_sub_510 common_sub_510 required_origin_510 +theorem envelope_origin_510 : ∀ x ∈ envelope_510, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_510 j := by decide +kernel +theorem envelope_exact_510 : envelope_510 = + insert (4, 3) (Finset.univ.biUnion childrenD_510) := by + exact envelope_eq_combination childrenD_510 (4, 3) envelope_510 + pivot_mem_510 child_envelope_sub_510 envelope_origin_510 +def checked_510 : CheckedCard where + required := required_510 + envelope := envelope_510 + height := height_510 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_510 +def height_513_i0 : ℕ := 7 +def childrenH_513_i0 : Fin 2 → ℕ := ![height_5, height_439] +theorem height_exact_513_i0 : height_513_i0 = 1 + Finset.univ.sup childrenH_513_i0 := by decide +kernel +theorem required_origin_513_i0 : ∀ x ∈ required_513_i0, + (∃ j, x ∈ childrenC_513_i0 j) ∨ ∀ j, x ∈ childrenD_513_i0 j := by decide +kernel +theorem required_exact_513_i0 : required_513_i0 = + ((Finset.univ.biUnion childrenC_513_i0) ∪ commonEnvelope childrenD_513_i0).erase (0, 4) := by + exact required_eq_combination childrenC_513_i0 childrenD_513_i0 (0, 4) required_513_i0 + (by decide +kernel) child_required_sub_513_i0 common_sub_513_i0 required_origin_513_i0 +theorem envelope_origin_513_i0 : ∀ x ∈ envelope_513_i0, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_513_i0 j := by decide +kernel +theorem envelope_exact_513_i0 : envelope_513_i0 = + insert (0, 4) (Finset.univ.biUnion childrenD_513_i0) := by + exact envelope_eq_combination childrenD_513_i0 (0, 4) envelope_513_i0 + pivot_mem_513_i0 child_envelope_sub_513_i0 envelope_origin_513_i0 +def checked_513_i0 : CheckedCard where + required := required_513_i0 + envelope := envelope_513_i0 + height := height_513_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_513_i0 +def height_513 : ℕ := 8 +def childrenH_513 : Fin 3 → ℕ := ![height_7, height_9, height_513_i0] +theorem height_exact_513 : height_513 = 1 + Finset.univ.sup childrenH_513 := by decide +kernel +theorem required_origin_513 : ∀ x ∈ required_513, + (∃ j, x ∈ childrenC_513 j) ∨ ∀ j, x ∈ childrenD_513 j := by decide +kernel +theorem required_exact_513 : required_513 = + ((Finset.univ.biUnion childrenC_513) ∪ commonEnvelope childrenD_513).erase (1, 4) := by + exact required_eq_combination childrenC_513 childrenD_513 (1, 4) required_513 + (by decide +kernel) child_required_sub_513 common_sub_513 required_origin_513 +theorem envelope_origin_513 : ∀ x ∈ envelope_513, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_513 j := by decide +kernel +theorem envelope_exact_513 : envelope_513 = + insert (1, 4) (Finset.univ.biUnion childrenD_513) := by + exact envelope_eq_combination childrenD_513 (1, 4) envelope_513 + pivot_mem_513 child_envelope_sub_513 envelope_origin_513 +def checked_513 : CheckedCard where + required := required_513 + envelope := envelope_513 + height := height_513 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_513 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part03.lean new file mode 100644 index 0000000..c2a4a7f --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part03.lean @@ -0,0 +1,954 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_518_i1 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_518_i1 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_518_i1 : Fin 3 → Finset Cell := ![(placed21 2 (3, 3) required_6), (placed21 5 (6, 4) required_213), (placed21 1 (1, 4) required_278)] +def childrenD_518_i1 : Fin 3 → Finset Cell := ![(placed21 2 (3, 3) envelope_6), (placed21 5 (6, 4) envelope_213), (placed21 1 (1, 4) envelope_278)] +theorem common_sub_518_i1 : commonEnvelope childrenD_518_i1 ⊆ insert (3, 7) required_518_i1 := by decide +kernel +theorem child_required_sub_518_i1 : ∀ j, childrenC_518_i1 j ⊆ insert (3, 7) required_518_i1 := by decide +kernel +theorem child_envelope_sub_518_i1 : ∀ j, childrenD_518_i1 j ⊆ envelope_518_i1 := by decide +kernel +theorem pivot_mem_518_i1 : (3, 7) ∈ envelope_518_i1 := by decide +kernel +theorem children_work_518_i1 : ∀ j, Template HasSnaky 5 (childrenC_518_i1 j) (childrenD_518_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 2 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_213 5 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_278 1 (1, 4)).mono (by decide +kernel) +theorem row_works_518_i1 : Template HasSnaky 6 required_518_i1 envelope_518_i1 := by + refine compose HasSnaky 5 childrenC_518_i1 childrenD_518_i1 children_work_518_i1 (3, 7) + required_518_i1 envelope_518_i1 pivot_mem_518_i1 child_required_sub_518_i1 child_envelope_sub_518_i1 ?_ + intro b hb + exact common_sub_518_i1 (mem_commonEnvelope childrenD_518_i1 b hb) +def required_518_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_518_i0 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_518_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 3) required_5), required_518_i1] +def childrenD_518_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 3) envelope_5), envelope_518_i1] +theorem common_sub_518_i0 : commonEnvelope childrenD_518_i0 ⊆ insert (3, 6) required_518_i0 := by decide +kernel +theorem child_required_sub_518_i0 : ∀ j, childrenC_518_i0 j ⊆ insert (3, 6) required_518_i0 := by decide +kernel +theorem child_envelope_sub_518_i0 : ∀ j, childrenD_518_i0 j ⊆ envelope_518_i0 := by decide +kernel +theorem pivot_mem_518_i0 : (3, 6) ∈ envelope_518_i0 := by decide +kernel +theorem children_work_518_i0 : ∀ j, Template HasSnaky 6 (childrenC_518_i0 j) (childrenD_518_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 3)).mono (by decide +kernel) + · exact row_works_518_i1.mono (by decide +kernel) +theorem row_works_518_i0 : Template HasSnaky 7 required_518_i0 envelope_518_i0 := by + refine compose HasSnaky 6 childrenC_518_i0 childrenD_518_i0 children_work_518_i0 (3, 6) + required_518_i0 envelope_518_i0 pivot_mem_518_i0 child_required_sub_518_i0 child_envelope_sub_518_i0 ?_ + intro b hb + exact common_sub_518_i0 (mem_commonEnvelope childrenD_518_i0 b hb) +def required_518 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_518 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_518 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) required_61), (placed21 6 (4, 6) required_89), (placed21 1 (1, 2) required_183), required_518_i0] +def childrenD_518 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) envelope_61), (placed21 6 (4, 6) envelope_89), (placed21 1 (1, 2) envelope_183), envelope_518_i0] +theorem common_sub_518 : commonEnvelope childrenD_518 ⊆ insert (4, 6) required_518 := by decide +kernel +theorem child_required_sub_518 : ∀ j, childrenC_518 j ⊆ insert (4, 6) required_518 := by decide +kernel +theorem child_envelope_sub_518 : ∀ j, childrenD_518 j ⊆ envelope_518 := by decide +kernel +theorem pivot_mem_518 : (4, 6) ∈ envelope_518 := by decide +kernel +theorem children_work_518 : ∀ j, Template HasSnaky 7 (childrenC_518 j) (childrenD_518 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_61 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_89 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_183 1 (1, 2)).mono (by decide +kernel) + · exact row_works_518_i0.mono (by decide +kernel) +theorem row_works_518 : Template HasSnaky 8 required_518 envelope_518 := by + refine compose HasSnaky 7 childrenC_518 childrenD_518 children_work_518 (4, 6) + required_518 envelope_518 pivot_mem_518 child_required_sub_518 child_envelope_sub_518 ?_ + intro b hb + exact common_sub_518 (mem_commonEnvelope childrenD_518 b hb) +def required_523 : Finset Cell := ⟨(([(2, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_523 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 6), (4, 7), (4, 8), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_523 : Fin 5 → Finset Cell := ![(placed21 0 (2, 1) required_14), (placed21 0 (1, 2) required_122), (placed21 4 (1, 6) required_136), (placed21 2 (4, 1) required_367), (placed21 7 (5, 6) required_522)] +def childrenD_523 : Fin 5 → Finset Cell := ![(placed21 0 (2, 1) envelope_14), (placed21 0 (1, 2) envelope_122), (placed21 4 (1, 6) envelope_136), (placed21 2 (4, 1) envelope_367), (placed21 7 (5, 6) envelope_522)] +theorem common_sub_523 : commonEnvelope childrenD_523 ⊆ insert (3, 5) required_523 := by decide +kernel +theorem child_required_sub_523 : ∀ j, childrenC_523 j ⊆ insert (3, 5) required_523 := by decide +kernel +theorem child_envelope_sub_523 : ∀ j, childrenD_523 j ⊆ envelope_523 := by decide +kernel +theorem pivot_mem_523 : (3, 5) ∈ envelope_523 := by decide +kernel +theorem children_work_523 : ∀ j, Template HasSnaky 7 (childrenC_523 j) (childrenD_523 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_122 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_136 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_367 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_522 7 (5, 6)).mono (by decide +kernel) +theorem row_works_523 : Template HasSnaky 8 required_523 envelope_523 := by + refine compose HasSnaky 7 childrenC_523 childrenD_523 children_work_523 (3, 5) + required_523 envelope_523 pivot_mem_523 child_required_sub_523 child_envelope_sub_523 ?_ + intro b hb + exact common_sub_523 (mem_commonEnvelope childrenD_523 b hb) +def required_524 : Finset Cell := ⟨(([(2, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_524 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (4, 8), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_524 : Fin 4 → Finset Cell := ![(placed21 3 (0, 6) required_88), (placed21 1 (0, 2) required_213), (placed21 0 (2, 1) required_254), (placed21 7 (5, 6) required_522)] +def childrenD_524 : Fin 4 → Finset Cell := ![(placed21 3 (0, 6) envelope_88), (placed21 1 (0, 2) envelope_213), (placed21 0 (2, 1) envelope_254), (placed21 7 (5, 6) envelope_522)] +theorem common_sub_524 : commonEnvelope childrenD_524 ⊆ insert (3, 5) required_524 := by decide +kernel +theorem child_required_sub_524 : ∀ j, childrenC_524 j ⊆ insert (3, 5) required_524 := by decide +kernel +theorem child_envelope_sub_524 : ∀ j, childrenD_524 j ⊆ envelope_524 := by decide +kernel +theorem pivot_mem_524 : (3, 5) ∈ envelope_524 := by decide +kernel +theorem children_work_524 : ∀ j, Template HasSnaky 7 (childrenC_524 j) (childrenD_524 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_88 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_213 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_254 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_522 7 (5, 6)).mono (by decide +kernel) +theorem row_works_524 : Template HasSnaky 8 required_524 envelope_524 := by + refine compose HasSnaky 7 childrenC_524 childrenD_524 children_work_524 (3, 5) + required_524 envelope_524 pivot_mem_524 child_required_sub_524 child_envelope_sub_524 ?_ + intro b hb + exact common_sub_524 (mem_commonEnvelope childrenD_524 b hb) +def required_530_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_530_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 5), (3, 6), (3, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_530_i2 : Fin 2 → Finset Cell := ![(placed21 3 (2, 5) required_5), (placed21 0 (1, 2) required_20)] +def childrenD_530_i2 : Fin 2 → Finset Cell := ![(placed21 3 (2, 5) envelope_5), (placed21 0 (1, 2) envelope_20)] +theorem common_sub_530_i2 : commonEnvelope childrenD_530_i2 ⊆ insert (2, 5) required_530_i2 := by decide +kernel +theorem child_required_sub_530_i2 : ∀ j, childrenC_530_i2 j ⊆ insert (2, 5) required_530_i2 := by decide +kernel +theorem child_envelope_sub_530_i2 : ∀ j, childrenD_530_i2 j ⊆ envelope_530_i2 := by decide +kernel +theorem pivot_mem_530_i2 : (2, 5) ∈ envelope_530_i2 := by decide +kernel +theorem children_work_530_i2 : ∀ j, Template HasSnaky 3 (childrenC_530_i2 j) (childrenD_530_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_20 0 (1, 2)).mono (by decide +kernel) +theorem row_works_530_i2 : Template HasSnaky 4 required_530_i2 envelope_530_i2 := by + refine compose HasSnaky 3 childrenC_530_i2 childrenD_530_i2 children_work_530_i2 (2, 5) + required_530_i2 envelope_530_i2 pivot_mem_530_i2 child_required_sub_530_i2 child_envelope_sub_530_i2 ?_ + intro b hb + exact common_sub_530_i2 (mem_commonEnvelope childrenD_530_i2 b hb) +def required_530_i1 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_530_i1 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_530_i1 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) required_51), required_530_i2] +def childrenD_530_i1 : Fin 2 → Finset Cell := ![(placed21 3 (0, 3) envelope_51), envelope_530_i2] +theorem common_sub_530_i1 : commonEnvelope childrenD_530_i1 ⊆ insert (3, 2) required_530_i1 := by decide +kernel +theorem child_required_sub_530_i1 : ∀ j, childrenC_530_i1 j ⊆ insert (3, 2) required_530_i1 := by decide +kernel +theorem child_envelope_sub_530_i1 : ∀ j, childrenD_530_i1 j ⊆ envelope_530_i1 := by decide +kernel +theorem pivot_mem_530_i1 : (3, 2) ∈ envelope_530_i1 := by decide +kernel +theorem children_work_530_i1 : ∀ j, Template HasSnaky 4 (childrenC_530_i1 j) (childrenD_530_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_51 3 (0, 3)).mono (by decide +kernel) + · exact row_works_530_i2.mono (by decide +kernel) +theorem row_works_530_i1 : Template HasSnaky 5 required_530_i1 envelope_530_i1 := by + refine compose HasSnaky 4 childrenC_530_i1 childrenD_530_i1 children_work_530_i1 (3, 2) + required_530_i1 envelope_530_i1 pivot_mem_530_i1 child_required_sub_530_i1 child_envelope_sub_530_i1 ?_ + intro b hb + exact common_sub_530_i1 (mem_commonEnvelope childrenD_530_i1 b hb) +def required_530_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_530_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (4, 2), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_530_i0 : Fin 2 → Finset Cell := ![(placed21 6 (2, 5) required_23), required_530_i1] +def childrenD_530_i0 : Fin 2 → Finset Cell := ![(placed21 6 (2, 5) envelope_23), envelope_530_i1] +theorem common_sub_530_i0 : commonEnvelope childrenD_530_i0 ⊆ insert (2, 2) required_530_i0 := by decide +kernel +theorem child_required_sub_530_i0 : ∀ j, childrenC_530_i0 j ⊆ insert (2, 2) required_530_i0 := by decide +kernel +theorem child_envelope_sub_530_i0 : ∀ j, childrenD_530_i0 j ⊆ envelope_530_i0 := by decide +kernel +theorem pivot_mem_530_i0 : (2, 2) ∈ envelope_530_i0 := by decide +kernel +theorem children_work_530_i0 : ∀ j, Template HasSnaky 5 (childrenC_530_i0 j) (childrenD_530_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_23 6 (2, 5)).mono (by decide +kernel) + · exact row_works_530_i1.mono (by decide +kernel) +theorem row_works_530_i0 : Template HasSnaky 6 required_530_i0 envelope_530_i0 := by + refine compose HasSnaky 5 childrenC_530_i0 childrenD_530_i0 children_work_530_i0 (2, 2) + required_530_i0 envelope_530_i0 pivot_mem_530_i0 child_required_sub_530_i0 child_envelope_sub_530_i0 ?_ + intro b hb + exact common_sub_530_i0 (mem_commonEnvelope childrenD_530_i0 b hb) +def required_530 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_530 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_530 : Fin 4 → Finset Cell := ![(placed21 4 (0, 5) required_72), (placed21 4 (0, 5) required_360), (placed21 0 (0, 1) required_499), required_530_i0] +def childrenD_530 : Fin 4 → Finset Cell := ![(placed21 4 (0, 5) envelope_72), (placed21 4 (0, 5) envelope_360), (placed21 0 (0, 1) envelope_499), envelope_530_i0] +theorem common_sub_530 : commonEnvelope childrenD_530 ⊆ insert (2, 4) required_530 := by decide +kernel +theorem child_required_sub_530 : ∀ j, childrenC_530 j ⊆ insert (2, 4) required_530 := by decide +kernel +theorem child_envelope_sub_530 : ∀ j, childrenD_530 j ⊆ envelope_530 := by decide +kernel +theorem pivot_mem_530 : (2, 4) ∈ envelope_530 := by decide +kernel +theorem children_work_530 : ∀ j, Template HasSnaky 7 (childrenC_530 j) (childrenD_530 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_72 4 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_360 4 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_499 0 (0, 1)).mono (by decide +kernel) + · exact row_works_530_i0.mono (by decide +kernel) +theorem row_works_530 : Template HasSnaky 8 required_530 envelope_530 := by + refine compose HasSnaky 7 childrenC_530 childrenD_530 children_work_530 (2, 4) + required_530 envelope_530 pivot_mem_530 child_required_sub_530 child_envelope_sub_530 ?_ + intro b hb + exact common_sub_530 (mem_commonEnvelope childrenD_530 b hb) +def required_532_i0 : Finset Cell := ⟨(([(2, 3), (2, 4), (2, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_532_i0 : Finset Cell := ⟨(([(1, 4), (1, 5), (1, 7), (1, 8), (1, 9), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 2), (4, 3), (4, 6), (4, 7), (5, 3), (5, 6), (6, 3), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_532_i0 : Fin 4 → Finset Cell := ![(placed21 2 (3, 2) required_19), (placed21 2 (3, 2) required_84), (placed21 5 (3, 3) required_314), (placed21 4 (1, 7) required_521)] +def childrenD_532_i0 : Fin 4 → Finset Cell := ![(placed21 2 (3, 2) envelope_19), (placed21 2 (3, 2) envelope_84), (placed21 5 (3, 3) envelope_314), (placed21 4 (1, 7) envelope_521)] +theorem common_sub_532_i0 : commonEnvelope childrenD_532_i0 ⊆ insert (2, 6) required_532_i0 := by decide +kernel +theorem child_required_sub_532_i0 : ∀ j, childrenC_532_i0 j ⊆ insert (2, 6) required_532_i0 := by decide +kernel +theorem child_envelope_sub_532_i0 : ∀ j, childrenD_532_i0 j ⊆ envelope_532_i0 := by decide +kernel +theorem pivot_mem_532_i0 : (2, 6) ∈ envelope_532_i0 := by decide +kernel +theorem children_work_532_i0 : ∀ j, Template HasSnaky 6 (childrenC_532_i0 j) (childrenD_532_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 2 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_84 2 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_314 5 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_521 4 (1, 7)).mono (by decide +kernel) +theorem row_works_532_i0 : Template HasSnaky 7 required_532_i0 envelope_532_i0 := by + refine compose HasSnaky 6 childrenC_532_i0 childrenD_532_i0 children_work_532_i0 (2, 6) + required_532_i0 envelope_532_i0 pivot_mem_532_i0 child_required_sub_532_i0 child_envelope_sub_532_i0 ?_ + intro b hb + exact common_sub_532_i0 (mem_commonEnvelope childrenD_532_i0 b hb) +def required_532 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_532 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (1, 7), (1, 8), (1, 9), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 2), (4, 3), (4, 6), (4, 7), (5, 3), (5, 6), (6, 3), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_532 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) required_44), (placed21 0 (2, 2) required_52), (placed21 3 (0, 6) required_134), required_532_i0] +def childrenD_532 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) envelope_44), (placed21 0 (2, 2) envelope_52), (placed21 3 (0, 6) envelope_134), envelope_532_i0] +theorem common_sub_532 : commonEnvelope childrenD_532 ⊆ insert (2, 3) required_532 := by decide +kernel +theorem child_required_sub_532 : ∀ j, childrenC_532 j ⊆ insert (2, 3) required_532 := by decide +kernel +theorem child_envelope_sub_532 : ∀ j, childrenD_532 j ⊆ envelope_532 := by decide +kernel +theorem pivot_mem_532 : (2, 3) ∈ envelope_532 := by decide +kernel +theorem children_work_532 : ∀ j, Template HasSnaky 7 (childrenC_532 j) (childrenD_532 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_134 3 (0, 6)).mono (by decide +kernel) + · exact row_works_532_i0.mono (by decide +kernel) +theorem row_works_532 : Template HasSnaky 8 required_532 envelope_532 := by + refine compose HasSnaky 7 childrenC_532 childrenD_532 children_work_532 (2, 3) + required_532 envelope_532 pivot_mem_532 child_required_sub_532 child_envelope_sub_532 ?_ + intro b hb + exact common_sub_532 (mem_commonEnvelope childrenD_532 b hb) +def required_533_i0 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_533_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_533_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 0) required_53), (placed21 4 (1, 6) required_55), (placed21 7 (5, 4) required_392)] +def childrenD_533_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 0) envelope_53), (placed21 4 (1, 6) envelope_55), (placed21 7 (5, 4) envelope_392)] +theorem common_sub_533_i0 : commonEnvelope childrenD_533_i0 ⊆ insert (3, 4) required_533_i0 := by decide +kernel +theorem child_required_sub_533_i0 : ∀ j, childrenC_533_i0 j ⊆ insert (3, 4) required_533_i0 := by decide +kernel +theorem child_envelope_sub_533_i0 : ∀ j, childrenD_533_i0 j ⊆ envelope_533_i0 := by decide +kernel +theorem pivot_mem_533_i0 : (3, 4) ∈ envelope_533_i0 := by decide +kernel +theorem children_work_533_i0 : ∀ j, Template HasSnaky 6 (childrenC_533_i0 j) (childrenD_533_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 0 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_55 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_392 7 (5, 4)).mono (by decide +kernel) +theorem row_works_533_i0 : Template HasSnaky 7 required_533_i0 envelope_533_i0 := by + refine compose HasSnaky 6 childrenC_533_i0 childrenD_533_i0 children_work_533_i0 (3, 4) + required_533_i0 envelope_533_i0 pivot_mem_533_i0 child_required_sub_533_i0 child_envelope_sub_533_i0 ?_ + intro b hb + exact common_sub_533_i0 (mem_commonEnvelope childrenD_533_i0 b hb) +def required_533 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_533 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2), (5, 3), (6, 2), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_533 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) required_11), (placed21 0 (1, 0) required_279), required_533_i0] +def childrenD_533 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) envelope_11), (placed21 0 (1, 0) envelope_279), envelope_533_i0] +theorem common_sub_533 : commonEnvelope childrenD_533 ⊆ insert (4, 3) required_533 := by decide +kernel +theorem child_required_sub_533 : ∀ j, childrenC_533 j ⊆ insert (4, 3) required_533 := by decide +kernel +theorem child_envelope_sub_533 : ∀ j, childrenD_533 j ⊆ envelope_533 := by decide +kernel +theorem pivot_mem_533 : (4, 3) ∈ envelope_533 := by decide +kernel +theorem children_work_533 : ∀ j, Template HasSnaky 7 (childrenC_533 j) (childrenD_533 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_279 0 (1, 0)).mono (by decide +kernel) + · exact row_works_533_i0.mono (by decide +kernel) +theorem row_works_533 : Template HasSnaky 8 required_533 envelope_533 := by + refine compose HasSnaky 7 childrenC_533 childrenD_533 children_work_533 (4, 3) + required_533 envelope_533 pivot_mem_533 child_required_sub_533 child_envelope_sub_533 ?_ + intro b hb + exact common_sub_533 (mem_commonEnvelope childrenD_533 b hb) +def required_534_i1 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (2, 5), (3, 3), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_534_i1 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 6), (3, 7), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_534_i1 : Fin 2 → Finset Cell := ![(placed21 1 (2, 3) required_5), (placed21 1 (0, 3) required_177)] +def childrenD_534_i1 : Fin 2 → Finset Cell := ![(placed21 1 (2, 3) envelope_5), (placed21 1 (0, 3) envelope_177)] +theorem common_sub_534_i1 : commonEnvelope childrenD_534_i1 ⊆ insert (2, 6) required_534_i1 := by decide +kernel +theorem child_required_sub_534_i1 : ∀ j, childrenC_534_i1 j ⊆ insert (2, 6) required_534_i1 := by decide +kernel +theorem child_envelope_sub_534_i1 : ∀ j, childrenD_534_i1 j ⊆ envelope_534_i1 := by decide +kernel +theorem pivot_mem_534_i1 : (2, 6) ∈ envelope_534_i1 := by decide +kernel +theorem children_work_534_i1 : ∀ j, Template HasSnaky 3 (childrenC_534_i1 j) (childrenD_534_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_177 1 (0, 3)).mono (by decide +kernel) +theorem row_works_534_i1 : Template HasSnaky 4 required_534_i1 envelope_534_i1 := by + refine compose HasSnaky 3 childrenC_534_i1 childrenD_534_i1 children_work_534_i1 (2, 6) + required_534_i1 envelope_534_i1 pivot_mem_534_i1 child_required_sub_534_i1 child_envelope_sub_534_i1 ?_ + intro b hb + exact common_sub_534_i1 (mem_commonEnvelope childrenD_534_i1 b hb) +def required_534_i2 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (2, 5), (3, 3), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_534_i2 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_534_i2 : Fin 2 → Finset Cell := ![(placed21 1 (2, 2) required_0), (placed21 7 (5, 6) required_239)] +def childrenD_534_i2 : Fin 2 → Finset Cell := ![(placed21 1 (2, 2) envelope_0), (placed21 7 (5, 6) envelope_239)] +theorem common_sub_534_i2 : commonEnvelope childrenD_534_i2 ⊆ insert (3, 5) required_534_i2 := by decide +kernel +theorem child_required_sub_534_i2 : ∀ j, childrenC_534_i2 j ⊆ insert (3, 5) required_534_i2 := by decide +kernel +theorem child_envelope_sub_534_i2 : ∀ j, childrenD_534_i2 j ⊆ envelope_534_i2 := by decide +kernel +theorem pivot_mem_534_i2 : (3, 5) ∈ envelope_534_i2 := by decide +kernel +theorem children_work_534_i2 : ∀ j, Template HasSnaky 3 (childrenC_534_i2 j) (childrenD_534_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_239 7 (5, 6)).mono (by decide +kernel) +theorem row_works_534_i2 : Template HasSnaky 4 required_534_i2 envelope_534_i2 := by + refine compose HasSnaky 3 childrenC_534_i2 childrenD_534_i2 children_work_534_i2 (3, 5) + required_534_i2 envelope_534_i2 pivot_mem_534_i2 child_required_sub_534_i2 child_envelope_sub_534_i2 ?_ + intro b hb + exact common_sub_534_i2 (mem_commonEnvelope childrenD_534_i2 b hb) +def required_534_i0 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (2, 5), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_534_i0 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_534_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 2) required_139), required_534_i1, required_534_i2] +def childrenD_534_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 2) envelope_139), envelope_534_i1, envelope_534_i2] +theorem common_sub_534_i0 : commonEnvelope childrenD_534_i0 ⊆ insert (3, 6) required_534_i0 := by decide +kernel +theorem child_required_sub_534_i0 : ∀ j, childrenC_534_i0 j ⊆ insert (3, 6) required_534_i0 := by decide +kernel +theorem child_envelope_sub_534_i0 : ∀ j, childrenD_534_i0 j ⊆ envelope_534_i0 := by decide +kernel +theorem pivot_mem_534_i0 : (3, 6) ∈ envelope_534_i0 := by decide +kernel +theorem children_work_534_i0 : ∀ j, Template HasSnaky 4 (childrenC_534_i0 j) (childrenD_534_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_139 0 (2, 2)).mono (by decide +kernel) + · exact row_works_534_i1.mono (by decide +kernel) + · exact row_works_534_i2.mono (by decide +kernel) +theorem row_works_534_i0 : Template HasSnaky 5 required_534_i0 envelope_534_i0 := by + refine compose HasSnaky 4 childrenC_534_i0 childrenD_534_i0 children_work_534_i0 (3, 6) + required_534_i0 envelope_534_i0 pivot_mem_534_i0 child_required_sub_534_i0 child_envelope_sub_534_i0 ?_ + intro b hb + exact common_sub_534_i0 (mem_commonEnvelope childrenD_534_i0 b hb) +def required_534 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_534 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_534 : Fin 4 → Finset Cell := ![(placed21 4 (2, 6) required_44), (placed21 4 (2, 6) required_52), (placed21 3 (0, 5) required_388), required_534_i0] +def childrenD_534 : Fin 4 → Finset Cell := ![(placed21 4 (2, 6) envelope_44), (placed21 4 (2, 6) envelope_52), (placed21 3 (0, 5) envelope_388), envelope_534_i0] +theorem common_sub_534 : commonEnvelope childrenD_534 ⊆ insert (2, 5) required_534 := by decide +kernel +theorem child_required_sub_534 : ∀ j, childrenC_534 j ⊆ insert (2, 5) required_534 := by decide +kernel +theorem child_envelope_sub_534 : ∀ j, childrenD_534 j ⊆ envelope_534 := by decide +kernel +theorem pivot_mem_534 : (2, 5) ∈ envelope_534 := by decide +kernel +theorem children_work_534 : ∀ j, Template HasSnaky 7 (childrenC_534 j) (childrenD_534 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 4 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 4 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_388 3 (0, 5)).mono (by decide +kernel) + · exact row_works_534_i0.mono (by decide +kernel) +theorem row_works_534 : Template HasSnaky 8 required_534 envelope_534 := by + refine compose HasSnaky 7 childrenC_534 childrenD_534 children_work_534 (2, 5) + required_534 envelope_534 pivot_mem_534 child_required_sub_534 child_envelope_sub_534 ?_ + intro b hb + exact common_sub_534 (mem_commonEnvelope childrenD_534 b hb) +def required_547_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_547_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_547_i0 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) required_6), (placed21 2 (2, 2) required_17)] +def childrenD_547_i0 : Fin 2 → Finset Cell := ![(placed21 6 (1, 5) envelope_6), (placed21 2 (2, 2) envelope_17)] +theorem common_sub_547_i0 : commonEnvelope childrenD_547_i0 ⊆ insert (1, 5) required_547_i0 := by decide +kernel +theorem child_required_sub_547_i0 : ∀ j, childrenC_547_i0 j ⊆ insert (1, 5) required_547_i0 := by decide +kernel +theorem child_envelope_sub_547_i0 : ∀ j, childrenD_547_i0 j ⊆ envelope_547_i0 := by decide +kernel +theorem pivot_mem_547_i0 : (1, 5) ∈ envelope_547_i0 := by decide +kernel +theorem children_work_547_i0 : ∀ j, Template HasSnaky 4 (childrenC_547_i0 j) (childrenD_547_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 6 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_17 2 (2, 2)).mono (by decide +kernel) +theorem row_works_547_i0 : Template HasSnaky 5 required_547_i0 envelope_547_i0 := by + refine compose HasSnaky 4 childrenC_547_i0 childrenD_547_i0 children_work_547_i0 (1, 5) + required_547_i0 envelope_547_i0 pivot_mem_547_i0 child_required_sub_547_i0 child_envelope_sub_547_i0 ?_ + intro b hb + exact common_sub_547_i0 (mem_commonEnvelope childrenD_547_i0 b hb) +def required_547_i1 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_547_i1 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_547_i1 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), (placed21 3 (0, 4) required_525)] +def childrenD_547_i1 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), (placed21 3 (0, 4) envelope_525)] +theorem common_sub_547_i1 : commonEnvelope childrenD_547_i1 ⊆ insert (2, 4) required_547_i1 := by decide +kernel +theorem child_required_sub_547_i1 : ∀ j, childrenC_547_i1 j ⊆ insert (2, 4) required_547_i1 := by decide +kernel +theorem child_envelope_sub_547_i1 : ∀ j, childrenD_547_i1 j ⊆ envelope_547_i1 := by decide +kernel +theorem pivot_mem_547_i1 : (2, 4) ∈ envelope_547_i1 := by decide +kernel +theorem children_work_547_i1 : ∀ j, Template HasSnaky 6 (childrenC_547_i1 j) (childrenD_547_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_525 3 (0, 4)).mono (by decide +kernel) +theorem row_works_547_i1 : Template HasSnaky 7 required_547_i1 envelope_547_i1 := by + refine compose HasSnaky 6 childrenC_547_i1 childrenD_547_i1 children_work_547_i1 (2, 4) + required_547_i1 envelope_547_i1 pivot_mem_547_i1 child_required_sub_547_i1 child_envelope_sub_547_i1 ?_ + intro b hb + exact common_sub_547_i1 (mem_commonEnvelope childrenD_547_i1 b hb) +def required_547 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_547 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_547 : Fin 4 → Finset Cell := ![required_19, (placed21 5 (2, 1) required_314), required_547_i0, required_547_i1] +def childrenD_547 : Fin 4 → Finset Cell := ![envelope_19, (placed21 5 (2, 1) envelope_314), envelope_547_i0, envelope_547_i1] +theorem common_sub_547 : commonEnvelope childrenD_547 ⊆ insert (1, 4) required_547 := by decide +kernel +theorem child_required_sub_547 : ∀ j, childrenC_547 j ⊆ insert (1, 4) required_547 := by decide +kernel +theorem child_envelope_sub_547 : ∀ j, childrenD_547 j ⊆ envelope_547 := by decide +kernel +theorem pivot_mem_547 : (1, 4) ∈ envelope_547 := by decide +kernel +theorem children_work_547 : ∀ j, Template HasSnaky 7 (childrenC_547 j) (childrenD_547 j) := by + intro j + fin_cases j + · exact row_works_19.mono (by decide +kernel) + · exact (placed21_template row_works_314 5 (2, 1)).mono (by decide +kernel) + · exact row_works_547_i0.mono (by decide +kernel) + · exact row_works_547_i1.mono (by decide +kernel) +theorem row_works_547 : Template HasSnaky 8 required_547 envelope_547 := by + refine compose HasSnaky 7 childrenC_547 childrenD_547 children_work_547 (1, 4) + required_547 envelope_547 pivot_mem_547 child_required_sub_547 child_envelope_sub_547 ?_ + intro b hb + exact common_sub_547 (mem_commonEnvelope childrenD_547 b hb) +def required_558_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_558_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_558_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) required_5), required_471] +def childrenD_558_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 2) envelope_5), envelope_471] +theorem common_sub_558_i0 : commonEnvelope childrenD_558_i0 ⊆ insert (3, 1) required_558_i0 := by decide +kernel +theorem child_required_sub_558_i0 : ∀ j, childrenC_558_i0 j ⊆ insert (3, 1) required_558_i0 := by decide +kernel +theorem child_envelope_sub_558_i0 : ∀ j, childrenD_558_i0 j ⊆ envelope_558_i0 := by decide +kernel +theorem pivot_mem_558_i0 : (3, 1) ∈ envelope_558_i0 := by decide +kernel +theorem children_work_558_i0 : ∀ j, Template HasSnaky 6 (childrenC_558_i0 j) (childrenD_558_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 2)).mono (by decide +kernel) + · exact row_works_471.mono (by decide +kernel) +theorem row_works_558_i0 : Template HasSnaky 7 required_558_i0 envelope_558_i0 := by + refine compose HasSnaky 6 childrenC_558_i0 childrenD_558_i0 children_work_558_i0 (3, 1) + required_558_i0 envelope_558_i0 pivot_mem_558_i0 child_required_sub_558_i0 child_envelope_sub_558_i0 ?_ + intro b hb + exact common_sub_558_i0 (mem_commonEnvelope childrenD_558_i0 b hb) +def required_558 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_558 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_558 : Fin 4 → Finset Cell := ![(placed21 0 (0, 1) required_8), (placed21 1 (0, 2) required_16), (placed21 4 (0, 3) required_24), required_558_i0] +def childrenD_558 : Fin 4 → Finset Cell := ![(placed21 0 (0, 1) envelope_8), (placed21 1 (0, 2) envelope_16), (placed21 4 (0, 3) envelope_24), envelope_558_i0] +theorem common_sub_558 : commonEnvelope childrenD_558 ⊆ insert (3, 2) required_558 := by decide +kernel +theorem child_required_sub_558 : ∀ j, childrenC_558 j ⊆ insert (3, 2) required_558 := by decide +kernel +theorem child_envelope_sub_558 : ∀ j, childrenD_558 j ⊆ envelope_558 := by decide +kernel +theorem pivot_mem_558 : (3, 2) ∈ envelope_558 := by decide +kernel +theorem children_work_558 : ∀ j, Template HasSnaky 7 (childrenC_558 j) (childrenD_558 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_16 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_24 4 (0, 3)).mono (by decide +kernel) + · exact row_works_558_i0.mono (by decide +kernel) +theorem row_works_558 : Template HasSnaky 8 required_558 envelope_558 := by + refine compose HasSnaky 7 childrenC_558 childrenD_558 children_work_558 (3, 2) + required_558 envelope_558 pivot_mem_558 child_required_sub_558 child_envelope_sub_558 ?_ + intro b hb + exact common_sub_558 (mem_commonEnvelope childrenD_558 b hb) +def height_518_i1 : ℕ := 6 +def childrenH_518_i1 : Fin 3 → ℕ := ![height_6, height_213, height_278] +theorem height_exact_518_i1 : height_518_i1 = 1 + Finset.univ.sup childrenH_518_i1 := by decide +kernel +theorem required_origin_518_i1 : ∀ x ∈ required_518_i1, + (∃ j, x ∈ childrenC_518_i1 j) ∨ ∀ j, x ∈ childrenD_518_i1 j := by decide +kernel +theorem required_exact_518_i1 : required_518_i1 = + ((Finset.univ.biUnion childrenC_518_i1) ∪ commonEnvelope childrenD_518_i1).erase (3, 7) := by + exact required_eq_combination childrenC_518_i1 childrenD_518_i1 (3, 7) required_518_i1 + (by decide +kernel) child_required_sub_518_i1 common_sub_518_i1 required_origin_518_i1 +theorem envelope_origin_518_i1 : ∀ x ∈ envelope_518_i1, + x = (3, 7) ∨ ∃ j, x ∈ childrenD_518_i1 j := by decide +kernel +theorem envelope_exact_518_i1 : envelope_518_i1 = + insert (3, 7) (Finset.univ.biUnion childrenD_518_i1) := by + exact envelope_eq_combination childrenD_518_i1 (3, 7) envelope_518_i1 + pivot_mem_518_i1 child_envelope_sub_518_i1 envelope_origin_518_i1 +def checked_518_i1 : CheckedCard where + required := required_518_i1 + envelope := envelope_518_i1 + height := height_518_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_518_i1 +def height_518_i0 : ℕ := 7 +def childrenH_518_i0 : Fin 2 → ℕ := ![height_5, height_518_i1] +theorem height_exact_518_i0 : height_518_i0 = 1 + Finset.univ.sup childrenH_518_i0 := by decide +kernel +theorem required_origin_518_i0 : ∀ x ∈ required_518_i0, + (∃ j, x ∈ childrenC_518_i0 j) ∨ ∀ j, x ∈ childrenD_518_i0 j := by decide +kernel +theorem required_exact_518_i0 : required_518_i0 = + ((Finset.univ.biUnion childrenC_518_i0) ∪ commonEnvelope childrenD_518_i0).erase (3, 6) := by + exact required_eq_combination childrenC_518_i0 childrenD_518_i0 (3, 6) required_518_i0 + (by decide +kernel) child_required_sub_518_i0 common_sub_518_i0 required_origin_518_i0 +theorem envelope_origin_518_i0 : ∀ x ∈ envelope_518_i0, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_518_i0 j := by decide +kernel +theorem envelope_exact_518_i0 : envelope_518_i0 = + insert (3, 6) (Finset.univ.biUnion childrenD_518_i0) := by + exact envelope_eq_combination childrenD_518_i0 (3, 6) envelope_518_i0 + pivot_mem_518_i0 child_envelope_sub_518_i0 envelope_origin_518_i0 +def checked_518_i0 : CheckedCard where + required := required_518_i0 + envelope := envelope_518_i0 + height := height_518_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_518_i0 +def height_518 : ℕ := 8 +def childrenH_518 : Fin 4 → ℕ := ![height_61, height_89, height_183, height_518_i0] +theorem height_exact_518 : height_518 = 1 + Finset.univ.sup childrenH_518 := by decide +kernel +theorem required_origin_518 : ∀ x ∈ required_518, + (∃ j, x ∈ childrenC_518 j) ∨ ∀ j, x ∈ childrenD_518 j := by decide +kernel +theorem required_exact_518 : required_518 = + ((Finset.univ.biUnion childrenC_518) ∪ commonEnvelope childrenD_518).erase (4, 6) := by + exact required_eq_combination childrenC_518 childrenD_518 (4, 6) required_518 + (by decide +kernel) child_required_sub_518 common_sub_518 required_origin_518 +theorem envelope_origin_518 : ∀ x ∈ envelope_518, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_518 j := by decide +kernel +theorem envelope_exact_518 : envelope_518 = + insert (4, 6) (Finset.univ.biUnion childrenD_518) := by + exact envelope_eq_combination childrenD_518 (4, 6) envelope_518 + pivot_mem_518 child_envelope_sub_518 envelope_origin_518 +def checked_518 : CheckedCard where + required := required_518 + envelope := envelope_518 + height := height_518 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_518 +def height_523 : ℕ := 8 +def childrenH_523 : Fin 5 → ℕ := ![height_14, height_122, height_136, height_367, height_522] +theorem height_exact_523 : height_523 = 1 + Finset.univ.sup childrenH_523 := by decide +kernel +theorem required_origin_523 : ∀ x ∈ required_523, + (∃ j, x ∈ childrenC_523 j) ∨ ∀ j, x ∈ childrenD_523 j := by decide +kernel +theorem required_exact_523 : required_523 = + ((Finset.univ.biUnion childrenC_523) ∪ commonEnvelope childrenD_523).erase (3, 5) := by + exact required_eq_combination childrenC_523 childrenD_523 (3, 5) required_523 + (by decide +kernel) child_required_sub_523 common_sub_523 required_origin_523 +theorem envelope_origin_523 : ∀ x ∈ envelope_523, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_523 j := by decide +kernel +theorem envelope_exact_523 : envelope_523 = + insert (3, 5) (Finset.univ.biUnion childrenD_523) := by + exact envelope_eq_combination childrenD_523 (3, 5) envelope_523 + pivot_mem_523 child_envelope_sub_523 envelope_origin_523 +def checked_523 : CheckedCard where + required := required_523 + envelope := envelope_523 + height := height_523 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_523 +def height_524 : ℕ := 8 +def childrenH_524 : Fin 4 → ℕ := ![height_88, height_213, height_254, height_522] +theorem height_exact_524 : height_524 = 1 + Finset.univ.sup childrenH_524 := by decide +kernel +theorem required_origin_524 : ∀ x ∈ required_524, + (∃ j, x ∈ childrenC_524 j) ∨ ∀ j, x ∈ childrenD_524 j := by decide +kernel +theorem required_exact_524 : required_524 = + ((Finset.univ.biUnion childrenC_524) ∪ commonEnvelope childrenD_524).erase (3, 5) := by + exact required_eq_combination childrenC_524 childrenD_524 (3, 5) required_524 + (by decide +kernel) child_required_sub_524 common_sub_524 required_origin_524 +theorem envelope_origin_524 : ∀ x ∈ envelope_524, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_524 j := by decide +kernel +theorem envelope_exact_524 : envelope_524 = + insert (3, 5) (Finset.univ.biUnion childrenD_524) := by + exact envelope_eq_combination childrenD_524 (3, 5) envelope_524 + pivot_mem_524 child_envelope_sub_524 envelope_origin_524 +def checked_524 : CheckedCard where + required := required_524 + envelope := envelope_524 + height := height_524 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_524 +def height_530_i2 : ℕ := 4 +def childrenH_530_i2 : Fin 2 → ℕ := ![height_5, height_20] +theorem height_exact_530_i2 : height_530_i2 = 1 + Finset.univ.sup childrenH_530_i2 := by decide +kernel +theorem required_origin_530_i2 : ∀ x ∈ required_530_i2, + (∃ j, x ∈ childrenC_530_i2 j) ∨ ∀ j, x ∈ childrenD_530_i2 j := by decide +kernel +theorem required_exact_530_i2 : required_530_i2 = + ((Finset.univ.biUnion childrenC_530_i2) ∪ commonEnvelope childrenD_530_i2).erase (2, 5) := by + exact required_eq_combination childrenC_530_i2 childrenD_530_i2 (2, 5) required_530_i2 + (by decide +kernel) child_required_sub_530_i2 common_sub_530_i2 required_origin_530_i2 +theorem envelope_origin_530_i2 : ∀ x ∈ envelope_530_i2, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_530_i2 j := by decide +kernel +theorem envelope_exact_530_i2 : envelope_530_i2 = + insert (2, 5) (Finset.univ.biUnion childrenD_530_i2) := by + exact envelope_eq_combination childrenD_530_i2 (2, 5) envelope_530_i2 + pivot_mem_530_i2 child_envelope_sub_530_i2 envelope_origin_530_i2 +def checked_530_i2 : CheckedCard where + required := required_530_i2 + envelope := envelope_530_i2 + height := height_530_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_530_i2 +def height_530_i1 : ℕ := 5 +def childrenH_530_i1 : Fin 2 → ℕ := ![height_51, height_530_i2] +theorem height_exact_530_i1 : height_530_i1 = 1 + Finset.univ.sup childrenH_530_i1 := by decide +kernel +theorem required_origin_530_i1 : ∀ x ∈ required_530_i1, + (∃ j, x ∈ childrenC_530_i1 j) ∨ ∀ j, x ∈ childrenD_530_i1 j := by decide +kernel +theorem required_exact_530_i1 : required_530_i1 = + ((Finset.univ.biUnion childrenC_530_i1) ∪ commonEnvelope childrenD_530_i1).erase (3, 2) := by + exact required_eq_combination childrenC_530_i1 childrenD_530_i1 (3, 2) required_530_i1 + (by decide +kernel) child_required_sub_530_i1 common_sub_530_i1 required_origin_530_i1 +theorem envelope_origin_530_i1 : ∀ x ∈ envelope_530_i1, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_530_i1 j := by decide +kernel +theorem envelope_exact_530_i1 : envelope_530_i1 = + insert (3, 2) (Finset.univ.biUnion childrenD_530_i1) := by + exact envelope_eq_combination childrenD_530_i1 (3, 2) envelope_530_i1 + pivot_mem_530_i1 child_envelope_sub_530_i1 envelope_origin_530_i1 +def checked_530_i1 : CheckedCard where + required := required_530_i1 + envelope := envelope_530_i1 + height := height_530_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_530_i1 +def height_530_i0 : ℕ := 6 +def childrenH_530_i0 : Fin 2 → ℕ := ![height_23, height_530_i1] +theorem height_exact_530_i0 : height_530_i0 = 1 + Finset.univ.sup childrenH_530_i0 := by decide +kernel +theorem required_origin_530_i0 : ∀ x ∈ required_530_i0, + (∃ j, x ∈ childrenC_530_i0 j) ∨ ∀ j, x ∈ childrenD_530_i0 j := by decide +kernel +theorem required_exact_530_i0 : required_530_i0 = + ((Finset.univ.biUnion childrenC_530_i0) ∪ commonEnvelope childrenD_530_i0).erase (2, 2) := by + exact required_eq_combination childrenC_530_i0 childrenD_530_i0 (2, 2) required_530_i0 + (by decide +kernel) child_required_sub_530_i0 common_sub_530_i0 required_origin_530_i0 +theorem envelope_origin_530_i0 : ∀ x ∈ envelope_530_i0, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_530_i0 j := by decide +kernel +theorem envelope_exact_530_i0 : envelope_530_i0 = + insert (2, 2) (Finset.univ.biUnion childrenD_530_i0) := by + exact envelope_eq_combination childrenD_530_i0 (2, 2) envelope_530_i0 + pivot_mem_530_i0 child_envelope_sub_530_i0 envelope_origin_530_i0 +def checked_530_i0 : CheckedCard where + required := required_530_i0 + envelope := envelope_530_i0 + height := height_530_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_530_i0 +def height_530 : ℕ := 8 +def childrenH_530 : Fin 4 → ℕ := ![height_72, height_360, height_499, height_530_i0] +theorem height_exact_530 : height_530 = 1 + Finset.univ.sup childrenH_530 := by decide +kernel +theorem required_origin_530 : ∀ x ∈ required_530, + (∃ j, x ∈ childrenC_530 j) ∨ ∀ j, x ∈ childrenD_530 j := by decide +kernel +theorem required_exact_530 : required_530 = + ((Finset.univ.biUnion childrenC_530) ∪ commonEnvelope childrenD_530).erase (2, 4) := by + exact required_eq_combination childrenC_530 childrenD_530 (2, 4) required_530 + (by decide +kernel) child_required_sub_530 common_sub_530 required_origin_530 +theorem envelope_origin_530 : ∀ x ∈ envelope_530, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_530 j := by decide +kernel +theorem envelope_exact_530 : envelope_530 = + insert (2, 4) (Finset.univ.biUnion childrenD_530) := by + exact envelope_eq_combination childrenD_530 (2, 4) envelope_530 + pivot_mem_530 child_envelope_sub_530 envelope_origin_530 +def checked_530 : CheckedCard where + required := required_530 + envelope := envelope_530 + height := height_530 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_530 +def height_532_i0 : ℕ := 7 +def childrenH_532_i0 : Fin 4 → ℕ := ![height_19, height_84, height_314, height_521] +theorem height_exact_532_i0 : height_532_i0 = 1 + Finset.univ.sup childrenH_532_i0 := by decide +kernel +theorem required_origin_532_i0 : ∀ x ∈ required_532_i0, + (∃ j, x ∈ childrenC_532_i0 j) ∨ ∀ j, x ∈ childrenD_532_i0 j := by decide +kernel +theorem required_exact_532_i0 : required_532_i0 = + ((Finset.univ.biUnion childrenC_532_i0) ∪ commonEnvelope childrenD_532_i0).erase (2, 6) := by + exact required_eq_combination childrenC_532_i0 childrenD_532_i0 (2, 6) required_532_i0 + (by decide +kernel) child_required_sub_532_i0 common_sub_532_i0 required_origin_532_i0 +theorem envelope_origin_532_i0 : ∀ x ∈ envelope_532_i0, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_532_i0 j := by decide +kernel +theorem envelope_exact_532_i0 : envelope_532_i0 = + insert (2, 6) (Finset.univ.biUnion childrenD_532_i0) := by + exact envelope_eq_combination childrenD_532_i0 (2, 6) envelope_532_i0 + pivot_mem_532_i0 child_envelope_sub_532_i0 envelope_origin_532_i0 +def checked_532_i0 : CheckedCard where + required := required_532_i0 + envelope := envelope_532_i0 + height := height_532_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_532_i0 +def height_532 : ℕ := 8 +def childrenH_532 : Fin 4 → ℕ := ![height_44, height_52, height_134, height_532_i0] +theorem height_exact_532 : height_532 = 1 + Finset.univ.sup childrenH_532 := by decide +kernel +theorem required_origin_532 : ∀ x ∈ required_532, + (∃ j, x ∈ childrenC_532 j) ∨ ∀ j, x ∈ childrenD_532 j := by decide +kernel +theorem required_exact_532 : required_532 = + ((Finset.univ.biUnion childrenC_532) ∪ commonEnvelope childrenD_532).erase (2, 3) := by + exact required_eq_combination childrenC_532 childrenD_532 (2, 3) required_532 + (by decide +kernel) child_required_sub_532 common_sub_532 required_origin_532 +theorem envelope_origin_532 : ∀ x ∈ envelope_532, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_532 j := by decide +kernel +theorem envelope_exact_532 : envelope_532 = + insert (2, 3) (Finset.univ.biUnion childrenD_532) := by + exact envelope_eq_combination childrenD_532 (2, 3) envelope_532 + pivot_mem_532 child_envelope_sub_532 envelope_origin_532 +def checked_532 : CheckedCard where + required := required_532 + envelope := envelope_532 + height := height_532 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_532 +def height_533_i0 : ℕ := 7 +def childrenH_533_i0 : Fin 3 → ℕ := ![height_53, height_55, height_392] +theorem height_exact_533_i0 : height_533_i0 = 1 + Finset.univ.sup childrenH_533_i0 := by decide +kernel +theorem required_origin_533_i0 : ∀ x ∈ required_533_i0, + (∃ j, x ∈ childrenC_533_i0 j) ∨ ∀ j, x ∈ childrenD_533_i0 j := by decide +kernel +theorem required_exact_533_i0 : required_533_i0 = + ((Finset.univ.biUnion childrenC_533_i0) ∪ commonEnvelope childrenD_533_i0).erase (3, 4) := by + exact required_eq_combination childrenC_533_i0 childrenD_533_i0 (3, 4) required_533_i0 + (by decide +kernel) child_required_sub_533_i0 common_sub_533_i0 required_origin_533_i0 +theorem envelope_origin_533_i0 : ∀ x ∈ envelope_533_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_533_i0 j := by decide +kernel +theorem envelope_exact_533_i0 : envelope_533_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_533_i0) := by + exact envelope_eq_combination childrenD_533_i0 (3, 4) envelope_533_i0 + pivot_mem_533_i0 child_envelope_sub_533_i0 envelope_origin_533_i0 +def checked_533_i0 : CheckedCard where + required := required_533_i0 + envelope := envelope_533_i0 + height := height_533_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_533_i0 +def height_533 : ℕ := 8 +def childrenH_533 : Fin 3 → ℕ := ![height_11, height_279, height_533_i0] +theorem height_exact_533 : height_533 = 1 + Finset.univ.sup childrenH_533 := by decide +kernel +theorem required_origin_533 : ∀ x ∈ required_533, + (∃ j, x ∈ childrenC_533 j) ∨ ∀ j, x ∈ childrenD_533 j := by decide +kernel +theorem required_exact_533 : required_533 = + ((Finset.univ.biUnion childrenC_533) ∪ commonEnvelope childrenD_533).erase (4, 3) := by + exact required_eq_combination childrenC_533 childrenD_533 (4, 3) required_533 + (by decide +kernel) child_required_sub_533 common_sub_533 required_origin_533 +theorem envelope_origin_533 : ∀ x ∈ envelope_533, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_533 j := by decide +kernel +theorem envelope_exact_533 : envelope_533 = + insert (4, 3) (Finset.univ.biUnion childrenD_533) := by + exact envelope_eq_combination childrenD_533 (4, 3) envelope_533 + pivot_mem_533 child_envelope_sub_533 envelope_origin_533 +def checked_533 : CheckedCard where + required := required_533 + envelope := envelope_533 + height := height_533 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_533 +def height_534_i1 : ℕ := 4 +def childrenH_534_i1 : Fin 2 → ℕ := ![height_5, height_177] +theorem height_exact_534_i1 : height_534_i1 = 1 + Finset.univ.sup childrenH_534_i1 := by decide +kernel +theorem required_origin_534_i1 : ∀ x ∈ required_534_i1, + (∃ j, x ∈ childrenC_534_i1 j) ∨ ∀ j, x ∈ childrenD_534_i1 j := by decide +kernel +theorem required_exact_534_i1 : required_534_i1 = + ((Finset.univ.biUnion childrenC_534_i1) ∪ commonEnvelope childrenD_534_i1).erase (2, 6) := by + exact required_eq_combination childrenC_534_i1 childrenD_534_i1 (2, 6) required_534_i1 + (by decide +kernel) child_required_sub_534_i1 common_sub_534_i1 required_origin_534_i1 +theorem envelope_origin_534_i1 : ∀ x ∈ envelope_534_i1, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_534_i1 j := by decide +kernel +theorem envelope_exact_534_i1 : envelope_534_i1 = + insert (2, 6) (Finset.univ.biUnion childrenD_534_i1) := by + exact envelope_eq_combination childrenD_534_i1 (2, 6) envelope_534_i1 + pivot_mem_534_i1 child_envelope_sub_534_i1 envelope_origin_534_i1 +def checked_534_i1 : CheckedCard where + required := required_534_i1 + envelope := envelope_534_i1 + height := height_534_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_534_i1 +def height_534_i2 : ℕ := 4 +def childrenH_534_i2 : Fin 2 → ℕ := ![height_0, height_239] +theorem height_exact_534_i2 : height_534_i2 = 1 + Finset.univ.sup childrenH_534_i2 := by decide +kernel +theorem required_origin_534_i2 : ∀ x ∈ required_534_i2, + (∃ j, x ∈ childrenC_534_i2 j) ∨ ∀ j, x ∈ childrenD_534_i2 j := by decide +kernel +theorem required_exact_534_i2 : required_534_i2 = + ((Finset.univ.biUnion childrenC_534_i2) ∪ commonEnvelope childrenD_534_i2).erase (3, 5) := by + exact required_eq_combination childrenC_534_i2 childrenD_534_i2 (3, 5) required_534_i2 + (by decide +kernel) child_required_sub_534_i2 common_sub_534_i2 required_origin_534_i2 +theorem envelope_origin_534_i2 : ∀ x ∈ envelope_534_i2, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_534_i2 j := by decide +kernel +theorem envelope_exact_534_i2 : envelope_534_i2 = + insert (3, 5) (Finset.univ.biUnion childrenD_534_i2) := by + exact envelope_eq_combination childrenD_534_i2 (3, 5) envelope_534_i2 + pivot_mem_534_i2 child_envelope_sub_534_i2 envelope_origin_534_i2 +def checked_534_i2 : CheckedCard where + required := required_534_i2 + envelope := envelope_534_i2 + height := height_534_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_534_i2 +def height_534_i0 : ℕ := 5 +def childrenH_534_i0 : Fin 3 → ℕ := ![height_139, height_534_i1, height_534_i2] +theorem height_exact_534_i0 : height_534_i0 = 1 + Finset.univ.sup childrenH_534_i0 := by decide +kernel +theorem required_origin_534_i0 : ∀ x ∈ required_534_i0, + (∃ j, x ∈ childrenC_534_i0 j) ∨ ∀ j, x ∈ childrenD_534_i0 j := by decide +kernel +theorem required_exact_534_i0 : required_534_i0 = + ((Finset.univ.biUnion childrenC_534_i0) ∪ commonEnvelope childrenD_534_i0).erase (3, 6) := by + exact required_eq_combination childrenC_534_i0 childrenD_534_i0 (3, 6) required_534_i0 + (by decide +kernel) child_required_sub_534_i0 common_sub_534_i0 required_origin_534_i0 +theorem envelope_origin_534_i0 : ∀ x ∈ envelope_534_i0, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_534_i0 j := by decide +kernel +theorem envelope_exact_534_i0 : envelope_534_i0 = + insert (3, 6) (Finset.univ.biUnion childrenD_534_i0) := by + exact envelope_eq_combination childrenD_534_i0 (3, 6) envelope_534_i0 + pivot_mem_534_i0 child_envelope_sub_534_i0 envelope_origin_534_i0 +def checked_534_i0 : CheckedCard where + required := required_534_i0 + envelope := envelope_534_i0 + height := height_534_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_534_i0 +def height_534 : ℕ := 8 +def childrenH_534 : Fin 4 → ℕ := ![height_44, height_52, height_388, height_534_i0] +theorem height_exact_534 : height_534 = 1 + Finset.univ.sup childrenH_534 := by decide +kernel +theorem required_origin_534 : ∀ x ∈ required_534, + (∃ j, x ∈ childrenC_534 j) ∨ ∀ j, x ∈ childrenD_534 j := by decide +kernel +theorem required_exact_534 : required_534 = + ((Finset.univ.biUnion childrenC_534) ∪ commonEnvelope childrenD_534).erase (2, 5) := by + exact required_eq_combination childrenC_534 childrenD_534 (2, 5) required_534 + (by decide +kernel) child_required_sub_534 common_sub_534 required_origin_534 +theorem envelope_origin_534 : ∀ x ∈ envelope_534, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_534 j := by decide +kernel +theorem envelope_exact_534 : envelope_534 = + insert (2, 5) (Finset.univ.biUnion childrenD_534) := by + exact envelope_eq_combination childrenD_534 (2, 5) envelope_534 + pivot_mem_534 child_envelope_sub_534 envelope_origin_534 +def checked_534 : CheckedCard where + required := required_534 + envelope := envelope_534 + height := height_534 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_534 +def height_547_i0 : ℕ := 5 +def childrenH_547_i0 : Fin 2 → ℕ := ![height_6, height_17] +theorem height_exact_547_i0 : height_547_i0 = 1 + Finset.univ.sup childrenH_547_i0 := by decide +kernel +theorem required_origin_547_i0 : ∀ x ∈ required_547_i0, + (∃ j, x ∈ childrenC_547_i0 j) ∨ ∀ j, x ∈ childrenD_547_i0 j := by decide +kernel +theorem required_exact_547_i0 : required_547_i0 = + ((Finset.univ.biUnion childrenC_547_i0) ∪ commonEnvelope childrenD_547_i0).erase (1, 5) := by + exact required_eq_combination childrenC_547_i0 childrenD_547_i0 (1, 5) required_547_i0 + (by decide +kernel) child_required_sub_547_i0 common_sub_547_i0 required_origin_547_i0 +theorem envelope_origin_547_i0 : ∀ x ∈ envelope_547_i0, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_547_i0 j := by decide +kernel +theorem envelope_exact_547_i0 : envelope_547_i0 = + insert (1, 5) (Finset.univ.biUnion childrenD_547_i0) := by + exact envelope_eq_combination childrenD_547_i0 (1, 5) envelope_547_i0 + pivot_mem_547_i0 child_envelope_sub_547_i0 envelope_origin_547_i0 +def checked_547_i0 : CheckedCard where + required := required_547_i0 + envelope := envelope_547_i0 + height := height_547_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_547_i0 +def height_547_i1 : ℕ := 7 +def childrenH_547_i1 : Fin 2 → ℕ := ![height_5, height_525] +theorem height_exact_547_i1 : height_547_i1 = 1 + Finset.univ.sup childrenH_547_i1 := by decide +kernel +theorem required_origin_547_i1 : ∀ x ∈ required_547_i1, + (∃ j, x ∈ childrenC_547_i1 j) ∨ ∀ j, x ∈ childrenD_547_i1 j := by decide +kernel +theorem required_exact_547_i1 : required_547_i1 = + ((Finset.univ.biUnion childrenC_547_i1) ∪ commonEnvelope childrenD_547_i1).erase (2, 4) := by + exact required_eq_combination childrenC_547_i1 childrenD_547_i1 (2, 4) required_547_i1 + (by decide +kernel) child_required_sub_547_i1 common_sub_547_i1 required_origin_547_i1 +theorem envelope_origin_547_i1 : ∀ x ∈ envelope_547_i1, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_547_i1 j := by decide +kernel +theorem envelope_exact_547_i1 : envelope_547_i1 = + insert (2, 4) (Finset.univ.biUnion childrenD_547_i1) := by + exact envelope_eq_combination childrenD_547_i1 (2, 4) envelope_547_i1 + pivot_mem_547_i1 child_envelope_sub_547_i1 envelope_origin_547_i1 +def checked_547_i1 : CheckedCard where + required := required_547_i1 + envelope := envelope_547_i1 + height := height_547_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_547_i1 +def height_547 : ℕ := 8 +def childrenH_547 : Fin 4 → ℕ := ![height_19, height_314, height_547_i0, height_547_i1] +theorem height_exact_547 : height_547 = 1 + Finset.univ.sup childrenH_547 := by decide +kernel +theorem required_origin_547 : ∀ x ∈ required_547, + (∃ j, x ∈ childrenC_547 j) ∨ ∀ j, x ∈ childrenD_547 j := by decide +kernel +theorem required_exact_547 : required_547 = + ((Finset.univ.biUnion childrenC_547) ∪ commonEnvelope childrenD_547).erase (1, 4) := by + exact required_eq_combination childrenC_547 childrenD_547 (1, 4) required_547 + (by decide +kernel) child_required_sub_547 common_sub_547 required_origin_547 +theorem envelope_origin_547 : ∀ x ∈ envelope_547, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_547 j := by decide +kernel +theorem envelope_exact_547 : envelope_547 = + insert (1, 4) (Finset.univ.biUnion childrenD_547) := by + exact envelope_eq_combination childrenD_547 (1, 4) envelope_547 + pivot_mem_547 child_envelope_sub_547 envelope_origin_547 +def checked_547 : CheckedCard where + required := required_547 + envelope := envelope_547 + height := height_547 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_547 +def height_558_i0 : ℕ := 7 +def childrenH_558_i0 : Fin 2 → ℕ := ![height_5, height_471] +theorem height_exact_558_i0 : height_558_i0 = 1 + Finset.univ.sup childrenH_558_i0 := by decide +kernel +theorem required_origin_558_i0 : ∀ x ∈ required_558_i0, + (∃ j, x ∈ childrenC_558_i0 j) ∨ ∀ j, x ∈ childrenD_558_i0 j := by decide +kernel +theorem required_exact_558_i0 : required_558_i0 = + ((Finset.univ.biUnion childrenC_558_i0) ∪ commonEnvelope childrenD_558_i0).erase (3, 1) := by + exact required_eq_combination childrenC_558_i0 childrenD_558_i0 (3, 1) required_558_i0 + (by decide +kernel) child_required_sub_558_i0 common_sub_558_i0 required_origin_558_i0 +theorem envelope_origin_558_i0 : ∀ x ∈ envelope_558_i0, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_558_i0 j := by decide +kernel +theorem envelope_exact_558_i0 : envelope_558_i0 = + insert (3, 1) (Finset.univ.biUnion childrenD_558_i0) := by + exact envelope_eq_combination childrenD_558_i0 (3, 1) envelope_558_i0 + pivot_mem_558_i0 child_envelope_sub_558_i0 envelope_origin_558_i0 +def checked_558_i0 : CheckedCard where + required := required_558_i0 + envelope := envelope_558_i0 + height := height_558_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_558_i0 +def height_558 : ℕ := 8 +def childrenH_558 : Fin 4 → ℕ := ![height_8, height_16, height_24, height_558_i0] +theorem height_exact_558 : height_558 = 1 + Finset.univ.sup childrenH_558 := by decide +kernel +theorem required_origin_558 : ∀ x ∈ required_558, + (∃ j, x ∈ childrenC_558 j) ∨ ∀ j, x ∈ childrenD_558 j := by decide +kernel +theorem required_exact_558 : required_558 = + ((Finset.univ.biUnion childrenC_558) ∪ commonEnvelope childrenD_558).erase (3, 2) := by + exact required_eq_combination childrenC_558 childrenD_558 (3, 2) required_558 + (by decide +kernel) child_required_sub_558 common_sub_558 required_origin_558 +theorem envelope_origin_558 : ∀ x ∈ envelope_558, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_558 j := by decide +kernel +theorem envelope_exact_558 : envelope_558 = + insert (3, 2) (Finset.univ.biUnion childrenD_558) := by + exact envelope_eq_combination childrenD_558 (3, 2) envelope_558 + pivot_mem_558 child_envelope_sub_558 envelope_origin_558 +def checked_558 : CheckedCard where + required := required_558 + envelope := envelope_558 + height := height_558 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_558 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part04.lean new file mode 100644 index 0000000..5fe43b2 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part04.lean @@ -0,0 +1,986 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_559_i0 : Finset Cell := ⟨(([(3, 1), (3, 2), (3, 3), (4, 1), (5, 1), (6, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_559_i0 : Finset Cell := ⟨(([(3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (5, 0), (5, 1), (6, 1), (6, 2), (7, 0), (7, 1), (7, 2), (8, 0), (8, 1), (8, 2), (9, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_559_i0 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) required_0), (placed21 1 (3, 0) required_17)] +def childrenD_559_i0 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) envelope_0), (placed21 1 (3, 0) envelope_17)] +theorem common_sub_559_i0 : commonEnvelope childrenD_559_i0 ⊆ insert (4, 0) required_559_i0 := by decide +kernel +theorem child_required_sub_559_i0 : ∀ j, childrenC_559_i0 j ⊆ insert (4, 0) required_559_i0 := by decide +kernel +theorem child_envelope_sub_559_i0 : ∀ j, childrenD_559_i0 j ⊆ envelope_559_i0 := by decide +kernel +theorem pivot_mem_559_i0 : (4, 0) ∈ envelope_559_i0 := by decide +kernel +theorem children_work_559_i0 : ∀ j, Template HasSnaky 4 (childrenC_559_i0 j) (childrenD_559_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_17 1 (3, 0)).mono (by decide +kernel) +theorem row_works_559_i0 : Template HasSnaky 5 required_559_i0 envelope_559_i0 := by + refine compose HasSnaky 4 childrenC_559_i0 childrenD_559_i0 children_work_559_i0 (4, 0) + required_559_i0 envelope_559_i0 pivot_mem_559_i0 child_required_sub_559_i0 child_envelope_sub_559_i0 ?_ + intro b hb + exact common_sub_559_i0 (mem_commonEnvelope childrenD_559_i0 b hb) +def required_559_i6 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 3), (3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_559_i6 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 3), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_559_i6 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_0), (placed21 0 (0, 3) required_0)] +def childrenD_559_i6 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_0), (placed21 0 (0, 3) envelope_0)] +theorem common_sub_559_i6 : commonEnvelope childrenD_559_i6 ⊆ insert (1, 3) required_559_i6 := by decide +kernel +theorem child_required_sub_559_i6 : ∀ j, childrenC_559_i6 j ⊆ insert (1, 3) required_559_i6 := by decide +kernel +theorem child_envelope_sub_559_i6 : ∀ j, childrenD_559_i6 j ⊆ envelope_559_i6 := by decide +kernel +theorem pivot_mem_559_i6 : (1, 3) ∈ envelope_559_i6 := by decide +kernel +theorem children_work_559_i6 : ∀ j, Template HasSnaky 1 (childrenC_559_i6 j) (childrenD_559_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_0 0 (0, 3)).mono (by decide +kernel) +theorem row_works_559_i6 : Template HasSnaky 2 required_559_i6 envelope_559_i6 := by + refine compose HasSnaky 1 childrenC_559_i6 childrenD_559_i6 children_work_559_i6 (1, 3) + required_559_i6 envelope_559_i6 pivot_mem_559_i6 child_required_sub_559_i6 child_envelope_sub_559_i6 ?_ + intro b hb + exact common_sub_559_i6 (mem_commonEnvelope childrenD_559_i6 b hb) +def required_559_i5 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 3), (3, 4), (4, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_559_i5 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 3), (3, 3), (3, 4), (4, 3), (4, 4), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_559_i5 : Fin 2 → Finset Cell := ![(placed21 6 (6, 4) required_1), required_559_i6] +def childrenD_559_i5 : Fin 2 → Finset Cell := ![(placed21 6 (6, 4) envelope_1), envelope_559_i6] +theorem common_sub_559_i5 : commonEnvelope childrenD_559_i5 ⊆ insert (2, 3) required_559_i5 := by decide +kernel +theorem child_required_sub_559_i5 : ∀ j, childrenC_559_i5 j ⊆ insert (2, 3) required_559_i5 := by decide +kernel +theorem child_envelope_sub_559_i5 : ∀ j, childrenD_559_i5 j ⊆ envelope_559_i5 := by decide +kernel +theorem pivot_mem_559_i5 : (2, 3) ∈ envelope_559_i5 := by decide +kernel +theorem children_work_559_i5 : ∀ j, Template HasSnaky 2 (childrenC_559_i5 j) (childrenD_559_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 6 (6, 4)).mono (by decide +kernel) + · exact row_works_559_i6.mono (by decide +kernel) +theorem row_works_559_i5 : Template HasSnaky 3 required_559_i5 envelope_559_i5 := by + refine compose HasSnaky 2 childrenC_559_i5 childrenD_559_i5 children_work_559_i5 (2, 3) + required_559_i5 envelope_559_i5 pivot_mem_559_i5 child_required_sub_559_i5 child_envelope_sub_559_i5 ?_ + intro b hb + exact common_sub_559_i5 (mem_commonEnvelope childrenD_559_i5 b hb) +def required_559_i4 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3), (3, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_559_i4 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_559_i4 : Fin 2 → Finset Cell := ![(placed21 1 (3, 1) required_5), required_559_i5] +def childrenD_559_i4 : Fin 2 → Finset Cell := ![(placed21 1 (3, 1) envelope_5), envelope_559_i5] +theorem common_sub_559_i4 : commonEnvelope childrenD_559_i4 ⊆ insert (4, 4) required_559_i4 := by decide +kernel +theorem child_required_sub_559_i4 : ∀ j, childrenC_559_i4 j ⊆ insert (4, 4) required_559_i4 := by decide +kernel +theorem child_envelope_sub_559_i4 : ∀ j, childrenD_559_i4 j ⊆ envelope_559_i4 := by decide +kernel +theorem pivot_mem_559_i4 : (4, 4) ∈ envelope_559_i4 := by decide +kernel +theorem children_work_559_i4 : ∀ j, Template HasSnaky 3 (childrenC_559_i4 j) (childrenD_559_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 1)).mono (by decide +kernel) + · exact row_works_559_i5.mono (by decide +kernel) +theorem row_works_559_i4 : Template HasSnaky 4 required_559_i4 envelope_559_i4 := by + refine compose HasSnaky 3 childrenC_559_i4 childrenD_559_i4 children_work_559_i4 (4, 4) + required_559_i4 envelope_559_i4 pivot_mem_559_i4 child_required_sub_559_i4 child_envelope_sub_559_i4 ?_ + intro b hb + exact common_sub_559_i4 (mem_commonEnvelope childrenD_559_i4 b hb) +def required_559_i3 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (5, 0), (5, 1), (6, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_559_i3 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 4), (6, 1), (6, 2), (6, 3), (6, 4), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_559_i3 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) required_35), required_559_i4] +def childrenD_559_i3 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) envelope_35), envelope_559_i4] +theorem common_sub_559_i3 : commonEnvelope childrenD_559_i3 ⊆ insert (6, 4) required_559_i3 := by decide +kernel +theorem child_required_sub_559_i3 : ∀ j, childrenC_559_i3 j ⊆ insert (6, 4) required_559_i3 := by decide +kernel +theorem child_envelope_sub_559_i3 : ∀ j, childrenD_559_i3 j ⊆ envelope_559_i3 := by decide +kernel +theorem pivot_mem_559_i3 : (6, 4) ∈ envelope_559_i3 := by decide +kernel +theorem children_work_559_i3 : ∀ j, Template HasSnaky 4 (childrenC_559_i3 j) (childrenD_559_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_35 0 (3, 0)).mono (by decide +kernel) + · exact row_works_559_i4.mono (by decide +kernel) +theorem row_works_559_i3 : Template HasSnaky 5 required_559_i3 envelope_559_i3 := by + refine compose HasSnaky 4 childrenC_559_i3 childrenD_559_i3 children_work_559_i3 (6, 4) + required_559_i3 envelope_559_i3 pivot_mem_559_i3 child_required_sub_559_i3 child_envelope_sub_559_i3 ?_ + intro b hb + exact common_sub_559_i3 (mem_commonEnvelope childrenD_559_i3 b hb) +def required_559_i2 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (5, 1), (6, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_559_i2 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 4), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_559_i2 : Fin 2 → Finset Cell := ![(placed21 5 (6, 0) required_244), required_559_i3] +def childrenD_559_i2 : Fin 2 → Finset Cell := ![(placed21 5 (6, 0) envelope_244), envelope_559_i3] +theorem common_sub_559_i2 : commonEnvelope childrenD_559_i2 ⊆ insert (5, 0) required_559_i2 := by decide +kernel +theorem child_required_sub_559_i2 : ∀ j, childrenC_559_i2 j ⊆ insert (5, 0) required_559_i2 := by decide +kernel +theorem child_envelope_sub_559_i2 : ∀ j, childrenD_559_i2 j ⊆ envelope_559_i2 := by decide +kernel +theorem pivot_mem_559_i2 : (5, 0) ∈ envelope_559_i2 := by decide +kernel +theorem children_work_559_i2 : ∀ j, Template HasSnaky 5 (childrenC_559_i2 j) (childrenD_559_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_244 5 (6, 0)).mono (by decide +kernel) + · exact row_works_559_i3.mono (by decide +kernel) +theorem row_works_559_i2 : Template HasSnaky 6 required_559_i2 envelope_559_i2 := by + refine compose HasSnaky 5 childrenC_559_i2 childrenD_559_i2 children_work_559_i2 (5, 0) + required_559_i2 envelope_559_i2 pivot_mem_559_i2 child_required_sub_559_i2 child_envelope_sub_559_i2 ?_ + intro b hb + exact common_sub_559_i2 (mem_commonEnvelope childrenD_559_i2 b hb) +def required_559_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3), (4, 1), (5, 1), (6, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_559_i1 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 4), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_559_i1 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) required_5), required_559_i2] +def childrenD_559_i1 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) envelope_5), envelope_559_i2] +theorem common_sub_559_i1 : commonEnvelope childrenD_559_i1 ⊆ insert (3, 4) required_559_i1 := by decide +kernel +theorem child_required_sub_559_i1 : ∀ j, childrenC_559_i1 j ⊆ insert (3, 4) required_559_i1 := by decide +kernel +theorem child_envelope_sub_559_i1 : ∀ j, childrenD_559_i1 j ⊆ envelope_559_i1 := by decide +kernel +theorem pivot_mem_559_i1 : (3, 4) ∈ envelope_559_i1 := by decide +kernel +theorem children_work_559_i1 : ∀ j, Template HasSnaky 6 (childrenC_559_i1 j) (childrenD_559_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (3, 4)).mono (by decide +kernel) + · exact row_works_559_i2.mono (by decide +kernel) +theorem row_works_559_i1 : Template HasSnaky 7 required_559_i1 envelope_559_i1 := by + refine compose HasSnaky 6 childrenC_559_i1 childrenD_559_i1 children_work_559_i1 (3, 4) + required_559_i1 envelope_559_i1 pivot_mem_559_i1 child_required_sub_559_i1 child_envelope_sub_559_i1 ?_ + intro b hb + exact common_sub_559_i1 (mem_commonEnvelope childrenD_559_i1 b hb) +def required_559 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2), (3, 3), (4, 1), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_559 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 2), (1, 3), (2, 0), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 4), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (7, 0), (7, 1), (7, 2), (8, 0), (8, 1), (8, 2), (9, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_559 : Fin 4 → Finset Cell := ![(placed21 4 (3, 2) required_8), (placed21 5 (7, 0) required_236), required_559_i0, required_559_i1] +def childrenD_559 : Fin 4 → Finset Cell := ![(placed21 4 (3, 2) envelope_8), (placed21 5 (7, 0) envelope_236), envelope_559_i0, envelope_559_i1] +theorem common_sub_559 : commonEnvelope childrenD_559 ⊆ insert (6, 1) required_559 := by decide +kernel +theorem child_required_sub_559 : ∀ j, childrenC_559 j ⊆ insert (6, 1) required_559 := by decide +kernel +theorem child_envelope_sub_559 : ∀ j, childrenD_559 j ⊆ envelope_559 := by decide +kernel +theorem pivot_mem_559 : (6, 1) ∈ envelope_559 := by decide +kernel +theorem children_work_559 : ∀ j, Template HasSnaky 7 (childrenC_559 j) (childrenD_559 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 4 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_236 5 (7, 0)).mono (by decide +kernel) + · exact row_works_559_i0.mono (by decide +kernel) + · exact row_works_559_i1.mono (by decide +kernel) +theorem row_works_559 : Template HasSnaky 8 required_559 envelope_559 := by + refine compose HasSnaky 7 childrenC_559 childrenD_559 children_work_559 (6, 1) + required_559 envelope_559 pivot_mem_559 child_required_sub_559 child_envelope_sub_559 ?_ + intro b hb + exact common_sub_559 (mem_commonEnvelope childrenD_559 b hb) +def required_566 : Finset Cell := ⟨(([(3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_566 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_566 : Fin 6 → Finset Cell := ![(placed21 1 (0, 2) required_116), (placed21 3 (0, 6) required_116), (placed21 1 (0, 2) required_172), (placed21 3 (0, 6) required_172), (placed21 0 (1, 1) required_182), (placed21 5 (6, 1) required_565)] +def childrenD_566 : Fin 6 → Finset Cell := ![(placed21 1 (0, 2) envelope_116), (placed21 3 (0, 6) envelope_116), (placed21 1 (0, 2) envelope_172), (placed21 3 (0, 6) envelope_172), (placed21 0 (1, 1) envelope_182), (placed21 5 (6, 1) envelope_565)] +theorem common_sub_566 : commonEnvelope childrenD_566 ⊆ insert (3, 5) required_566 := by decide +kernel +theorem child_required_sub_566 : ∀ j, childrenC_566 j ⊆ insert (3, 5) required_566 := by decide +kernel +theorem child_envelope_sub_566 : ∀ j, childrenD_566 j ⊆ envelope_566 := by decide +kernel +theorem pivot_mem_566 : (3, 5) ∈ envelope_566 := by decide +kernel +theorem children_work_566 : ∀ j, Template HasSnaky 7 (childrenC_566 j) (childrenD_566 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_116 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_116 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_172 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_172 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_182 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_565 5 (6, 1)).mono (by decide +kernel) +theorem row_works_566 : Template HasSnaky 8 required_566 envelope_566 := by + refine compose HasSnaky 7 childrenC_566 childrenD_566 children_work_566 (3, 5) + required_566 envelope_566 pivot_mem_566 child_required_sub_566 child_envelope_sub_566 ?_ + intro b hb + exact common_sub_566 (mem_commonEnvelope childrenD_566 b hb) +def required_604_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_604_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_604_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_5), (placed21 0 (1, 0) required_267)] +def childrenD_604_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_5), (placed21 0 (1, 0) envelope_267)] +theorem common_sub_604_i0 : commonEnvelope childrenD_604_i0 ⊆ insert (3, 4) required_604_i0 := by decide +kernel +theorem child_required_sub_604_i0 : ∀ j, childrenC_604_i0 j ⊆ insert (3, 4) required_604_i0 := by decide +kernel +theorem child_envelope_sub_604_i0 : ∀ j, childrenD_604_i0 j ⊆ envelope_604_i0 := by decide +kernel +theorem pivot_mem_604_i0 : (3, 4) ∈ envelope_604_i0 := by decide +kernel +theorem children_work_604_i0 : ∀ j, Template HasSnaky 6 (childrenC_604_i0 j) (childrenD_604_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_267 0 (1, 0)).mono (by decide +kernel) +theorem row_works_604_i0 : Template HasSnaky 7 required_604_i0 envelope_604_i0 := by + refine compose HasSnaky 6 childrenC_604_i0 childrenD_604_i0 children_work_604_i0 (3, 4) + required_604_i0 envelope_604_i0 pivot_mem_604_i0 child_required_sub_604_i0 child_envelope_sub_604_i0 ?_ + intro b hb + exact common_sub_604_i0 (mem_commonEnvelope childrenD_604_i0 b hb) +def required_604 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_604 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_604 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) required_5), required_604_i0] +def childrenD_604 : Fin 2 → Finset Cell := ![(placed21 4 (0, 3) envelope_5), envelope_604_i0] +theorem common_sub_604 : commonEnvelope childrenD_604 ⊆ insert (3, 2) required_604 := by decide +kernel +theorem child_required_sub_604 : ∀ j, childrenC_604 j ⊆ insert (3, 2) required_604 := by decide +kernel +theorem child_envelope_sub_604 : ∀ j, childrenD_604 j ⊆ envelope_604 := by decide +kernel +theorem pivot_mem_604 : (3, 2) ∈ envelope_604 := by decide +kernel +theorem children_work_604 : ∀ j, Template HasSnaky 7 (childrenC_604 j) (childrenD_604 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 3)).mono (by decide +kernel) + · exact row_works_604_i0.mono (by decide +kernel) +theorem row_works_604 : Template HasSnaky 8 required_604 envelope_604 := by + refine compose HasSnaky 7 childrenC_604 childrenD_604 children_work_604 (3, 2) + required_604 envelope_604 pivot_mem_604 child_required_sub_604 child_envelope_sub_604 ?_ + intro b hb + exact common_sub_604 (mem_commonEnvelope childrenD_604 b hb) +def required_607_i0 : Finset Cell := ⟨(([(1, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_607_i0 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_607_i0 : Fin 2 → Finset Cell := ![(placed21 3 (3, 5) required_8), (placed21 5 (6, 2) required_383)] +def childrenD_607_i0 : Fin 2 → Finset Cell := ![(placed21 3 (3, 5) envelope_8), (placed21 5 (6, 2) envelope_383)] +theorem common_sub_607_i0 : commonEnvelope childrenD_607_i0 ⊆ insert (4, 2) required_607_i0 := by decide +kernel +theorem child_required_sub_607_i0 : ∀ j, childrenC_607_i0 j ⊆ insert (4, 2) required_607_i0 := by decide +kernel +theorem child_envelope_sub_607_i0 : ∀ j, childrenD_607_i0 j ⊆ envelope_607_i0 := by decide +kernel +theorem pivot_mem_607_i0 : (4, 2) ∈ envelope_607_i0 := by decide +kernel +theorem children_work_607_i0 : ∀ j, Template HasSnaky 5 (childrenC_607_i0 j) (childrenD_607_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 3 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_383 5 (6, 2)).mono (by decide +kernel) +theorem row_works_607_i0 : Template HasSnaky 6 required_607_i0 envelope_607_i0 := by + refine compose HasSnaky 5 childrenC_607_i0 childrenD_607_i0 children_work_607_i0 (4, 2) + required_607_i0 envelope_607_i0 pivot_mem_607_i0 child_required_sub_607_i0 child_envelope_sub_607_i0 ?_ + intro b hb + exact common_sub_607_i0 (mem_commonEnvelope childrenD_607_i0 b hb) +def required_607_i3 : Finset Cell := ⟨(([(1, 2), (1, 4), (1, 5), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_607_i3 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_607_i3 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) required_25), (placed21 6 (2, 6) required_42)] +def childrenD_607_i3 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) envelope_25), (placed21 6 (2, 6) envelope_42)] +theorem common_sub_607_i3 : commonEnvelope childrenD_607_i3 ⊆ insert (2, 5) required_607_i3 := by decide +kernel +theorem child_required_sub_607_i3 : ∀ j, childrenC_607_i3 j ⊆ insert (2, 5) required_607_i3 := by decide +kernel +theorem child_envelope_sub_607_i3 : ∀ j, childrenD_607_i3 j ⊆ envelope_607_i3 := by decide +kernel +theorem pivot_mem_607_i3 : (2, 5) ∈ envelope_607_i3 := by decide +kernel +theorem children_work_607_i3 : ∀ j, Template HasSnaky 4 (childrenC_607_i3 j) (childrenD_607_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_25 5 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_42 6 (2, 6)).mono (by decide +kernel) +theorem row_works_607_i3 : Template HasSnaky 5 required_607_i3 envelope_607_i3 := by + refine compose HasSnaky 4 childrenC_607_i3 childrenD_607_i3 children_work_607_i3 (2, 5) + required_607_i3 envelope_607_i3 pivot_mem_607_i3 child_required_sub_607_i3 child_envelope_sub_607_i3 ?_ + intro b hb + exact common_sub_607_i3 (mem_commonEnvelope childrenD_607_i3 b hb) +def required_607_i2 : Finset Cell := ⟨(([(1, 4), (1, 5), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_607_i2 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_607_i2 : Fin 2 → Finset Cell := ![(placed21 7 (5, 6) required_352), required_607_i3] +def childrenD_607_i2 : Fin 2 → Finset Cell := ![(placed21 7 (5, 6) envelope_352), envelope_607_i3] +theorem common_sub_607_i2 : commonEnvelope childrenD_607_i2 ⊆ insert (1, 2) required_607_i2 := by decide +kernel +theorem child_required_sub_607_i2 : ∀ j, childrenC_607_i2 j ⊆ insert (1, 2) required_607_i2 := by decide +kernel +theorem child_envelope_sub_607_i2 : ∀ j, childrenD_607_i2 j ⊆ envelope_607_i2 := by decide +kernel +theorem pivot_mem_607_i2 : (1, 2) ∈ envelope_607_i2 := by decide +kernel +theorem children_work_607_i2 : ∀ j, Template HasSnaky 5 (childrenC_607_i2 j) (childrenD_607_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_352 7 (5, 6)).mono (by decide +kernel) + · exact row_works_607_i3.mono (by decide +kernel) +theorem row_works_607_i2 : Template HasSnaky 6 required_607_i2 envelope_607_i2 := by + refine compose HasSnaky 5 childrenC_607_i2 childrenD_607_i2 children_work_607_i2 (1, 2) + required_607_i2 envelope_607_i2 pivot_mem_607_i2 child_required_sub_607_i2 child_envelope_sub_607_i2 ?_ + intro b hb + exact common_sub_607_i2 (mem_commonEnvelope childrenD_607_i2 b hb) +def required_607_i1 : Finset Cell := ⟨(([(1, 4), (1, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_607_i1 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_607_i1 : Fin 3 → Finset Cell := ![(placed21 6 (4, 7) required_7), (placed21 5 (5, 3) required_8), required_607_i2] +def childrenD_607_i1 : Fin 3 → Finset Cell := ![(placed21 6 (4, 7) envelope_7), (placed21 5 (5, 3) envelope_8), envelope_607_i2] +theorem common_sub_607_i1 : commonEnvelope childrenD_607_i1 ⊆ insert (4, 6) required_607_i1 := by decide +kernel +theorem child_required_sub_607_i1 : ∀ j, childrenC_607_i1 j ⊆ insert (4, 6) required_607_i1 := by decide +kernel +theorem child_envelope_sub_607_i1 : ∀ j, childrenD_607_i1 j ⊆ envelope_607_i1 := by decide +kernel +theorem pivot_mem_607_i1 : (4, 6) ∈ envelope_607_i1 := by decide +kernel +theorem children_work_607_i1 : ∀ j, Template HasSnaky 6 (childrenC_607_i1 j) (childrenD_607_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_8 5 (5, 3)).mono (by decide +kernel) + · exact row_works_607_i2.mono (by decide +kernel) +theorem row_works_607_i1 : Template HasSnaky 7 required_607_i1 envelope_607_i1 := by + refine compose HasSnaky 6 childrenC_607_i1 childrenD_607_i1 children_work_607_i1 (4, 6) + required_607_i1 envelope_607_i1 pivot_mem_607_i1 child_required_sub_607_i1 child_envelope_sub_607_i1 ?_ + intro b hb + exact common_sub_607_i1 (mem_commonEnvelope childrenD_607_i1 b hb) +def required_607_i4 : Finset Cell := ⟨(([(1, 4), (1, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_607_i4 : Finset Cell := ⟨(([(0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_607_i4 : Fin 4 → Finset Cell := ![(placed21 5 (5, 3) required_197), (placed21 0 (1, 2) required_363), (placed21 5 (5, 3) required_371), (placed21 2 (5, 2) required_606)] +def childrenD_607_i4 : Fin 4 → Finset Cell := ![(placed21 5 (5, 3) envelope_197), (placed21 0 (1, 2) envelope_363), (placed21 5 (5, 3) envelope_371), (placed21 2 (5, 2) envelope_606)] +theorem common_sub_607_i4 : commonEnvelope childrenD_607_i4 ⊆ insert (4, 6) required_607_i4 := by decide +kernel +theorem child_required_sub_607_i4 : ∀ j, childrenC_607_i4 j ⊆ insert (4, 6) required_607_i4 := by decide +kernel +theorem child_envelope_sub_607_i4 : ∀ j, childrenD_607_i4 j ⊆ envelope_607_i4 := by decide +kernel +theorem pivot_mem_607_i4 : (4, 6) ∈ envelope_607_i4 := by decide +kernel +theorem children_work_607_i4 : ∀ j, Template HasSnaky 6 (childrenC_607_i4 j) (childrenD_607_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_197 5 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_363 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_371 5 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_606 2 (5, 2)).mono (by decide +kernel) +theorem row_works_607_i4 : Template HasSnaky 7 required_607_i4 envelope_607_i4 := by + refine compose HasSnaky 6 childrenC_607_i4 childrenD_607_i4 children_work_607_i4 (4, 6) + required_607_i4 envelope_607_i4 pivot_mem_607_i4 child_required_sub_607_i4 child_envelope_sub_607_i4 ?_ + intro b hb + exact common_sub_607_i4 (mem_commonEnvelope childrenD_607_i4 b hb) +def required_607 : Finset Cell := ⟨(([(1, 4), (1, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_607 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_607 : Fin 5 → Finset Cell := ![(placed21 6 (5, 7) required_13), (placed21 4 (1, 7) required_211), required_607_i0, required_607_i1, required_607_i4] +def childrenD_607 : Fin 5 → Finset Cell := ![(placed21 6 (5, 7) envelope_13), (placed21 4 (1, 7) envelope_211), envelope_607_i0, envelope_607_i1, envelope_607_i4] +theorem common_sub_607 : commonEnvelope childrenD_607 ⊆ insert (4, 3) required_607 := by decide +kernel +theorem child_required_sub_607 : ∀ j, childrenC_607 j ⊆ insert (4, 3) required_607 := by decide +kernel +theorem child_envelope_sub_607 : ∀ j, childrenD_607 j ⊆ envelope_607 := by decide +kernel +theorem pivot_mem_607 : (4, 3) ∈ envelope_607 := by decide +kernel +theorem children_work_607 : ∀ j, Template HasSnaky 7 (childrenC_607 j) (childrenD_607 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_211 4 (1, 7)).mono (by decide +kernel) + · exact row_works_607_i0.mono (by decide +kernel) + · exact row_works_607_i1.mono (by decide +kernel) + · exact row_works_607_i4.mono (by decide +kernel) +theorem row_works_607 : Template HasSnaky 8 required_607 envelope_607 := by + refine compose HasSnaky 7 childrenC_607 childrenD_607 children_work_607 (4, 3) + required_607 envelope_607 pivot_mem_607 child_required_sub_607 child_envelope_sub_607 ?_ + intro b hb + exact common_sub_607 (mem_commonEnvelope childrenD_607 b hb) +def required_619_i0 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_619_i0 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4), (8, 2), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_619_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 0) required_56), (placed21 0 (1, 0) required_253)] +def childrenD_619_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 0) envelope_56), (placed21 0 (1, 0) envelope_253)] +theorem common_sub_619_i0 : commonEnvelope childrenD_619_i0 ⊆ insert (2, 2) required_619_i0 := by decide +kernel +theorem child_required_sub_619_i0 : ∀ j, childrenC_619_i0 j ⊆ insert (2, 2) required_619_i0 := by decide +kernel +theorem child_envelope_sub_619_i0 : ∀ j, childrenD_619_i0 j ⊆ envelope_619_i0 := by decide +kernel +theorem pivot_mem_619_i0 : (2, 2) ∈ envelope_619_i0 := by decide +kernel +theorem children_work_619_i0 : ∀ j, Template HasSnaky 6 (childrenC_619_i0 j) (childrenD_619_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_56 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_253 0 (1, 0)).mono (by decide +kernel) +theorem row_works_619_i0 : Template HasSnaky 7 required_619_i0 envelope_619_i0 := by + refine compose HasSnaky 6 childrenC_619_i0 childrenD_619_i0 children_work_619_i0 (2, 2) + required_619_i0 envelope_619_i0 pivot_mem_619_i0 child_required_sub_619_i0 child_envelope_sub_619_i0 ?_ + intro b hb + exact common_sub_619_i0 (mem_commonEnvelope childrenD_619_i0 b hb) +def required_619 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_619 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4), (8, 2), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_619 : Fin 6 → Finset Cell := ![(placed21 0 (1, 2) required_8), (placed21 0 (1, 2) required_26), (placed21 0 (1, 2) required_49), (placed21 0 (1, 0) required_115), (placed21 0 (1, 0) required_292), required_619_i0] +def childrenD_619 : Fin 6 → Finset Cell := ![(placed21 0 (1, 2) envelope_8), (placed21 0 (1, 2) envelope_26), (placed21 0 (1, 2) envelope_49), (placed21 0 (1, 0) envelope_115), (placed21 0 (1, 0) envelope_292), envelope_619_i0] +theorem common_sub_619 : commonEnvelope childrenD_619 ⊆ insert (4, 3) required_619 := by decide +kernel +theorem child_required_sub_619 : ∀ j, childrenC_619 j ⊆ insert (4, 3) required_619 := by decide +kernel +theorem child_envelope_sub_619 : ∀ j, childrenD_619 j ⊆ envelope_619 := by decide +kernel +theorem pivot_mem_619 : (4, 3) ∈ envelope_619 := by decide +kernel +theorem children_work_619 : ∀ j, Template HasSnaky 7 (childrenC_619 j) (childrenD_619 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_26 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_49 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_115 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_292 0 (1, 0)).mono (by decide +kernel) + · exact row_works_619_i0.mono (by decide +kernel) +theorem row_works_619 : Template HasSnaky 8 required_619 envelope_619 := by + refine compose HasSnaky 7 childrenC_619 childrenD_619 children_work_619 (4, 3) + required_619 envelope_619 pivot_mem_619 child_required_sub_619 child_envelope_sub_619 ?_ + intro b hb + exact common_sub_619 (mem_commonEnvelope childrenD_619 b hb) +def required_651_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 6), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_651_i0 : Finset Cell := ⟨(([(0, 3), (0, 6), (1, 3), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_651_i0 : Fin 2 → Finset Cell := ![(placed21 5 (6, 3) required_55), (placed21 7 (6, 6) required_56)] +def childrenD_651_i0 : Fin 2 → Finset Cell := ![(placed21 5 (6, 3) envelope_55), (placed21 7 (6, 6) envelope_56)] +theorem common_sub_651_i0 : commonEnvelope childrenD_651_i0 ⊆ insert (3, 5) required_651_i0 := by decide +kernel +theorem child_required_sub_651_i0 : ∀ j, childrenC_651_i0 j ⊆ insert (3, 5) required_651_i0 := by decide +kernel +theorem child_envelope_sub_651_i0 : ∀ j, childrenD_651_i0 j ⊆ envelope_651_i0 := by decide +kernel +theorem pivot_mem_651_i0 : (3, 5) ∈ envelope_651_i0 := by decide +kernel +theorem children_work_651_i0 : ∀ j, Template HasSnaky 4 (childrenC_651_i0 j) (childrenD_651_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_55 5 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_56 7 (6, 6)).mono (by decide +kernel) +theorem row_works_651_i0 : Template HasSnaky 5 required_651_i0 envelope_651_i0 := by + refine compose HasSnaky 4 childrenC_651_i0 childrenD_651_i0 children_work_651_i0 (3, 5) + required_651_i0 envelope_651_i0 pivot_mem_651_i0 child_required_sub_651_i0 child_envelope_sub_651_i0 ?_ + intro b hb + exact common_sub_651_i0 (mem_commonEnvelope childrenD_651_i0 b hb) +def required_651_i1 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 6), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_651_i1 : Finset Cell := ⟨(([(0, 6), (1, 6), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_651_i1 : Fin 3 → Finset Cell := ![(placed21 2 (4, 3) required_20), (placed21 0 (3, 3) required_29), (placed21 5 (5, 3) required_46)] +def childrenD_651_i1 : Fin 3 → Finset Cell := ![(placed21 2 (4, 3) envelope_20), (placed21 0 (3, 3) envelope_29), (placed21 5 (5, 3) envelope_46)] +theorem common_sub_651_i1 : commonEnvelope childrenD_651_i1 ⊆ insert (3, 5) required_651_i1 := by decide +kernel +theorem child_required_sub_651_i1 : ∀ j, childrenC_651_i1 j ⊆ insert (3, 5) required_651_i1 := by decide +kernel +theorem child_envelope_sub_651_i1 : ∀ j, childrenD_651_i1 j ⊆ envelope_651_i1 := by decide +kernel +theorem pivot_mem_651_i1 : (3, 5) ∈ envelope_651_i1 := by decide +kernel +theorem children_work_651_i1 : ∀ j, Template HasSnaky 4 (childrenC_651_i1 j) (childrenD_651_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_20 2 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_29 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_46 5 (5, 3)).mono (by decide +kernel) +theorem row_works_651_i1 : Template HasSnaky 5 required_651_i1 envelope_651_i1 := by + refine compose HasSnaky 4 childrenC_651_i1 childrenD_651_i1 children_work_651_i1 (3, 5) + required_651_i1 envelope_651_i1 pivot_mem_651_i1 child_required_sub_651_i1 child_envelope_sub_651_i1 ?_ + intro b hb + exact common_sub_651_i1 (mem_commonEnvelope childrenD_651_i1 b hb) +def required_651_i2 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 6), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_651_i2 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3), (3, 4), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_651_i2 : Fin 2 → Finset Cell := ![(placed21 7 (7, 5) required_85), (placed21 2 (4, 3) required_94)] +def childrenD_651_i2 : Fin 2 → Finset Cell := ![(placed21 7 (7, 5) envelope_85), (placed21 2 (4, 3) envelope_94)] +theorem common_sub_651_i2 : commonEnvelope childrenD_651_i2 ⊆ insert (4, 3) required_651_i2 := by decide +kernel +theorem child_required_sub_651_i2 : ∀ j, childrenC_651_i2 j ⊆ insert (4, 3) required_651_i2 := by decide +kernel +theorem child_envelope_sub_651_i2 : ∀ j, childrenD_651_i2 j ⊆ envelope_651_i2 := by decide +kernel +theorem pivot_mem_651_i2 : (4, 3) ∈ envelope_651_i2 := by decide +kernel +theorem children_work_651_i2 : ∀ j, Template HasSnaky 6 (childrenC_651_i2 j) (childrenD_651_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_85 7 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_94 2 (4, 3)).mono (by decide +kernel) +theorem row_works_651_i2 : Template HasSnaky 7 required_651_i2 envelope_651_i2 := by + refine compose HasSnaky 6 childrenC_651_i2 childrenD_651_i2 children_work_651_i2 (4, 3) + required_651_i2 envelope_651_i2 pivot_mem_651_i2 child_required_sub_651_i2 child_envelope_sub_651_i2 ?_ + intro b hb + exact common_sub_651_i2 (mem_commonEnvelope childrenD_651_i2 b hb) +def required_651 : Finset Cell := ⟨(([(3, 3), (3, 4), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_651 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 6), (1, 2), (1, 3), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 2), (6, 3), (6, 4), (6, 5), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_651 : Fin 3 → Finset Cell := ![required_651_i0, required_651_i1, required_651_i2] +def childrenD_651 : Fin 3 → Finset Cell := ![envelope_651_i0, envelope_651_i1, envelope_651_i2] +theorem common_sub_651 : commonEnvelope childrenD_651 ⊆ insert (3, 6) required_651 := by decide +kernel +theorem child_required_sub_651 : ∀ j, childrenC_651 j ⊆ insert (3, 6) required_651 := by decide +kernel +theorem child_envelope_sub_651 : ∀ j, childrenD_651 j ⊆ envelope_651 := by decide +kernel +theorem pivot_mem_651 : (3, 6) ∈ envelope_651 := by decide +kernel +theorem children_work_651 : ∀ j, Template HasSnaky 7 (childrenC_651 j) (childrenD_651 j) := by + intro j + fin_cases j + · exact row_works_651_i0.mono (by decide +kernel) + · exact row_works_651_i1.mono (by decide +kernel) + · exact row_works_651_i2.mono (by decide +kernel) +theorem row_works_651 : Template HasSnaky 8 required_651 envelope_651 := by + refine compose HasSnaky 7 childrenC_651 childrenD_651 children_work_651 (3, 6) + required_651 envelope_651 pivot_mem_651 child_required_sub_651 child_envelope_sub_651 ?_ + intro b hb + exact common_sub_651 (mem_commonEnvelope childrenD_651 b hb) +def height_559_i0 : ℕ := 5 +def childrenH_559_i0 : Fin 2 → ℕ := ![height_0, height_17] +theorem height_exact_559_i0 : height_559_i0 = 1 + Finset.univ.sup childrenH_559_i0 := by decide +kernel +theorem required_origin_559_i0 : ∀ x ∈ required_559_i0, + (∃ j, x ∈ childrenC_559_i0 j) ∨ ∀ j, x ∈ childrenD_559_i0 j := by decide +kernel +theorem required_exact_559_i0 : required_559_i0 = + ((Finset.univ.biUnion childrenC_559_i0) ∪ commonEnvelope childrenD_559_i0).erase (4, 0) := by + exact required_eq_combination childrenC_559_i0 childrenD_559_i0 (4, 0) required_559_i0 + (by decide +kernel) child_required_sub_559_i0 common_sub_559_i0 required_origin_559_i0 +theorem envelope_origin_559_i0 : ∀ x ∈ envelope_559_i0, + x = (4, 0) ∨ ∃ j, x ∈ childrenD_559_i0 j := by decide +kernel +theorem envelope_exact_559_i0 : envelope_559_i0 = + insert (4, 0) (Finset.univ.biUnion childrenD_559_i0) := by + exact envelope_eq_combination childrenD_559_i0 (4, 0) envelope_559_i0 + pivot_mem_559_i0 child_envelope_sub_559_i0 envelope_origin_559_i0 +def checked_559_i0 : CheckedCard where + required := required_559_i0 + envelope := envelope_559_i0 + height := height_559_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_559_i0 +def height_559_i6 : ℕ := 2 +def childrenH_559_i6 : Fin 2 → ℕ := ![height_0, height_0] +theorem height_exact_559_i6 : height_559_i6 = 1 + Finset.univ.sup childrenH_559_i6 := by decide +kernel +theorem required_origin_559_i6 : ∀ x ∈ required_559_i6, + (∃ j, x ∈ childrenC_559_i6 j) ∨ ∀ j, x ∈ childrenD_559_i6 j := by decide +kernel +theorem required_exact_559_i6 : required_559_i6 = + ((Finset.univ.biUnion childrenC_559_i6) ∪ commonEnvelope childrenD_559_i6).erase (1, 3) := by + exact required_eq_combination childrenC_559_i6 childrenD_559_i6 (1, 3) required_559_i6 + (by decide +kernel) child_required_sub_559_i6 common_sub_559_i6 required_origin_559_i6 +theorem envelope_origin_559_i6 : ∀ x ∈ envelope_559_i6, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_559_i6 j := by decide +kernel +theorem envelope_exact_559_i6 : envelope_559_i6 = + insert (1, 3) (Finset.univ.biUnion childrenD_559_i6) := by + exact envelope_eq_combination childrenD_559_i6 (1, 3) envelope_559_i6 + pivot_mem_559_i6 child_envelope_sub_559_i6 envelope_origin_559_i6 +def checked_559_i6 : CheckedCard where + required := required_559_i6 + envelope := envelope_559_i6 + height := height_559_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_559_i6 +def height_559_i5 : ℕ := 3 +def childrenH_559_i5 : Fin 2 → ℕ := ![height_1, height_559_i6] +theorem height_exact_559_i5 : height_559_i5 = 1 + Finset.univ.sup childrenH_559_i5 := by decide +kernel +theorem required_origin_559_i5 : ∀ x ∈ required_559_i5, + (∃ j, x ∈ childrenC_559_i5 j) ∨ ∀ j, x ∈ childrenD_559_i5 j := by decide +kernel +theorem required_exact_559_i5 : required_559_i5 = + ((Finset.univ.biUnion childrenC_559_i5) ∪ commonEnvelope childrenD_559_i5).erase (2, 3) := by + exact required_eq_combination childrenC_559_i5 childrenD_559_i5 (2, 3) required_559_i5 + (by decide +kernel) child_required_sub_559_i5 common_sub_559_i5 required_origin_559_i5 +theorem envelope_origin_559_i5 : ∀ x ∈ envelope_559_i5, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_559_i5 j := by decide +kernel +theorem envelope_exact_559_i5 : envelope_559_i5 = + insert (2, 3) (Finset.univ.biUnion childrenD_559_i5) := by + exact envelope_eq_combination childrenD_559_i5 (2, 3) envelope_559_i5 + pivot_mem_559_i5 child_envelope_sub_559_i5 envelope_origin_559_i5 +def checked_559_i5 : CheckedCard where + required := required_559_i5 + envelope := envelope_559_i5 + height := height_559_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_559_i5 +def height_559_i4 : ℕ := 4 +def childrenH_559_i4 : Fin 2 → ℕ := ![height_5, height_559_i5] +theorem height_exact_559_i4 : height_559_i4 = 1 + Finset.univ.sup childrenH_559_i4 := by decide +kernel +theorem required_origin_559_i4 : ∀ x ∈ required_559_i4, + (∃ j, x ∈ childrenC_559_i4 j) ∨ ∀ j, x ∈ childrenD_559_i4 j := by decide +kernel +theorem required_exact_559_i4 : required_559_i4 = + ((Finset.univ.biUnion childrenC_559_i4) ∪ commonEnvelope childrenD_559_i4).erase (4, 4) := by + exact required_eq_combination childrenC_559_i4 childrenD_559_i4 (4, 4) required_559_i4 + (by decide +kernel) child_required_sub_559_i4 common_sub_559_i4 required_origin_559_i4 +theorem envelope_origin_559_i4 : ∀ x ∈ envelope_559_i4, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_559_i4 j := by decide +kernel +theorem envelope_exact_559_i4 : envelope_559_i4 = + insert (4, 4) (Finset.univ.biUnion childrenD_559_i4) := by + exact envelope_eq_combination childrenD_559_i4 (4, 4) envelope_559_i4 + pivot_mem_559_i4 child_envelope_sub_559_i4 envelope_origin_559_i4 +def checked_559_i4 : CheckedCard where + required := required_559_i4 + envelope := envelope_559_i4 + height := height_559_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_559_i4 +def height_559_i3 : ℕ := 5 +def childrenH_559_i3 : Fin 2 → ℕ := ![height_35, height_559_i4] +theorem height_exact_559_i3 : height_559_i3 = 1 + Finset.univ.sup childrenH_559_i3 := by decide +kernel +theorem required_origin_559_i3 : ∀ x ∈ required_559_i3, + (∃ j, x ∈ childrenC_559_i3 j) ∨ ∀ j, x ∈ childrenD_559_i3 j := by decide +kernel +theorem required_exact_559_i3 : required_559_i3 = + ((Finset.univ.biUnion childrenC_559_i3) ∪ commonEnvelope childrenD_559_i3).erase (6, 4) := by + exact required_eq_combination childrenC_559_i3 childrenD_559_i3 (6, 4) required_559_i3 + (by decide +kernel) child_required_sub_559_i3 common_sub_559_i3 required_origin_559_i3 +theorem envelope_origin_559_i3 : ∀ x ∈ envelope_559_i3, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_559_i3 j := by decide +kernel +theorem envelope_exact_559_i3 : envelope_559_i3 = + insert (6, 4) (Finset.univ.biUnion childrenD_559_i3) := by + exact envelope_eq_combination childrenD_559_i3 (6, 4) envelope_559_i3 + pivot_mem_559_i3 child_envelope_sub_559_i3 envelope_origin_559_i3 +def checked_559_i3 : CheckedCard where + required := required_559_i3 + envelope := envelope_559_i3 + height := height_559_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_559_i3 +def height_559_i2 : ℕ := 6 +def childrenH_559_i2 : Fin 2 → ℕ := ![height_244, height_559_i3] +theorem height_exact_559_i2 : height_559_i2 = 1 + Finset.univ.sup childrenH_559_i2 := by decide +kernel +theorem required_origin_559_i2 : ∀ x ∈ required_559_i2, + (∃ j, x ∈ childrenC_559_i2 j) ∨ ∀ j, x ∈ childrenD_559_i2 j := by decide +kernel +theorem required_exact_559_i2 : required_559_i2 = + ((Finset.univ.biUnion childrenC_559_i2) ∪ commonEnvelope childrenD_559_i2).erase (5, 0) := by + exact required_eq_combination childrenC_559_i2 childrenD_559_i2 (5, 0) required_559_i2 + (by decide +kernel) child_required_sub_559_i2 common_sub_559_i2 required_origin_559_i2 +theorem envelope_origin_559_i2 : ∀ x ∈ envelope_559_i2, + x = (5, 0) ∨ ∃ j, x ∈ childrenD_559_i2 j := by decide +kernel +theorem envelope_exact_559_i2 : envelope_559_i2 = + insert (5, 0) (Finset.univ.biUnion childrenD_559_i2) := by + exact envelope_eq_combination childrenD_559_i2 (5, 0) envelope_559_i2 + pivot_mem_559_i2 child_envelope_sub_559_i2 envelope_origin_559_i2 +def checked_559_i2 : CheckedCard where + required := required_559_i2 + envelope := envelope_559_i2 + height := height_559_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_559_i2 +def height_559_i1 : ℕ := 7 +def childrenH_559_i1 : Fin 2 → ℕ := ![height_5, height_559_i2] +theorem height_exact_559_i1 : height_559_i1 = 1 + Finset.univ.sup childrenH_559_i1 := by decide +kernel +theorem required_origin_559_i1 : ∀ x ∈ required_559_i1, + (∃ j, x ∈ childrenC_559_i1 j) ∨ ∀ j, x ∈ childrenD_559_i1 j := by decide +kernel +theorem required_exact_559_i1 : required_559_i1 = + ((Finset.univ.biUnion childrenC_559_i1) ∪ commonEnvelope childrenD_559_i1).erase (3, 4) := by + exact required_eq_combination childrenC_559_i1 childrenD_559_i1 (3, 4) required_559_i1 + (by decide +kernel) child_required_sub_559_i1 common_sub_559_i1 required_origin_559_i1 +theorem envelope_origin_559_i1 : ∀ x ∈ envelope_559_i1, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_559_i1 j := by decide +kernel +theorem envelope_exact_559_i1 : envelope_559_i1 = + insert (3, 4) (Finset.univ.biUnion childrenD_559_i1) := by + exact envelope_eq_combination childrenD_559_i1 (3, 4) envelope_559_i1 + pivot_mem_559_i1 child_envelope_sub_559_i1 envelope_origin_559_i1 +def checked_559_i1 : CheckedCard where + required := required_559_i1 + envelope := envelope_559_i1 + height := height_559_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_559_i1 +def height_559 : ℕ := 8 +def childrenH_559 : Fin 4 → ℕ := ![height_8, height_236, height_559_i0, height_559_i1] +theorem height_exact_559 : height_559 = 1 + Finset.univ.sup childrenH_559 := by decide +kernel +theorem required_origin_559 : ∀ x ∈ required_559, + (∃ j, x ∈ childrenC_559 j) ∨ ∀ j, x ∈ childrenD_559 j := by decide +kernel +theorem required_exact_559 : required_559 = + ((Finset.univ.biUnion childrenC_559) ∪ commonEnvelope childrenD_559).erase (6, 1) := by + exact required_eq_combination childrenC_559 childrenD_559 (6, 1) required_559 + (by decide +kernel) child_required_sub_559 common_sub_559 required_origin_559 +theorem envelope_origin_559 : ∀ x ∈ envelope_559, + x = (6, 1) ∨ ∃ j, x ∈ childrenD_559 j := by decide +kernel +theorem envelope_exact_559 : envelope_559 = + insert (6, 1) (Finset.univ.biUnion childrenD_559) := by + exact envelope_eq_combination childrenD_559 (6, 1) envelope_559 + pivot_mem_559 child_envelope_sub_559 envelope_origin_559 +def checked_559 : CheckedCard where + required := required_559 + envelope := envelope_559 + height := height_559 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_559 +def height_566 : ℕ := 8 +def childrenH_566 : Fin 6 → ℕ := ![height_116, height_116, height_172, height_172, height_182, height_565] +theorem height_exact_566 : height_566 = 1 + Finset.univ.sup childrenH_566 := by decide +kernel +theorem required_origin_566 : ∀ x ∈ required_566, + (∃ j, x ∈ childrenC_566 j) ∨ ∀ j, x ∈ childrenD_566 j := by decide +kernel +theorem required_exact_566 : required_566 = + ((Finset.univ.biUnion childrenC_566) ∪ commonEnvelope childrenD_566).erase (3, 5) := by + exact required_eq_combination childrenC_566 childrenD_566 (3, 5) required_566 + (by decide +kernel) child_required_sub_566 common_sub_566 required_origin_566 +theorem envelope_origin_566 : ∀ x ∈ envelope_566, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_566 j := by decide +kernel +theorem envelope_exact_566 : envelope_566 = + insert (3, 5) (Finset.univ.biUnion childrenD_566) := by + exact envelope_eq_combination childrenD_566 (3, 5) envelope_566 + pivot_mem_566 child_envelope_sub_566 envelope_origin_566 +def checked_566 : CheckedCard where + required := required_566 + envelope := envelope_566 + height := height_566 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_566 +def height_604_i0 : ℕ := 7 +def childrenH_604_i0 : Fin 2 → ℕ := ![height_5, height_267] +theorem height_exact_604_i0 : height_604_i0 = 1 + Finset.univ.sup childrenH_604_i0 := by decide +kernel +theorem required_origin_604_i0 : ∀ x ∈ required_604_i0, + (∃ j, x ∈ childrenC_604_i0 j) ∨ ∀ j, x ∈ childrenD_604_i0 j := by decide +kernel +theorem required_exact_604_i0 : required_604_i0 = + ((Finset.univ.biUnion childrenC_604_i0) ∪ commonEnvelope childrenD_604_i0).erase (3, 4) := by + exact required_eq_combination childrenC_604_i0 childrenD_604_i0 (3, 4) required_604_i0 + (by decide +kernel) child_required_sub_604_i0 common_sub_604_i0 required_origin_604_i0 +theorem envelope_origin_604_i0 : ∀ x ∈ envelope_604_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_604_i0 j := by decide +kernel +theorem envelope_exact_604_i0 : envelope_604_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_604_i0) := by + exact envelope_eq_combination childrenD_604_i0 (3, 4) envelope_604_i0 + pivot_mem_604_i0 child_envelope_sub_604_i0 envelope_origin_604_i0 +def checked_604_i0 : CheckedCard where + required := required_604_i0 + envelope := envelope_604_i0 + height := height_604_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_604_i0 +def height_604 : ℕ := 8 +def childrenH_604 : Fin 2 → ℕ := ![height_5, height_604_i0] +theorem height_exact_604 : height_604 = 1 + Finset.univ.sup childrenH_604 := by decide +kernel +theorem required_origin_604 : ∀ x ∈ required_604, + (∃ j, x ∈ childrenC_604 j) ∨ ∀ j, x ∈ childrenD_604 j := by decide +kernel +theorem required_exact_604 : required_604 = + ((Finset.univ.biUnion childrenC_604) ∪ commonEnvelope childrenD_604).erase (3, 2) := by + exact required_eq_combination childrenC_604 childrenD_604 (3, 2) required_604 + (by decide +kernel) child_required_sub_604 common_sub_604 required_origin_604 +theorem envelope_origin_604 : ∀ x ∈ envelope_604, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_604 j := by decide +kernel +theorem envelope_exact_604 : envelope_604 = + insert (3, 2) (Finset.univ.biUnion childrenD_604) := by + exact envelope_eq_combination childrenD_604 (3, 2) envelope_604 + pivot_mem_604 child_envelope_sub_604 envelope_origin_604 +def checked_604 : CheckedCard where + required := required_604 + envelope := envelope_604 + height := height_604 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_604 +def height_607_i0 : ℕ := 6 +def childrenH_607_i0 : Fin 2 → ℕ := ![height_8, height_383] +theorem height_exact_607_i0 : height_607_i0 = 1 + Finset.univ.sup childrenH_607_i0 := by decide +kernel +theorem required_origin_607_i0 : ∀ x ∈ required_607_i0, + (∃ j, x ∈ childrenC_607_i0 j) ∨ ∀ j, x ∈ childrenD_607_i0 j := by decide +kernel +theorem required_exact_607_i0 : required_607_i0 = + ((Finset.univ.biUnion childrenC_607_i0) ∪ commonEnvelope childrenD_607_i0).erase (4, 2) := by + exact required_eq_combination childrenC_607_i0 childrenD_607_i0 (4, 2) required_607_i0 + (by decide +kernel) child_required_sub_607_i0 common_sub_607_i0 required_origin_607_i0 +theorem envelope_origin_607_i0 : ∀ x ∈ envelope_607_i0, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_607_i0 j := by decide +kernel +theorem envelope_exact_607_i0 : envelope_607_i0 = + insert (4, 2) (Finset.univ.biUnion childrenD_607_i0) := by + exact envelope_eq_combination childrenD_607_i0 (4, 2) envelope_607_i0 + pivot_mem_607_i0 child_envelope_sub_607_i0 envelope_origin_607_i0 +def checked_607_i0 : CheckedCard where + required := required_607_i0 + envelope := envelope_607_i0 + height := height_607_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_607_i0 +def height_607_i3 : ℕ := 5 +def childrenH_607_i3 : Fin 2 → ℕ := ![height_25, height_42] +theorem height_exact_607_i3 : height_607_i3 = 1 + Finset.univ.sup childrenH_607_i3 := by decide +kernel +theorem required_origin_607_i3 : ∀ x ∈ required_607_i3, + (∃ j, x ∈ childrenC_607_i3 j) ∨ ∀ j, x ∈ childrenD_607_i3 j := by decide +kernel +theorem required_exact_607_i3 : required_607_i3 = + ((Finset.univ.biUnion childrenC_607_i3) ∪ commonEnvelope childrenD_607_i3).erase (2, 5) := by + exact required_eq_combination childrenC_607_i3 childrenD_607_i3 (2, 5) required_607_i3 + (by decide +kernel) child_required_sub_607_i3 common_sub_607_i3 required_origin_607_i3 +theorem envelope_origin_607_i3 : ∀ x ∈ envelope_607_i3, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_607_i3 j := by decide +kernel +theorem envelope_exact_607_i3 : envelope_607_i3 = + insert (2, 5) (Finset.univ.biUnion childrenD_607_i3) := by + exact envelope_eq_combination childrenD_607_i3 (2, 5) envelope_607_i3 + pivot_mem_607_i3 child_envelope_sub_607_i3 envelope_origin_607_i3 +def checked_607_i3 : CheckedCard where + required := required_607_i3 + envelope := envelope_607_i3 + height := height_607_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_607_i3 +def height_607_i2 : ℕ := 6 +def childrenH_607_i2 : Fin 2 → ℕ := ![height_352, height_607_i3] +theorem height_exact_607_i2 : height_607_i2 = 1 + Finset.univ.sup childrenH_607_i2 := by decide +kernel +theorem required_origin_607_i2 : ∀ x ∈ required_607_i2, + (∃ j, x ∈ childrenC_607_i2 j) ∨ ∀ j, x ∈ childrenD_607_i2 j := by decide +kernel +theorem required_exact_607_i2 : required_607_i2 = + ((Finset.univ.biUnion childrenC_607_i2) ∪ commonEnvelope childrenD_607_i2).erase (1, 2) := by + exact required_eq_combination childrenC_607_i2 childrenD_607_i2 (1, 2) required_607_i2 + (by decide +kernel) child_required_sub_607_i2 common_sub_607_i2 required_origin_607_i2 +theorem envelope_origin_607_i2 : ∀ x ∈ envelope_607_i2, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_607_i2 j := by decide +kernel +theorem envelope_exact_607_i2 : envelope_607_i2 = + insert (1, 2) (Finset.univ.biUnion childrenD_607_i2) := by + exact envelope_eq_combination childrenD_607_i2 (1, 2) envelope_607_i2 + pivot_mem_607_i2 child_envelope_sub_607_i2 envelope_origin_607_i2 +def checked_607_i2 : CheckedCard where + required := required_607_i2 + envelope := envelope_607_i2 + height := height_607_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_607_i2 +def height_607_i1 : ℕ := 7 +def childrenH_607_i1 : Fin 3 → ℕ := ![height_7, height_8, height_607_i2] +theorem height_exact_607_i1 : height_607_i1 = 1 + Finset.univ.sup childrenH_607_i1 := by decide +kernel +theorem required_origin_607_i1 : ∀ x ∈ required_607_i1, + (∃ j, x ∈ childrenC_607_i1 j) ∨ ∀ j, x ∈ childrenD_607_i1 j := by decide +kernel +theorem required_exact_607_i1 : required_607_i1 = + ((Finset.univ.biUnion childrenC_607_i1) ∪ commonEnvelope childrenD_607_i1).erase (4, 6) := by + exact required_eq_combination childrenC_607_i1 childrenD_607_i1 (4, 6) required_607_i1 + (by decide +kernel) child_required_sub_607_i1 common_sub_607_i1 required_origin_607_i1 +theorem envelope_origin_607_i1 : ∀ x ∈ envelope_607_i1, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_607_i1 j := by decide +kernel +theorem envelope_exact_607_i1 : envelope_607_i1 = + insert (4, 6) (Finset.univ.biUnion childrenD_607_i1) := by + exact envelope_eq_combination childrenD_607_i1 (4, 6) envelope_607_i1 + pivot_mem_607_i1 child_envelope_sub_607_i1 envelope_origin_607_i1 +def checked_607_i1 : CheckedCard where + required := required_607_i1 + envelope := envelope_607_i1 + height := height_607_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_607_i1 +def height_607_i4 : ℕ := 7 +def childrenH_607_i4 : Fin 4 → ℕ := ![height_197, height_363, height_371, height_606] +theorem height_exact_607_i4 : height_607_i4 = 1 + Finset.univ.sup childrenH_607_i4 := by decide +kernel +theorem required_origin_607_i4 : ∀ x ∈ required_607_i4, + (∃ j, x ∈ childrenC_607_i4 j) ∨ ∀ j, x ∈ childrenD_607_i4 j := by decide +kernel +theorem required_exact_607_i4 : required_607_i4 = + ((Finset.univ.biUnion childrenC_607_i4) ∪ commonEnvelope childrenD_607_i4).erase (4, 6) := by + exact required_eq_combination childrenC_607_i4 childrenD_607_i4 (4, 6) required_607_i4 + (by decide +kernel) child_required_sub_607_i4 common_sub_607_i4 required_origin_607_i4 +theorem envelope_origin_607_i4 : ∀ x ∈ envelope_607_i4, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_607_i4 j := by decide +kernel +theorem envelope_exact_607_i4 : envelope_607_i4 = + insert (4, 6) (Finset.univ.biUnion childrenD_607_i4) := by + exact envelope_eq_combination childrenD_607_i4 (4, 6) envelope_607_i4 + pivot_mem_607_i4 child_envelope_sub_607_i4 envelope_origin_607_i4 +def checked_607_i4 : CheckedCard where + required := required_607_i4 + envelope := envelope_607_i4 + height := height_607_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_607_i4 +def height_607 : ℕ := 8 +def childrenH_607 : Fin 5 → ℕ := ![height_13, height_211, height_607_i0, height_607_i1, height_607_i4] +theorem height_exact_607 : height_607 = 1 + Finset.univ.sup childrenH_607 := by decide +kernel +theorem required_origin_607 : ∀ x ∈ required_607, + (∃ j, x ∈ childrenC_607 j) ∨ ∀ j, x ∈ childrenD_607 j := by decide +kernel +theorem required_exact_607 : required_607 = + ((Finset.univ.biUnion childrenC_607) ∪ commonEnvelope childrenD_607).erase (4, 3) := by + exact required_eq_combination childrenC_607 childrenD_607 (4, 3) required_607 + (by decide +kernel) child_required_sub_607 common_sub_607 required_origin_607 +theorem envelope_origin_607 : ∀ x ∈ envelope_607, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_607 j := by decide +kernel +theorem envelope_exact_607 : envelope_607 = + insert (4, 3) (Finset.univ.biUnion childrenD_607) := by + exact envelope_eq_combination childrenD_607 (4, 3) envelope_607 + pivot_mem_607 child_envelope_sub_607 envelope_origin_607 +def checked_607 : CheckedCard where + required := required_607 + envelope := envelope_607 + height := height_607 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_607 +def height_619_i0 : ℕ := 7 +def childrenH_619_i0 : Fin 2 → ℕ := ![height_56, height_253] +theorem height_exact_619_i0 : height_619_i0 = 1 + Finset.univ.sup childrenH_619_i0 := by decide +kernel +theorem required_origin_619_i0 : ∀ x ∈ required_619_i0, + (∃ j, x ∈ childrenC_619_i0 j) ∨ ∀ j, x ∈ childrenD_619_i0 j := by decide +kernel +theorem required_exact_619_i0 : required_619_i0 = + ((Finset.univ.biUnion childrenC_619_i0) ∪ commonEnvelope childrenD_619_i0).erase (2, 2) := by + exact required_eq_combination childrenC_619_i0 childrenD_619_i0 (2, 2) required_619_i0 + (by decide +kernel) child_required_sub_619_i0 common_sub_619_i0 required_origin_619_i0 +theorem envelope_origin_619_i0 : ∀ x ∈ envelope_619_i0, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_619_i0 j := by decide +kernel +theorem envelope_exact_619_i0 : envelope_619_i0 = + insert (2, 2) (Finset.univ.biUnion childrenD_619_i0) := by + exact envelope_eq_combination childrenD_619_i0 (2, 2) envelope_619_i0 + pivot_mem_619_i0 child_envelope_sub_619_i0 envelope_origin_619_i0 +def checked_619_i0 : CheckedCard where + required := required_619_i0 + envelope := envelope_619_i0 + height := height_619_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_619_i0 +def height_619 : ℕ := 8 +def childrenH_619 : Fin 6 → ℕ := ![height_8, height_26, height_49, height_115, height_292, height_619_i0] +theorem height_exact_619 : height_619 = 1 + Finset.univ.sup childrenH_619 := by decide +kernel +theorem required_origin_619 : ∀ x ∈ required_619, + (∃ j, x ∈ childrenC_619 j) ∨ ∀ j, x ∈ childrenD_619 j := by decide +kernel +theorem required_exact_619 : required_619 = + ((Finset.univ.biUnion childrenC_619) ∪ commonEnvelope childrenD_619).erase (4, 3) := by + exact required_eq_combination childrenC_619 childrenD_619 (4, 3) required_619 + (by decide +kernel) child_required_sub_619 common_sub_619 required_origin_619 +theorem envelope_origin_619 : ∀ x ∈ envelope_619, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_619 j := by decide +kernel +theorem envelope_exact_619 : envelope_619 = + insert (4, 3) (Finset.univ.biUnion childrenD_619) := by + exact envelope_eq_combination childrenD_619 (4, 3) envelope_619 + pivot_mem_619 child_envelope_sub_619 envelope_origin_619 +def checked_619 : CheckedCard where + required := required_619 + envelope := envelope_619 + height := height_619 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_619 +def height_651_i0 : ℕ := 5 +def childrenH_651_i0 : Fin 2 → ℕ := ![height_55, height_56] +theorem height_exact_651_i0 : height_651_i0 = 1 + Finset.univ.sup childrenH_651_i0 := by decide +kernel +theorem required_origin_651_i0 : ∀ x ∈ required_651_i0, + (∃ j, x ∈ childrenC_651_i0 j) ∨ ∀ j, x ∈ childrenD_651_i0 j := by decide +kernel +theorem required_exact_651_i0 : required_651_i0 = + ((Finset.univ.biUnion childrenC_651_i0) ∪ commonEnvelope childrenD_651_i0).erase (3, 5) := by + exact required_eq_combination childrenC_651_i0 childrenD_651_i0 (3, 5) required_651_i0 + (by decide +kernel) child_required_sub_651_i0 common_sub_651_i0 required_origin_651_i0 +theorem envelope_origin_651_i0 : ∀ x ∈ envelope_651_i0, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_651_i0 j := by decide +kernel +theorem envelope_exact_651_i0 : envelope_651_i0 = + insert (3, 5) (Finset.univ.biUnion childrenD_651_i0) := by + exact envelope_eq_combination childrenD_651_i0 (3, 5) envelope_651_i0 + pivot_mem_651_i0 child_envelope_sub_651_i0 envelope_origin_651_i0 +def checked_651_i0 : CheckedCard where + required := required_651_i0 + envelope := envelope_651_i0 + height := height_651_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_651_i0 +def height_651_i1 : ℕ := 5 +def childrenH_651_i1 : Fin 3 → ℕ := ![height_20, height_29, height_46] +theorem height_exact_651_i1 : height_651_i1 = 1 + Finset.univ.sup childrenH_651_i1 := by decide +kernel +theorem required_origin_651_i1 : ∀ x ∈ required_651_i1, + (∃ j, x ∈ childrenC_651_i1 j) ∨ ∀ j, x ∈ childrenD_651_i1 j := by decide +kernel +theorem required_exact_651_i1 : required_651_i1 = + ((Finset.univ.biUnion childrenC_651_i1) ∪ commonEnvelope childrenD_651_i1).erase (3, 5) := by + exact required_eq_combination childrenC_651_i1 childrenD_651_i1 (3, 5) required_651_i1 + (by decide +kernel) child_required_sub_651_i1 common_sub_651_i1 required_origin_651_i1 +theorem envelope_origin_651_i1 : ∀ x ∈ envelope_651_i1, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_651_i1 j := by decide +kernel +theorem envelope_exact_651_i1 : envelope_651_i1 = + insert (3, 5) (Finset.univ.biUnion childrenD_651_i1) := by + exact envelope_eq_combination childrenD_651_i1 (3, 5) envelope_651_i1 + pivot_mem_651_i1 child_envelope_sub_651_i1 envelope_origin_651_i1 +def checked_651_i1 : CheckedCard where + required := required_651_i1 + envelope := envelope_651_i1 + height := height_651_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_651_i1 +def height_651_i2 : ℕ := 7 +def childrenH_651_i2 : Fin 2 → ℕ := ![height_85, height_94] +theorem height_exact_651_i2 : height_651_i2 = 1 + Finset.univ.sup childrenH_651_i2 := by decide +kernel +theorem required_origin_651_i2 : ∀ x ∈ required_651_i2, + (∃ j, x ∈ childrenC_651_i2 j) ∨ ∀ j, x ∈ childrenD_651_i2 j := by decide +kernel +theorem required_exact_651_i2 : required_651_i2 = + ((Finset.univ.biUnion childrenC_651_i2) ∪ commonEnvelope childrenD_651_i2).erase (4, 3) := by + exact required_eq_combination childrenC_651_i2 childrenD_651_i2 (4, 3) required_651_i2 + (by decide +kernel) child_required_sub_651_i2 common_sub_651_i2 required_origin_651_i2 +theorem envelope_origin_651_i2 : ∀ x ∈ envelope_651_i2, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_651_i2 j := by decide +kernel +theorem envelope_exact_651_i2 : envelope_651_i2 = + insert (4, 3) (Finset.univ.biUnion childrenD_651_i2) := by + exact envelope_eq_combination childrenD_651_i2 (4, 3) envelope_651_i2 + pivot_mem_651_i2 child_envelope_sub_651_i2 envelope_origin_651_i2 +def checked_651_i2 : CheckedCard where + required := required_651_i2 + envelope := envelope_651_i2 + height := height_651_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_651_i2 +def height_651 : ℕ := 8 +def childrenH_651 : Fin 3 → ℕ := ![height_651_i0, height_651_i1, height_651_i2] +theorem height_exact_651 : height_651 = 1 + Finset.univ.sup childrenH_651 := by decide +kernel +theorem required_origin_651 : ∀ x ∈ required_651, + (∃ j, x ∈ childrenC_651 j) ∨ ∀ j, x ∈ childrenD_651 j := by decide +kernel +theorem required_exact_651 : required_651 = + ((Finset.univ.biUnion childrenC_651) ∪ commonEnvelope childrenD_651).erase (3, 6) := by + exact required_eq_combination childrenC_651 childrenD_651 (3, 6) required_651 + (by decide +kernel) child_required_sub_651 common_sub_651 required_origin_651 +theorem envelope_origin_651 : ∀ x ∈ envelope_651, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_651 j := by decide +kernel +theorem envelope_exact_651 : envelope_651 = + insert (3, 6) (Finset.univ.biUnion childrenD_651) := by + exact envelope_eq_combination childrenD_651 (3, 6) envelope_651 + pivot_mem_651 child_envelope_sub_651 envelope_origin_651 +def checked_651 : CheckedCard where + required := required_651 + envelope := envelope_651 + height := height_651 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_651 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part05.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part05.lean new file mode 100644 index 0000000..cea1ec3 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part05.lean @@ -0,0 +1,904 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_658_i0 : Finset Cell := ⟨(([(0, 4), (1, 5), (2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_658_i0 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 2), (3, 3), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_658_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 3) required_314), (placed21 3 (0, 6) required_378)] +def childrenD_658_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 3) envelope_314), (placed21 3 (0, 6) envelope_378)] +theorem common_sub_658_i0 : commonEnvelope childrenD_658_i0 ⊆ insert (2, 6) required_658_i0 := by decide +kernel +theorem child_required_sub_658_i0 : ∀ j, childrenC_658_i0 j ⊆ insert (2, 6) required_658_i0 := by decide +kernel +theorem child_envelope_sub_658_i0 : ∀ j, childrenD_658_i0 j ⊆ envelope_658_i0 := by decide +kernel +theorem pivot_mem_658_i0 : (2, 6) ∈ envelope_658_i0 := by decide +kernel +theorem children_work_658_i0 : ∀ j, Template HasSnaky 6 (childrenC_658_i0 j) (childrenD_658_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_314 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_378 3 (0, 6)).mono (by decide +kernel) +theorem row_works_658_i0 : Template HasSnaky 7 required_658_i0 envelope_658_i0 := by + refine compose HasSnaky 6 childrenC_658_i0 childrenD_658_i0 children_work_658_i0 (2, 6) + required_658_i0 envelope_658_i0 pivot_mem_658_i0 child_required_sub_658_i0 child_envelope_sub_658_i0 ?_ + intro b hb + exact common_sub_658_i0 (mem_commonEnvelope childrenD_658_i0 b hb) +def required_658 : Finset Cell := ⟨(([(0, 4), (1, 5), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_658 : Finset Cell := ⟨(([(0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_658 : Fin 4 → Finset Cell := ![(placed21 6 (2, 6) required_27), (placed21 2 (2, 2) required_52), (placed21 4 (1, 9) required_284), required_658_i0] +def childrenD_658 : Fin 4 → Finset Cell := ![(placed21 6 (2, 6) envelope_27), (placed21 2 (2, 2) envelope_52), (placed21 4 (1, 9) envelope_284), envelope_658_i0] +theorem common_sub_658 : commonEnvelope childrenD_658 ⊆ insert (2, 3) required_658 := by decide +kernel +theorem child_required_sub_658 : ∀ j, childrenC_658 j ⊆ insert (2, 3) required_658 := by decide +kernel +theorem child_envelope_sub_658 : ∀ j, childrenD_658 j ⊆ envelope_658 := by decide +kernel +theorem pivot_mem_658 : (2, 3) ∈ envelope_658 := by decide +kernel +theorem children_work_658 : ∀ j, Template HasSnaky 7 (childrenC_658 j) (childrenD_658 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_27 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_284 4 (1, 9)).mono (by decide +kernel) + · exact row_works_658_i0.mono (by decide +kernel) +theorem row_works_658 : Template HasSnaky 8 required_658 envelope_658 := by + refine compose HasSnaky 7 childrenC_658 childrenD_658 children_work_658 (2, 3) + required_658 envelope_658 pivot_mem_658 child_required_sub_658 child_envelope_sub_658 ?_ + intro b hb + exact common_sub_658 (mem_commonEnvelope childrenD_658 b hb) +def required_661_i0 : Finset Cell := ⟨(([(4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_661_i0 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_661_i0 : Fin 4 → Finset Cell := ![(placed21 6 (5, 7) required_9), (placed21 7 (7, 6) required_115), (placed21 7 (7, 7) required_302), (placed21 7 (7, 7) required_303)] +def childrenD_661_i0 : Fin 4 → Finset Cell := ![(placed21 6 (5, 7) envelope_9), (placed21 7 (7, 6) envelope_115), (placed21 7 (7, 7) envelope_302), (placed21 7 (7, 7) envelope_303)] +theorem common_sub_661_i0 : commonEnvelope childrenD_661_i0 ⊆ insert (4, 3) required_661_i0 := by decide +kernel +theorem child_required_sub_661_i0 : ∀ j, childrenC_661_i0 j ⊆ insert (4, 3) required_661_i0 := by decide +kernel +theorem child_envelope_sub_661_i0 : ∀ j, childrenD_661_i0 j ⊆ envelope_661_i0 := by decide +kernel +theorem pivot_mem_661_i0 : (4, 3) ∈ envelope_661_i0 := by decide +kernel +theorem children_work_661_i0 : ∀ j, Template HasSnaky 6 (childrenC_661_i0 j) (childrenD_661_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_115 7 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_302 7 (7, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_303 7 (7, 7)).mono (by decide +kernel) +theorem row_works_661_i0 : Template HasSnaky 7 required_661_i0 envelope_661_i0 := by + refine compose HasSnaky 6 childrenC_661_i0 childrenD_661_i0 children_work_661_i0 (4, 3) + required_661_i0 envelope_661_i0 pivot_mem_661_i0 child_required_sub_661_i0 child_envelope_sub_661_i0 ?_ + intro b hb + exact common_sub_661_i0 (mem_commonEnvelope childrenD_661_i0 b hb) +def required_661 : Finset Cell := ⟨(([(4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_661 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5), (8, 3), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_661 : Fin 5 → Finset Cell := ![(placed21 0 (3, 2) required_13), (placed21 2 (5, 2) required_14), (placed21 0 (3, 2) required_33), (placed21 1 (1, 3) required_116), required_661_i0] +def childrenD_661 : Fin 5 → Finset Cell := ![(placed21 0 (3, 2) envelope_13), (placed21 2 (5, 2) envelope_14), (placed21 0 (3, 2) envelope_33), (placed21 1 (1, 3) envelope_116), envelope_661_i0] +theorem common_sub_661 : commonEnvelope childrenD_661 ⊆ insert (4, 6) required_661 := by decide +kernel +theorem child_required_sub_661 : ∀ j, childrenC_661 j ⊆ insert (4, 6) required_661 := by decide +kernel +theorem child_envelope_sub_661 : ∀ j, childrenD_661 j ⊆ envelope_661 := by decide +kernel +theorem pivot_mem_661 : (4, 6) ∈ envelope_661 := by decide +kernel +theorem children_work_661 : ∀ j, Template HasSnaky 7 (childrenC_661 j) (childrenD_661 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_14 2 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_33 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_116 1 (1, 3)).mono (by decide +kernel) + · exact row_works_661_i0.mono (by decide +kernel) +theorem row_works_661 : Template HasSnaky 8 required_661 envelope_661 := by + refine compose HasSnaky 7 childrenC_661 childrenD_661 children_work_661 (4, 6) + required_661 envelope_661 pivot_mem_661 child_required_sub_661 child_envelope_sub_661 ?_ + intro b hb + exact common_sub_661 (mem_commonEnvelope childrenD_661 b hb) +def required_666_i1 : Finset Cell := ⟨(([(0, 2), (2, 3), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_666_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 3), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_666_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) required_4), (placed21 0 (1, 2) required_314)] +def childrenD_666_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 3) envelope_4), (placed21 0 (1, 2) envelope_314)] +theorem common_sub_666_i1 : commonEnvelope childrenD_666_i1 ⊆ insert (1, 3) required_666_i1 := by decide +kernel +theorem child_required_sub_666_i1 : ∀ j, childrenC_666_i1 j ⊆ insert (1, 3) required_666_i1 := by decide +kernel +theorem child_envelope_sub_666_i1 : ∀ j, childrenD_666_i1 j ⊆ envelope_666_i1 := by decide +kernel +theorem pivot_mem_666_i1 : (1, 3) ∈ envelope_666_i1 := by decide +kernel +theorem children_work_666_i1 : ∀ j, Template HasSnaky 5 (childrenC_666_i1 j) (childrenD_666_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 6 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_314 0 (1, 2)).mono (by decide +kernel) +theorem row_works_666_i1 : Template HasSnaky 6 required_666_i1 envelope_666_i1 := by + refine compose HasSnaky 5 childrenC_666_i1 childrenD_666_i1 children_work_666_i1 (1, 3) + required_666_i1 envelope_666_i1 pivot_mem_666_i1 child_required_sub_666_i1 child_envelope_sub_666_i1 ?_ + intro b hb + exact common_sub_666_i1 (mem_commonEnvelope childrenD_666_i1 b hb) +def required_666_i0 : Finset Cell := ⟨(([(0, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_666_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_666_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 0) required_5), required_666_i1] +def childrenD_666_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 0) envelope_5), envelope_666_i1] +theorem common_sub_666_i0 : commonEnvelope childrenD_666_i0 ⊆ insert (4, 3) required_666_i0 := by decide +kernel +theorem child_required_sub_666_i0 : ∀ j, childrenC_666_i0 j ⊆ insert (4, 3) required_666_i0 := by decide +kernel +theorem child_envelope_sub_666_i0 : ∀ j, childrenD_666_i0 j ⊆ envelope_666_i0 := by decide +kernel +theorem pivot_mem_666_i0 : (4, 3) ∈ envelope_666_i0 := by decide +kernel +theorem children_work_666_i0 : ∀ j, Template HasSnaky 6 (childrenC_666_i0 j) (childrenD_666_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 0)).mono (by decide +kernel) + · exact row_works_666_i1.mono (by decide +kernel) +theorem row_works_666_i0 : Template HasSnaky 7 required_666_i0 envelope_666_i0 := by + refine compose HasSnaky 6 childrenC_666_i0 childrenD_666_i0 children_work_666_i0 (4, 3) + required_666_i0 envelope_666_i0 pivot_mem_666_i0 child_required_sub_666_i0 child_envelope_sub_666_i0 ?_ + intro b hb + exact common_sub_666_i0 (mem_commonEnvelope childrenD_666_i0 b hb) +def required_666 : Finset Cell := ⟨(([(0, 2), (3, 0), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_666 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_666 : Fin 2 → Finset Cell := ![(placed21 5 (3, 0) required_5), required_666_i0] +def childrenD_666 : Fin 2 → Finset Cell := ![(placed21 5 (3, 0) envelope_5), envelope_666_i0] +theorem common_sub_666 : commonEnvelope childrenD_666 ⊆ insert (2, 3) required_666 := by decide +kernel +theorem child_required_sub_666 : ∀ j, childrenC_666 j ⊆ insert (2, 3) required_666 := by decide +kernel +theorem child_envelope_sub_666 : ∀ j, childrenD_666 j ⊆ envelope_666 := by decide +kernel +theorem pivot_mem_666 : (2, 3) ∈ envelope_666 := by decide +kernel +theorem children_work_666 : ∀ j, Template HasSnaky 7 (childrenC_666 j) (childrenD_666 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (3, 0)).mono (by decide +kernel) + · exact row_works_666_i0.mono (by decide +kernel) +theorem row_works_666 : Template HasSnaky 8 required_666 envelope_666 := by + refine compose HasSnaky 7 childrenC_666 childrenD_666 children_work_666 (2, 3) + required_666 envelope_666 pivot_mem_666 child_required_sub_666 child_envelope_sub_666 ?_ + intro b hb + exact common_sub_666 (mem_commonEnvelope childrenD_666 b hb) +def required_678_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 6), (3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_678_i1 : Finset Cell := ⟨(([(0, 4), (0, 6), (0, 7), (0, 8), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 4), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 6), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_678_i1 : Fin 2 → Finset Cell := ![(placed21 7 (5, 4) required_22), (placed21 2 (4, 2) required_382)] +def childrenD_678_i1 : Fin 2 → Finset Cell := ![(placed21 7 (5, 4) envelope_22), (placed21 2 (4, 2) envelope_382)] +theorem common_sub_678_i1 : commonEnvelope childrenD_678_i1 ⊆ insert (4, 3) required_678_i1 := by decide +kernel +theorem child_required_sub_678_i1 : ∀ j, childrenC_678_i1 j ⊆ insert (4, 3) required_678_i1 := by decide +kernel +theorem child_envelope_sub_678_i1 : ∀ j, childrenD_678_i1 j ⊆ envelope_678_i1 := by decide +kernel +theorem pivot_mem_678_i1 : (4, 3) ∈ envelope_678_i1 := by decide +kernel +theorem children_work_678_i1 : ∀ j, Template HasSnaky 5 (childrenC_678_i1 j) (childrenD_678_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 7 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_382 2 (4, 2)).mono (by decide +kernel) +theorem row_works_678_i1 : Template HasSnaky 6 required_678_i1 envelope_678_i1 := by + refine compose HasSnaky 5 childrenC_678_i1 childrenD_678_i1 children_work_678_i1 (4, 3) + required_678_i1 envelope_678_i1 pivot_mem_678_i1 child_required_sub_678_i1 child_envelope_sub_678_i1 ?_ + intro b hb + exact common_sub_678_i1 (mem_commonEnvelope childrenD_678_i1 b hb) +def required_678_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_678_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 6), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_678_i0 : Fin 2 → Finset Cell := ![(placed21 6 (2, 6) required_18), required_678_i1] +def childrenD_678_i0 : Fin 2 → Finset Cell := ![(placed21 6 (2, 6) envelope_18), envelope_678_i1] +theorem common_sub_678_i0 : commonEnvelope childrenD_678_i0 ⊆ insert (2, 6) required_678_i0 := by decide +kernel +theorem child_required_sub_678_i0 : ∀ j, childrenC_678_i0 j ⊆ insert (2, 6) required_678_i0 := by decide +kernel +theorem child_envelope_sub_678_i0 : ∀ j, childrenD_678_i0 j ⊆ envelope_678_i0 := by decide +kernel +theorem pivot_mem_678_i0 : (2, 6) ∈ envelope_678_i0 := by decide +kernel +theorem children_work_678_i0 : ∀ j, Template HasSnaky 6 (childrenC_678_i0 j) (childrenD_678_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 6 (2, 6)).mono (by decide +kernel) + · exact row_works_678_i1.mono (by decide +kernel) +theorem row_works_678_i0 : Template HasSnaky 7 required_678_i0 envelope_678_i0 := by + refine compose HasSnaky 6 childrenC_678_i0 childrenD_678_i0 children_work_678_i0 (2, 6) + required_678_i0 envelope_678_i0 pivot_mem_678_i0 child_required_sub_678_i0 child_envelope_sub_678_i0 ?_ + intro b hb + exact common_sub_678_i0 (mem_commonEnvelope childrenD_678_i0 b hb) +def required_678 : Finset Cell := ⟨(([(1, 3), (1, 4), (3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_678 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 6), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_678 : Fin 3 → Finset Cell := ![(placed21 4 (0, 7) required_31), (placed21 3 (0, 5) required_160), required_678_i0] +def childrenD_678 : Fin 3 → Finset Cell := ![(placed21 4 (0, 7) envelope_31), (placed21 3 (0, 5) envelope_160), envelope_678_i0] +theorem common_sub_678 : commonEnvelope childrenD_678 ⊆ insert (1, 5) required_678 := by decide +kernel +theorem child_required_sub_678 : ∀ j, childrenC_678 j ⊆ insert (1, 5) required_678 := by decide +kernel +theorem child_envelope_sub_678 : ∀ j, childrenD_678 j ⊆ envelope_678 := by decide +kernel +theorem pivot_mem_678 : (1, 5) ∈ envelope_678 := by decide +kernel +theorem children_work_678 : ∀ j, Template HasSnaky 7 (childrenC_678 j) (childrenD_678 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_31 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_160 3 (0, 5)).mono (by decide +kernel) + · exact row_works_678_i0.mono (by decide +kernel) +theorem row_works_678 : Template HasSnaky 8 required_678 envelope_678 := by + refine compose HasSnaky 7 childrenC_678 childrenD_678 children_work_678 (1, 5) + required_678 envelope_678 pivot_mem_678 child_required_sub_678 child_envelope_sub_678 ?_ + intro b hb + exact common_sub_678 (mem_commonEnvelope childrenD_678 b hb) +def required_703_i1 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 3), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703_i1 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 3), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703_i1 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) required_3), (placed21 0 (4, 2) required_27)] +def childrenD_703_i1 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) envelope_3), (placed21 0 (4, 2) envelope_27)] +theorem common_sub_703_i1 : commonEnvelope childrenD_703_i1 ⊆ insert (5, 3) required_703_i1 := by decide +kernel +theorem child_required_sub_703_i1 : ∀ j, childrenC_703_i1 j ⊆ insert (5, 3) required_703_i1 := by decide +kernel +theorem child_envelope_sub_703_i1 : ∀ j, childrenD_703_i1 j ⊆ envelope_703_i1 := by decide +kernel +theorem pivot_mem_703_i1 : (5, 3) ∈ envelope_703_i1 := by decide +kernel +theorem children_work_703_i1 : ∀ j, Template HasSnaky 4 (childrenC_703_i1 j) (childrenD_703_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 2 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_27 0 (4, 2)).mono (by decide +kernel) +theorem row_works_703_i1 : Template HasSnaky 5 required_703_i1 envelope_703_i1 := by + refine compose HasSnaky 4 childrenC_703_i1 childrenD_703_i1 children_work_703_i1 (5, 3) + required_703_i1 envelope_703_i1 pivot_mem_703_i1 child_required_sub_703_i1 child_envelope_sub_703_i1 ?_ + intro b hb + exact common_sub_703_i1 (mem_commonEnvelope childrenD_703_i1 b hb) +def required_703_i2 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703_i2 : Finset Cell := ⟨(([(1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703_i2 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) required_0), (placed21 4 (2, 6) required_52)] +def childrenD_703_i2 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) envelope_0), (placed21 4 (2, 6) envelope_52)] +theorem common_sub_703_i2 : commonEnvelope childrenD_703_i2 ⊆ insert (2, 3) required_703_i2 := by decide +kernel +theorem child_required_sub_703_i2 : ∀ j, childrenC_703_i2 j ⊆ insert (2, 3) required_703_i2 := by decide +kernel +theorem child_envelope_sub_703_i2 : ∀ j, childrenD_703_i2 j ⊆ envelope_703_i2 := by decide +kernel +theorem pivot_mem_703_i2 : (2, 3) ∈ envelope_703_i2 := by decide +kernel +theorem children_work_703_i2 : ∀ j, Template HasSnaky 3 (childrenC_703_i2 j) (childrenD_703_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_52 4 (2, 6)).mono (by decide +kernel) +theorem row_works_703_i2 : Template HasSnaky 4 required_703_i2 envelope_703_i2 := by + refine compose HasSnaky 3 childrenC_703_i2 childrenD_703_i2 children_work_703_i2 (2, 3) + required_703_i2 envelope_703_i2 pivot_mem_703_i2 child_required_sub_703_i2 child_envelope_sub_703_i2 ?_ + intro b hb + exact common_sub_703_i2 (mem_commonEnvelope childrenD_703_i2 b hb) +def required_703_i3 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 3), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703_i3 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 6) required_0), (placed21 4 (2, 6) required_101)] +def childrenD_703_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 6) envelope_0), (placed21 4 (2, 6) envelope_101)] +theorem common_sub_703_i3 : commonEnvelope childrenD_703_i3 ⊆ insert (3, 2) required_703_i3 := by decide +kernel +theorem child_required_sub_703_i3 : ∀ j, childrenC_703_i3 j ⊆ insert (3, 2) required_703_i3 := by decide +kernel +theorem child_envelope_sub_703_i3 : ∀ j, childrenD_703_i3 j ⊆ envelope_703_i3 := by decide +kernel +theorem pivot_mem_703_i3 : (3, 2) ∈ envelope_703_i3 := by decide +kernel +theorem children_work_703_i3 : ∀ j, Template HasSnaky 3 (childrenC_703_i3 j) (childrenD_703_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_101 4 (2, 6)).mono (by decide +kernel) +theorem row_works_703_i3 : Template HasSnaky 4 required_703_i3 envelope_703_i3 := by + refine compose HasSnaky 3 childrenC_703_i3 childrenD_703_i3 children_work_703_i3 (3, 2) + required_703_i3 envelope_703_i3 pivot_mem_703_i3 child_required_sub_703_i3 child_envelope_sub_703_i3 ?_ + intro b hb + exact common_sub_703_i3 (mem_commonEnvelope childrenD_703_i3 b hb) +def required_703_i0 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703_i0 : Finset Cell := ⟨(([(1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703_i0 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) required_195), required_703_i1, required_703_i2, required_703_i3] +def childrenD_703_i0 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) envelope_195), envelope_703_i1, envelope_703_i2, envelope_703_i3] +theorem common_sub_703_i0 : commonEnvelope childrenD_703_i0 ⊆ insert (3, 3) required_703_i0 := by decide +kernel +theorem child_required_sub_703_i0 : ∀ j, childrenC_703_i0 j ⊆ insert (3, 3) required_703_i0 := by decide +kernel +theorem child_envelope_sub_703_i0 : ∀ j, childrenD_703_i0 j ⊆ envelope_703_i0 := by decide +kernel +theorem pivot_mem_703_i0 : (3, 3) ∈ envelope_703_i0 := by decide +kernel +theorem children_work_703_i0 : ∀ j, Template HasSnaky 5 (childrenC_703_i0 j) (childrenD_703_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_195 0 (3, 2)).mono (by decide +kernel) + · exact row_works_703_i1.mono (by decide +kernel) + · exact row_works_703_i2.mono (by decide +kernel) + · exact row_works_703_i3.mono (by decide +kernel) +theorem row_works_703_i0 : Template HasSnaky 6 required_703_i0 envelope_703_i0 := by + refine compose HasSnaky 5 childrenC_703_i0 childrenD_703_i0 children_work_703_i0 (3, 3) + required_703_i0 envelope_703_i0 pivot_mem_703_i0 child_required_sub_703_i0 child_envelope_sub_703_i0 ?_ + intro b hb + exact common_sub_703_i0 (mem_commonEnvelope childrenD_703_i0 b hb) +def required_703_i7 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 2), (4, 2), (4, 3), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703_i7 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703_i7 : Fin 3 → Finset Cell := ![(placed21 5 (6, 2) required_11), (placed21 1 (2, 2) required_103), (placed21 2 (5, 1) required_157)] +def childrenD_703_i7 : Fin 3 → Finset Cell := ![(placed21 5 (6, 2) envelope_11), (placed21 1 (2, 2) envelope_103), (placed21 2 (5, 1) envelope_157)] +theorem common_sub_703_i7 : commonEnvelope childrenD_703_i7 ⊆ insert (2, 2) required_703_i7 := by decide +kernel +theorem child_required_sub_703_i7 : ∀ j, childrenC_703_i7 j ⊆ insert (2, 2) required_703_i7 := by decide +kernel +theorem child_envelope_sub_703_i7 : ∀ j, childrenD_703_i7 j ⊆ envelope_703_i7 := by decide +kernel +theorem pivot_mem_703_i7 : (2, 2) ∈ envelope_703_i7 := by decide +kernel +theorem children_work_703_i7 : ∀ j, Template HasSnaky 3 (childrenC_703_i7 j) (childrenD_703_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 5 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_103 1 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_157 2 (5, 1)).mono (by decide +kernel) +theorem row_works_703_i7 : Template HasSnaky 4 required_703_i7 envelope_703_i7 := by + refine compose HasSnaky 3 childrenC_703_i7 childrenD_703_i7 children_work_703_i7 (2, 2) + required_703_i7 envelope_703_i7 pivot_mem_703_i7 child_required_sub_703_i7 child_envelope_sub_703_i7 ?_ + intro b hb + exact common_sub_703_i7 (mem_commonEnvelope childrenD_703_i7 b hb) +def required_703_i6 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 2), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703_i6 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703_i6 : Fin 2 → Finset Cell := ![(placed21 3 (4, 5) required_5), required_703_i7] +def childrenD_703_i6 : Fin 2 → Finset Cell := ![(placed21 3 (4, 5) envelope_5), envelope_703_i7] +theorem common_sub_703_i6 : commonEnvelope childrenD_703_i6 ⊆ insert (5, 2) required_703_i6 := by decide +kernel +theorem child_required_sub_703_i6 : ∀ j, childrenC_703_i6 j ⊆ insert (5, 2) required_703_i6 := by decide +kernel +theorem child_envelope_sub_703_i6 : ∀ j, childrenD_703_i6 j ⊆ envelope_703_i6 := by decide +kernel +theorem pivot_mem_703_i6 : (5, 2) ∈ envelope_703_i6 := by decide +kernel +theorem children_work_703_i6 : ∀ j, Template HasSnaky 4 (childrenC_703_i6 j) (childrenD_703_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (4, 5)).mono (by decide +kernel) + · exact row_works_703_i7.mono (by decide +kernel) +theorem row_works_703_i6 : Template HasSnaky 5 required_703_i6 envelope_703_i6 := by + refine compose HasSnaky 4 childrenC_703_i6 childrenD_703_i6 children_work_703_i6 (5, 2) + required_703_i6 envelope_703_i6 pivot_mem_703_i6 child_required_sub_703_i6 child_envelope_sub_703_i6 ?_ + intro b hb + exact common_sub_703_i6 (mem_commonEnvelope childrenD_703_i6 b hb) +def required_703_i5 : Finset Cell := ⟨(([(2, 4), (2, 5), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703_i5 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703_i5 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) required_5), required_703_i6] +def childrenD_703_i5 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) envelope_5), envelope_703_i6] +theorem common_sub_703_i5 : commonEnvelope childrenD_703_i5 ⊆ insert (3, 2) required_703_i5 := by decide +kernel +theorem child_required_sub_703_i5 : ∀ j, childrenC_703_i5 j ⊆ insert (3, 2) required_703_i5 := by decide +kernel +theorem child_envelope_sub_703_i5 : ∀ j, childrenD_703_i5 j ⊆ envelope_703_i5 := by decide +kernel +theorem pivot_mem_703_i5 : (3, 2) ∈ envelope_703_i5 := by decide +kernel +theorem children_work_703_i5 : ∀ j, Template HasSnaky 5 (childrenC_703_i5 j) (childrenD_703_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (4, 5)).mono (by decide +kernel) + · exact row_works_703_i6.mono (by decide +kernel) +theorem row_works_703_i5 : Template HasSnaky 6 required_703_i5 envelope_703_i5 := by + refine compose HasSnaky 5 childrenC_703_i5 childrenD_703_i5 children_work_703_i5 (3, 2) + required_703_i5 envelope_703_i5 pivot_mem_703_i5 child_required_sub_703_i5 child_envelope_sub_703_i5 ?_ + intro b hb + exact common_sub_703_i5 (mem_commonEnvelope childrenD_703_i5 b hb) +def required_703_i4 : Finset Cell := ⟨(([(2, 4), (2, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703_i4 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703_i4 : Fin 3 → Finset Cell := ![(placed21 4 (4, 6) required_7), (placed21 6 (5, 6) required_9), required_703_i5] +def childrenD_703_i4 : Fin 3 → Finset Cell := ![(placed21 4 (4, 6) envelope_7), (placed21 6 (5, 6) envelope_9), envelope_703_i5] +theorem common_sub_703_i4 : commonEnvelope childrenD_703_i4 ⊆ insert (4, 2) required_703_i4 := by decide +kernel +theorem child_required_sub_703_i4 : ∀ j, childrenC_703_i4 j ⊆ insert (4, 2) required_703_i4 := by decide +kernel +theorem child_envelope_sub_703_i4 : ∀ j, childrenD_703_i4 j ⊆ envelope_703_i4 := by decide +kernel +theorem pivot_mem_703_i4 : (4, 2) ∈ envelope_703_i4 := by decide +kernel +theorem children_work_703_i4 : ∀ j, Template HasSnaky 6 (childrenC_703_i4 j) (childrenD_703_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_9 6 (5, 6)).mono (by decide +kernel) + · exact row_works_703_i5.mono (by decide +kernel) +theorem row_works_703_i4 : Template HasSnaky 7 required_703_i4 envelope_703_i4 := by + refine compose HasSnaky 6 childrenC_703_i4 childrenD_703_i4 children_work_703_i4 (4, 2) + required_703_i4 envelope_703_i4 pivot_mem_703_i4 child_required_sub_703_i4 child_envelope_sub_703_i4 ?_ + intro b hb + exact common_sub_703_i4 (mem_commonEnvelope childrenD_703_i4 b hb) +def required_703_i9 : Finset Cell := ⟨(([(1, 4), (2, 4), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703_i9 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 2), (3, 3), (3, 7), (3, 8), (3, 9), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703_i9 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) required_18), (placed21 2 (5, 2) required_77)] +def childrenD_703_i9 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) envelope_18), (placed21 2 (5, 2) envelope_77)] +theorem common_sub_703_i9 : commonEnvelope childrenD_703_i9 ⊆ insert (5, 3) required_703_i9 := by decide +kernel +theorem child_required_sub_703_i9 : ∀ j, childrenC_703_i9 j ⊆ insert (5, 3) required_703_i9 := by decide +kernel +theorem child_envelope_sub_703_i9 : ∀ j, childrenD_703_i9 j ⊆ envelope_703_i9 := by decide +kernel +theorem pivot_mem_703_i9 : (5, 3) ∈ envelope_703_i9 := by decide +kernel +theorem children_work_703_i9 : ∀ j, Template HasSnaky 4 (childrenC_703_i9 j) (childrenD_703_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 2 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_77 2 (5, 2)).mono (by decide +kernel) +theorem row_works_703_i9 : Template HasSnaky 5 required_703_i9 envelope_703_i9 := by + refine compose HasSnaky 4 childrenC_703_i9 childrenD_703_i9 children_work_703_i9 (5, 3) + required_703_i9 envelope_703_i9 pivot_mem_703_i9 child_required_sub_703_i9 child_envelope_sub_703_i9 ?_ + intro b hb + exact common_sub_703_i9 (mem_commonEnvelope childrenD_703_i9 b hb) +def required_703_i8 : Finset Cell := ⟨(([(1, 4), (2, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703_i8 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703_i8 : Fin 4 → Finset Cell := ![(placed21 6 (5, 7) required_9), (placed21 5 (5, 3) required_49), (placed21 0 (3, 1) required_186), required_703_i9] +def childrenD_703_i8 : Fin 4 → Finset Cell := ![(placed21 6 (5, 7) envelope_9), (placed21 5 (5, 3) envelope_49), (placed21 0 (3, 1) envelope_186), envelope_703_i9] +theorem common_sub_703_i8 : commonEnvelope childrenD_703_i8 ⊆ insert (4, 6) required_703_i8 := by decide +kernel +theorem child_required_sub_703_i8 : ∀ j, childrenC_703_i8 j ⊆ insert (4, 6) required_703_i8 := by decide +kernel +theorem child_envelope_sub_703_i8 : ∀ j, childrenD_703_i8 j ⊆ envelope_703_i8 := by decide +kernel +theorem pivot_mem_703_i8 : (4, 6) ∈ envelope_703_i8 := by decide +kernel +theorem children_work_703_i8 : ∀ j, Template HasSnaky 5 (childrenC_703_i8 j) (childrenD_703_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_49 5 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_186 0 (3, 1)).mono (by decide +kernel) + · exact row_works_703_i9.mono (by decide +kernel) +theorem row_works_703_i8 : Template HasSnaky 6 required_703_i8 envelope_703_i8 := by + refine compose HasSnaky 5 childrenC_703_i8 childrenD_703_i8 children_work_703_i8 (4, 6) + required_703_i8 envelope_703_i8 pivot_mem_703_i8 child_required_sub_703_i8 child_envelope_sub_703_i8 ?_ + intro b hb + exact common_sub_703_i8 (mem_commonEnvelope childrenD_703_i8 b hb) +def required_703 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (2, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_703 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_703 : Fin 6 → Finset Cell := ![(placed21 6 (5, 7) required_13), (placed21 2 (5, 0) required_369), required_703_i0, (placed21 4 (1, 6) required_516), required_703_i4, required_703_i8] +def childrenD_703 : Fin 6 → Finset Cell := ![(placed21 6 (5, 7) envelope_13), (placed21 2 (5, 0) envelope_369), envelope_703_i0, (placed21 4 (1, 6) envelope_516), envelope_703_i4, envelope_703_i8] +theorem common_sub_703 : commonEnvelope childrenD_703 ⊆ insert (4, 3) required_703 := by decide +kernel +theorem child_required_sub_703 : ∀ j, childrenC_703 j ⊆ insert (4, 3) required_703 := by decide +kernel +theorem child_envelope_sub_703 : ∀ j, childrenD_703 j ⊆ envelope_703 := by decide +kernel +theorem pivot_mem_703 : (4, 3) ∈ envelope_703 := by decide +kernel +theorem children_work_703 : ∀ j, Template HasSnaky 7 (childrenC_703 j) (childrenD_703 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_369 2 (5, 0)).mono (by decide +kernel) + · exact row_works_703_i0.mono (by decide +kernel) + · exact (placed21_template row_works_516 4 (1, 6)).mono (by decide +kernel) + · exact row_works_703_i4.mono (by decide +kernel) + · exact row_works_703_i8.mono (by decide +kernel) +theorem row_works_703 : Template HasSnaky 8 required_703 envelope_703 := by + refine compose HasSnaky 7 childrenC_703 childrenD_703 children_work_703 (4, 3) + required_703 envelope_703 pivot_mem_703 child_required_sub_703 child_envelope_sub_703 ?_ + intro b hb + exact common_sub_703 (mem_commonEnvelope childrenD_703 b hb) +def height_658_i0 : ℕ := 7 +def childrenH_658_i0 : Fin 2 → ℕ := ![height_314, height_378] +theorem height_exact_658_i0 : height_658_i0 = 1 + Finset.univ.sup childrenH_658_i0 := by decide +kernel +theorem required_origin_658_i0 : ∀ x ∈ required_658_i0, + (∃ j, x ∈ childrenC_658_i0 j) ∨ ∀ j, x ∈ childrenD_658_i0 j := by decide +kernel +theorem required_exact_658_i0 : required_658_i0 = + ((Finset.univ.biUnion childrenC_658_i0) ∪ commonEnvelope childrenD_658_i0).erase (2, 6) := by + exact required_eq_combination childrenC_658_i0 childrenD_658_i0 (2, 6) required_658_i0 + (by decide +kernel) child_required_sub_658_i0 common_sub_658_i0 required_origin_658_i0 +theorem envelope_origin_658_i0 : ∀ x ∈ envelope_658_i0, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_658_i0 j := by decide +kernel +theorem envelope_exact_658_i0 : envelope_658_i0 = + insert (2, 6) (Finset.univ.biUnion childrenD_658_i0) := by + exact envelope_eq_combination childrenD_658_i0 (2, 6) envelope_658_i0 + pivot_mem_658_i0 child_envelope_sub_658_i0 envelope_origin_658_i0 +def checked_658_i0 : CheckedCard where + required := required_658_i0 + envelope := envelope_658_i0 + height := height_658_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_658_i0 +def height_658 : ℕ := 8 +def childrenH_658 : Fin 4 → ℕ := ![height_27, height_52, height_284, height_658_i0] +theorem height_exact_658 : height_658 = 1 + Finset.univ.sup childrenH_658 := by decide +kernel +theorem required_origin_658 : ∀ x ∈ required_658, + (∃ j, x ∈ childrenC_658 j) ∨ ∀ j, x ∈ childrenD_658 j := by decide +kernel +theorem required_exact_658 : required_658 = + ((Finset.univ.biUnion childrenC_658) ∪ commonEnvelope childrenD_658).erase (2, 3) := by + exact required_eq_combination childrenC_658 childrenD_658 (2, 3) required_658 + (by decide +kernel) child_required_sub_658 common_sub_658 required_origin_658 +theorem envelope_origin_658 : ∀ x ∈ envelope_658, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_658 j := by decide +kernel +theorem envelope_exact_658 : envelope_658 = + insert (2, 3) (Finset.univ.biUnion childrenD_658) := by + exact envelope_eq_combination childrenD_658 (2, 3) envelope_658 + pivot_mem_658 child_envelope_sub_658 envelope_origin_658 +def checked_658 : CheckedCard where + required := required_658 + envelope := envelope_658 + height := height_658 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_658 +def height_661_i0 : ℕ := 7 +def childrenH_661_i0 : Fin 4 → ℕ := ![height_9, height_115, height_302, height_303] +theorem height_exact_661_i0 : height_661_i0 = 1 + Finset.univ.sup childrenH_661_i0 := by decide +kernel +theorem required_origin_661_i0 : ∀ x ∈ required_661_i0, + (∃ j, x ∈ childrenC_661_i0 j) ∨ ∀ j, x ∈ childrenD_661_i0 j := by decide +kernel +theorem required_exact_661_i0 : required_661_i0 = + ((Finset.univ.biUnion childrenC_661_i0) ∪ commonEnvelope childrenD_661_i0).erase (4, 3) := by + exact required_eq_combination childrenC_661_i0 childrenD_661_i0 (4, 3) required_661_i0 + (by decide +kernel) child_required_sub_661_i0 common_sub_661_i0 required_origin_661_i0 +theorem envelope_origin_661_i0 : ∀ x ∈ envelope_661_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_661_i0 j := by decide +kernel +theorem envelope_exact_661_i0 : envelope_661_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_661_i0) := by + exact envelope_eq_combination childrenD_661_i0 (4, 3) envelope_661_i0 + pivot_mem_661_i0 child_envelope_sub_661_i0 envelope_origin_661_i0 +def checked_661_i0 : CheckedCard where + required := required_661_i0 + envelope := envelope_661_i0 + height := height_661_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_661_i0 +def height_661 : ℕ := 8 +def childrenH_661 : Fin 5 → ℕ := ![height_13, height_14, height_33, height_116, height_661_i0] +theorem height_exact_661 : height_661 = 1 + Finset.univ.sup childrenH_661 := by decide +kernel +theorem required_origin_661 : ∀ x ∈ required_661, + (∃ j, x ∈ childrenC_661 j) ∨ ∀ j, x ∈ childrenD_661 j := by decide +kernel +theorem required_exact_661 : required_661 = + ((Finset.univ.biUnion childrenC_661) ∪ commonEnvelope childrenD_661).erase (4, 6) := by + exact required_eq_combination childrenC_661 childrenD_661 (4, 6) required_661 + (by decide +kernel) child_required_sub_661 common_sub_661 required_origin_661 +theorem envelope_origin_661 : ∀ x ∈ envelope_661, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_661 j := by decide +kernel +theorem envelope_exact_661 : envelope_661 = + insert (4, 6) (Finset.univ.biUnion childrenD_661) := by + exact envelope_eq_combination childrenD_661 (4, 6) envelope_661 + pivot_mem_661 child_envelope_sub_661 envelope_origin_661 +def checked_661 : CheckedCard where + required := required_661 + envelope := envelope_661 + height := height_661 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_661 +def height_666_i1 : ℕ := 6 +def childrenH_666_i1 : Fin 2 → ℕ := ![height_4, height_314] +theorem height_exact_666_i1 : height_666_i1 = 1 + Finset.univ.sup childrenH_666_i1 := by decide +kernel +theorem required_origin_666_i1 : ∀ x ∈ required_666_i1, + (∃ j, x ∈ childrenC_666_i1 j) ∨ ∀ j, x ∈ childrenD_666_i1 j := by decide +kernel +theorem required_exact_666_i1 : required_666_i1 = + ((Finset.univ.biUnion childrenC_666_i1) ∪ commonEnvelope childrenD_666_i1).erase (1, 3) := by + exact required_eq_combination childrenC_666_i1 childrenD_666_i1 (1, 3) required_666_i1 + (by decide +kernel) child_required_sub_666_i1 common_sub_666_i1 required_origin_666_i1 +theorem envelope_origin_666_i1 : ∀ x ∈ envelope_666_i1, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_666_i1 j := by decide +kernel +theorem envelope_exact_666_i1 : envelope_666_i1 = + insert (1, 3) (Finset.univ.biUnion childrenD_666_i1) := by + exact envelope_eq_combination childrenD_666_i1 (1, 3) envelope_666_i1 + pivot_mem_666_i1 child_envelope_sub_666_i1 envelope_origin_666_i1 +def checked_666_i1 : CheckedCard where + required := required_666_i1 + envelope := envelope_666_i1 + height := height_666_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_666_i1 +def height_666_i0 : ℕ := 7 +def childrenH_666_i0 : Fin 2 → ℕ := ![height_5, height_666_i1] +theorem height_exact_666_i0 : height_666_i0 = 1 + Finset.univ.sup childrenH_666_i0 := by decide +kernel +theorem required_origin_666_i0 : ∀ x ∈ required_666_i0, + (∃ j, x ∈ childrenC_666_i0 j) ∨ ∀ j, x ∈ childrenD_666_i0 j := by decide +kernel +theorem required_exact_666_i0 : required_666_i0 = + ((Finset.univ.biUnion childrenC_666_i0) ∪ commonEnvelope childrenD_666_i0).erase (4, 3) := by + exact required_eq_combination childrenC_666_i0 childrenD_666_i0 (4, 3) required_666_i0 + (by decide +kernel) child_required_sub_666_i0 common_sub_666_i0 required_origin_666_i0 +theorem envelope_origin_666_i0 : ∀ x ∈ envelope_666_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_666_i0 j := by decide +kernel +theorem envelope_exact_666_i0 : envelope_666_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_666_i0) := by + exact envelope_eq_combination childrenD_666_i0 (4, 3) envelope_666_i0 + pivot_mem_666_i0 child_envelope_sub_666_i0 envelope_origin_666_i0 +def checked_666_i0 : CheckedCard where + required := required_666_i0 + envelope := envelope_666_i0 + height := height_666_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_666_i0 +def height_666 : ℕ := 8 +def childrenH_666 : Fin 2 → ℕ := ![height_5, height_666_i0] +theorem height_exact_666 : height_666 = 1 + Finset.univ.sup childrenH_666 := by decide +kernel +theorem required_origin_666 : ∀ x ∈ required_666, + (∃ j, x ∈ childrenC_666 j) ∨ ∀ j, x ∈ childrenD_666 j := by decide +kernel +theorem required_exact_666 : required_666 = + ((Finset.univ.biUnion childrenC_666) ∪ commonEnvelope childrenD_666).erase (2, 3) := by + exact required_eq_combination childrenC_666 childrenD_666 (2, 3) required_666 + (by decide +kernel) child_required_sub_666 common_sub_666 required_origin_666 +theorem envelope_origin_666 : ∀ x ∈ envelope_666, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_666 j := by decide +kernel +theorem envelope_exact_666 : envelope_666 = + insert (2, 3) (Finset.univ.biUnion childrenD_666) := by + exact envelope_eq_combination childrenD_666 (2, 3) envelope_666 + pivot_mem_666 child_envelope_sub_666 envelope_origin_666 +def checked_666 : CheckedCard where + required := required_666 + envelope := envelope_666 + height := height_666 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_666 +def height_678_i1 : ℕ := 6 +def childrenH_678_i1 : Fin 2 → ℕ := ![height_22, height_382] +theorem height_exact_678_i1 : height_678_i1 = 1 + Finset.univ.sup childrenH_678_i1 := by decide +kernel +theorem required_origin_678_i1 : ∀ x ∈ required_678_i1, + (∃ j, x ∈ childrenC_678_i1 j) ∨ ∀ j, x ∈ childrenD_678_i1 j := by decide +kernel +theorem required_exact_678_i1 : required_678_i1 = + ((Finset.univ.biUnion childrenC_678_i1) ∪ commonEnvelope childrenD_678_i1).erase (4, 3) := by + exact required_eq_combination childrenC_678_i1 childrenD_678_i1 (4, 3) required_678_i1 + (by decide +kernel) child_required_sub_678_i1 common_sub_678_i1 required_origin_678_i1 +theorem envelope_origin_678_i1 : ∀ x ∈ envelope_678_i1, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_678_i1 j := by decide +kernel +theorem envelope_exact_678_i1 : envelope_678_i1 = + insert (4, 3) (Finset.univ.biUnion childrenD_678_i1) := by + exact envelope_eq_combination childrenD_678_i1 (4, 3) envelope_678_i1 + pivot_mem_678_i1 child_envelope_sub_678_i1 envelope_origin_678_i1 +def checked_678_i1 : CheckedCard where + required := required_678_i1 + envelope := envelope_678_i1 + height := height_678_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_678_i1 +def height_678_i0 : ℕ := 7 +def childrenH_678_i0 : Fin 2 → ℕ := ![height_18, height_678_i1] +theorem height_exact_678_i0 : height_678_i0 = 1 + Finset.univ.sup childrenH_678_i0 := by decide +kernel +theorem required_origin_678_i0 : ∀ x ∈ required_678_i0, + (∃ j, x ∈ childrenC_678_i0 j) ∨ ∀ j, x ∈ childrenD_678_i0 j := by decide +kernel +theorem required_exact_678_i0 : required_678_i0 = + ((Finset.univ.biUnion childrenC_678_i0) ∪ commonEnvelope childrenD_678_i0).erase (2, 6) := by + exact required_eq_combination childrenC_678_i0 childrenD_678_i0 (2, 6) required_678_i0 + (by decide +kernel) child_required_sub_678_i0 common_sub_678_i0 required_origin_678_i0 +theorem envelope_origin_678_i0 : ∀ x ∈ envelope_678_i0, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_678_i0 j := by decide +kernel +theorem envelope_exact_678_i0 : envelope_678_i0 = + insert (2, 6) (Finset.univ.biUnion childrenD_678_i0) := by + exact envelope_eq_combination childrenD_678_i0 (2, 6) envelope_678_i0 + pivot_mem_678_i0 child_envelope_sub_678_i0 envelope_origin_678_i0 +def checked_678_i0 : CheckedCard where + required := required_678_i0 + envelope := envelope_678_i0 + height := height_678_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_678_i0 +def height_678 : ℕ := 8 +def childrenH_678 : Fin 3 → ℕ := ![height_31, height_160, height_678_i0] +theorem height_exact_678 : height_678 = 1 + Finset.univ.sup childrenH_678 := by decide +kernel +theorem required_origin_678 : ∀ x ∈ required_678, + (∃ j, x ∈ childrenC_678 j) ∨ ∀ j, x ∈ childrenD_678 j := by decide +kernel +theorem required_exact_678 : required_678 = + ((Finset.univ.biUnion childrenC_678) ∪ commonEnvelope childrenD_678).erase (1, 5) := by + exact required_eq_combination childrenC_678 childrenD_678 (1, 5) required_678 + (by decide +kernel) child_required_sub_678 common_sub_678 required_origin_678 +theorem envelope_origin_678 : ∀ x ∈ envelope_678, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_678 j := by decide +kernel +theorem envelope_exact_678 : envelope_678 = + insert (1, 5) (Finset.univ.biUnion childrenD_678) := by + exact envelope_eq_combination childrenD_678 (1, 5) envelope_678 + pivot_mem_678 child_envelope_sub_678 envelope_origin_678 +def checked_678 : CheckedCard where + required := required_678 + envelope := envelope_678 + height := height_678 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_678 +def height_703_i1 : ℕ := 5 +def childrenH_703_i1 : Fin 2 → ℕ := ![height_3, height_27] +theorem height_exact_703_i1 : height_703_i1 = 1 + Finset.univ.sup childrenH_703_i1 := by decide +kernel +theorem required_origin_703_i1 : ∀ x ∈ required_703_i1, + (∃ j, x ∈ childrenC_703_i1 j) ∨ ∀ j, x ∈ childrenD_703_i1 j := by decide +kernel +theorem required_exact_703_i1 : required_703_i1 = + ((Finset.univ.biUnion childrenC_703_i1) ∪ commonEnvelope childrenD_703_i1).erase (5, 3) := by + exact required_eq_combination childrenC_703_i1 childrenD_703_i1 (5, 3) required_703_i1 + (by decide +kernel) child_required_sub_703_i1 common_sub_703_i1 required_origin_703_i1 +theorem envelope_origin_703_i1 : ∀ x ∈ envelope_703_i1, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_703_i1 j := by decide +kernel +theorem envelope_exact_703_i1 : envelope_703_i1 = + insert (5, 3) (Finset.univ.biUnion childrenD_703_i1) := by + exact envelope_eq_combination childrenD_703_i1 (5, 3) envelope_703_i1 + pivot_mem_703_i1 child_envelope_sub_703_i1 envelope_origin_703_i1 +def checked_703_i1 : CheckedCard where + required := required_703_i1 + envelope := envelope_703_i1 + height := height_703_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703_i1 +def height_703_i2 : ℕ := 4 +def childrenH_703_i2 : Fin 2 → ℕ := ![height_0, height_52] +theorem height_exact_703_i2 : height_703_i2 = 1 + Finset.univ.sup childrenH_703_i2 := by decide +kernel +theorem required_origin_703_i2 : ∀ x ∈ required_703_i2, + (∃ j, x ∈ childrenC_703_i2 j) ∨ ∀ j, x ∈ childrenD_703_i2 j := by decide +kernel +theorem required_exact_703_i2 : required_703_i2 = + ((Finset.univ.biUnion childrenC_703_i2) ∪ commonEnvelope childrenD_703_i2).erase (2, 3) := by + exact required_eq_combination childrenC_703_i2 childrenD_703_i2 (2, 3) required_703_i2 + (by decide +kernel) child_required_sub_703_i2 common_sub_703_i2 required_origin_703_i2 +theorem envelope_origin_703_i2 : ∀ x ∈ envelope_703_i2, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_703_i2 j := by decide +kernel +theorem envelope_exact_703_i2 : envelope_703_i2 = + insert (2, 3) (Finset.univ.biUnion childrenD_703_i2) := by + exact envelope_eq_combination childrenD_703_i2 (2, 3) envelope_703_i2 + pivot_mem_703_i2 child_envelope_sub_703_i2 envelope_origin_703_i2 +def checked_703_i2 : CheckedCard where + required := required_703_i2 + envelope := envelope_703_i2 + height := height_703_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703_i2 +def height_703_i3 : ℕ := 4 +def childrenH_703_i3 : Fin 2 → ℕ := ![height_0, height_101] +theorem height_exact_703_i3 : height_703_i3 = 1 + Finset.univ.sup childrenH_703_i3 := by decide +kernel +theorem required_origin_703_i3 : ∀ x ∈ required_703_i3, + (∃ j, x ∈ childrenC_703_i3 j) ∨ ∀ j, x ∈ childrenD_703_i3 j := by decide +kernel +theorem required_exact_703_i3 : required_703_i3 = + ((Finset.univ.biUnion childrenC_703_i3) ∪ commonEnvelope childrenD_703_i3).erase (3, 2) := by + exact required_eq_combination childrenC_703_i3 childrenD_703_i3 (3, 2) required_703_i3 + (by decide +kernel) child_required_sub_703_i3 common_sub_703_i3 required_origin_703_i3 +theorem envelope_origin_703_i3 : ∀ x ∈ envelope_703_i3, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_703_i3 j := by decide +kernel +theorem envelope_exact_703_i3 : envelope_703_i3 = + insert (3, 2) (Finset.univ.biUnion childrenD_703_i3) := by + exact envelope_eq_combination childrenD_703_i3 (3, 2) envelope_703_i3 + pivot_mem_703_i3 child_envelope_sub_703_i3 envelope_origin_703_i3 +def checked_703_i3 : CheckedCard where + required := required_703_i3 + envelope := envelope_703_i3 + height := height_703_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703_i3 +def height_703_i0 : ℕ := 6 +def childrenH_703_i0 : Fin 4 → ℕ := ![height_195, height_703_i1, height_703_i2, height_703_i3] +theorem height_exact_703_i0 : height_703_i0 = 1 + Finset.univ.sup childrenH_703_i0 := by decide +kernel +theorem required_origin_703_i0 : ∀ x ∈ required_703_i0, + (∃ j, x ∈ childrenC_703_i0 j) ∨ ∀ j, x ∈ childrenD_703_i0 j := by decide +kernel +theorem required_exact_703_i0 : required_703_i0 = + ((Finset.univ.biUnion childrenC_703_i0) ∪ commonEnvelope childrenD_703_i0).erase (3, 3) := by + exact required_eq_combination childrenC_703_i0 childrenD_703_i0 (3, 3) required_703_i0 + (by decide +kernel) child_required_sub_703_i0 common_sub_703_i0 required_origin_703_i0 +theorem envelope_origin_703_i0 : ∀ x ∈ envelope_703_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_703_i0 j := by decide +kernel +theorem envelope_exact_703_i0 : envelope_703_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_703_i0) := by + exact envelope_eq_combination childrenD_703_i0 (3, 3) envelope_703_i0 + pivot_mem_703_i0 child_envelope_sub_703_i0 envelope_origin_703_i0 +def checked_703_i0 : CheckedCard where + required := required_703_i0 + envelope := envelope_703_i0 + height := height_703_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703_i0 +def height_703_i7 : ℕ := 4 +def childrenH_703_i7 : Fin 3 → ℕ := ![height_11, height_103, height_157] +theorem height_exact_703_i7 : height_703_i7 = 1 + Finset.univ.sup childrenH_703_i7 := by decide +kernel +theorem required_origin_703_i7 : ∀ x ∈ required_703_i7, + (∃ j, x ∈ childrenC_703_i7 j) ∨ ∀ j, x ∈ childrenD_703_i7 j := by decide +kernel +theorem required_exact_703_i7 : required_703_i7 = + ((Finset.univ.biUnion childrenC_703_i7) ∪ commonEnvelope childrenD_703_i7).erase (2, 2) := by + exact required_eq_combination childrenC_703_i7 childrenD_703_i7 (2, 2) required_703_i7 + (by decide +kernel) child_required_sub_703_i7 common_sub_703_i7 required_origin_703_i7 +theorem envelope_origin_703_i7 : ∀ x ∈ envelope_703_i7, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_703_i7 j := by decide +kernel +theorem envelope_exact_703_i7 : envelope_703_i7 = + insert (2, 2) (Finset.univ.biUnion childrenD_703_i7) := by + exact envelope_eq_combination childrenD_703_i7 (2, 2) envelope_703_i7 + pivot_mem_703_i7 child_envelope_sub_703_i7 envelope_origin_703_i7 +def checked_703_i7 : CheckedCard where + required := required_703_i7 + envelope := envelope_703_i7 + height := height_703_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703_i7 +def height_703_i6 : ℕ := 5 +def childrenH_703_i6 : Fin 2 → ℕ := ![height_5, height_703_i7] +theorem height_exact_703_i6 : height_703_i6 = 1 + Finset.univ.sup childrenH_703_i6 := by decide +kernel +theorem required_origin_703_i6 : ∀ x ∈ required_703_i6, + (∃ j, x ∈ childrenC_703_i6 j) ∨ ∀ j, x ∈ childrenD_703_i6 j := by decide +kernel +theorem required_exact_703_i6 : required_703_i6 = + ((Finset.univ.biUnion childrenC_703_i6) ∪ commonEnvelope childrenD_703_i6).erase (5, 2) := by + exact required_eq_combination childrenC_703_i6 childrenD_703_i6 (5, 2) required_703_i6 + (by decide +kernel) child_required_sub_703_i6 common_sub_703_i6 required_origin_703_i6 +theorem envelope_origin_703_i6 : ∀ x ∈ envelope_703_i6, + x = (5, 2) ∨ ∃ j, x ∈ childrenD_703_i6 j := by decide +kernel +theorem envelope_exact_703_i6 : envelope_703_i6 = + insert (5, 2) (Finset.univ.biUnion childrenD_703_i6) := by + exact envelope_eq_combination childrenD_703_i6 (5, 2) envelope_703_i6 + pivot_mem_703_i6 child_envelope_sub_703_i6 envelope_origin_703_i6 +def checked_703_i6 : CheckedCard where + required := required_703_i6 + envelope := envelope_703_i6 + height := height_703_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703_i6 +def height_703_i5 : ℕ := 6 +def childrenH_703_i5 : Fin 2 → ℕ := ![height_5, height_703_i6] +theorem height_exact_703_i5 : height_703_i5 = 1 + Finset.univ.sup childrenH_703_i5 := by decide +kernel +theorem required_origin_703_i5 : ∀ x ∈ required_703_i5, + (∃ j, x ∈ childrenC_703_i5 j) ∨ ∀ j, x ∈ childrenD_703_i5 j := by decide +kernel +theorem required_exact_703_i5 : required_703_i5 = + ((Finset.univ.biUnion childrenC_703_i5) ∪ commonEnvelope childrenD_703_i5).erase (3, 2) := by + exact required_eq_combination childrenC_703_i5 childrenD_703_i5 (3, 2) required_703_i5 + (by decide +kernel) child_required_sub_703_i5 common_sub_703_i5 required_origin_703_i5 +theorem envelope_origin_703_i5 : ∀ x ∈ envelope_703_i5, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_703_i5 j := by decide +kernel +theorem envelope_exact_703_i5 : envelope_703_i5 = + insert (3, 2) (Finset.univ.biUnion childrenD_703_i5) := by + exact envelope_eq_combination childrenD_703_i5 (3, 2) envelope_703_i5 + pivot_mem_703_i5 child_envelope_sub_703_i5 envelope_origin_703_i5 +def checked_703_i5 : CheckedCard where + required := required_703_i5 + envelope := envelope_703_i5 + height := height_703_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703_i5 +def height_703_i4 : ℕ := 7 +def childrenH_703_i4 : Fin 3 → ℕ := ![height_7, height_9, height_703_i5] +theorem height_exact_703_i4 : height_703_i4 = 1 + Finset.univ.sup childrenH_703_i4 := by decide +kernel +theorem required_origin_703_i4 : ∀ x ∈ required_703_i4, + (∃ j, x ∈ childrenC_703_i4 j) ∨ ∀ j, x ∈ childrenD_703_i4 j := by decide +kernel +theorem required_exact_703_i4 : required_703_i4 = + ((Finset.univ.biUnion childrenC_703_i4) ∪ commonEnvelope childrenD_703_i4).erase (4, 2) := by + exact required_eq_combination childrenC_703_i4 childrenD_703_i4 (4, 2) required_703_i4 + (by decide +kernel) child_required_sub_703_i4 common_sub_703_i4 required_origin_703_i4 +theorem envelope_origin_703_i4 : ∀ x ∈ envelope_703_i4, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_703_i4 j := by decide +kernel +theorem envelope_exact_703_i4 : envelope_703_i4 = + insert (4, 2) (Finset.univ.biUnion childrenD_703_i4) := by + exact envelope_eq_combination childrenD_703_i4 (4, 2) envelope_703_i4 + pivot_mem_703_i4 child_envelope_sub_703_i4 envelope_origin_703_i4 +def checked_703_i4 : CheckedCard where + required := required_703_i4 + envelope := envelope_703_i4 + height := height_703_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703_i4 +def height_703_i9 : ℕ := 5 +def childrenH_703_i9 : Fin 2 → ℕ := ![height_18, height_77] +theorem height_exact_703_i9 : height_703_i9 = 1 + Finset.univ.sup childrenH_703_i9 := by decide +kernel +theorem required_origin_703_i9 : ∀ x ∈ required_703_i9, + (∃ j, x ∈ childrenC_703_i9 j) ∨ ∀ j, x ∈ childrenD_703_i9 j := by decide +kernel +theorem required_exact_703_i9 : required_703_i9 = + ((Finset.univ.biUnion childrenC_703_i9) ∪ commonEnvelope childrenD_703_i9).erase (5, 3) := by + exact required_eq_combination childrenC_703_i9 childrenD_703_i9 (5, 3) required_703_i9 + (by decide +kernel) child_required_sub_703_i9 common_sub_703_i9 required_origin_703_i9 +theorem envelope_origin_703_i9 : ∀ x ∈ envelope_703_i9, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_703_i9 j := by decide +kernel +theorem envelope_exact_703_i9 : envelope_703_i9 = + insert (5, 3) (Finset.univ.biUnion childrenD_703_i9) := by + exact envelope_eq_combination childrenD_703_i9 (5, 3) envelope_703_i9 + pivot_mem_703_i9 child_envelope_sub_703_i9 envelope_origin_703_i9 +def checked_703_i9 : CheckedCard where + required := required_703_i9 + envelope := envelope_703_i9 + height := height_703_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703_i9 +def height_703_i8 : ℕ := 6 +def childrenH_703_i8 : Fin 4 → ℕ := ![height_9, height_49, height_186, height_703_i9] +theorem height_exact_703_i8 : height_703_i8 = 1 + Finset.univ.sup childrenH_703_i8 := by decide +kernel +theorem required_origin_703_i8 : ∀ x ∈ required_703_i8, + (∃ j, x ∈ childrenC_703_i8 j) ∨ ∀ j, x ∈ childrenD_703_i8 j := by decide +kernel +theorem required_exact_703_i8 : required_703_i8 = + ((Finset.univ.biUnion childrenC_703_i8) ∪ commonEnvelope childrenD_703_i8).erase (4, 6) := by + exact required_eq_combination childrenC_703_i8 childrenD_703_i8 (4, 6) required_703_i8 + (by decide +kernel) child_required_sub_703_i8 common_sub_703_i8 required_origin_703_i8 +theorem envelope_origin_703_i8 : ∀ x ∈ envelope_703_i8, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_703_i8 j := by decide +kernel +theorem envelope_exact_703_i8 : envelope_703_i8 = + insert (4, 6) (Finset.univ.biUnion childrenD_703_i8) := by + exact envelope_eq_combination childrenD_703_i8 (4, 6) envelope_703_i8 + pivot_mem_703_i8 child_envelope_sub_703_i8 envelope_origin_703_i8 +def checked_703_i8 : CheckedCard where + required := required_703_i8 + envelope := envelope_703_i8 + height := height_703_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703_i8 +def height_703 : ℕ := 8 +def childrenH_703 : Fin 6 → ℕ := ![height_13, height_369, height_703_i0, height_516, height_703_i4, height_703_i8] +theorem height_exact_703 : height_703 = 1 + Finset.univ.sup childrenH_703 := by decide +kernel +theorem required_origin_703 : ∀ x ∈ required_703, + (∃ j, x ∈ childrenC_703 j) ∨ ∀ j, x ∈ childrenD_703 j := by decide +kernel +theorem required_exact_703 : required_703 = + ((Finset.univ.biUnion childrenC_703) ∪ commonEnvelope childrenD_703).erase (4, 3) := by + exact required_eq_combination childrenC_703 childrenD_703 (4, 3) required_703 + (by decide +kernel) child_required_sub_703 common_sub_703 required_origin_703 +theorem envelope_origin_703 : ∀ x ∈ envelope_703, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_703 j := by decide +kernel +theorem envelope_exact_703 : envelope_703 = + insert (4, 3) (Finset.univ.biUnion childrenD_703) := by + exact envelope_eq_combination childrenD_703 (4, 3) envelope_703 + pivot_mem_703 child_envelope_sub_703 envelope_origin_703 +def checked_703 : CheckedCard where + required := required_703 + envelope := envelope_703 + height := height_703 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_703 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part01.lean new file mode 100644 index 0000000..ceb58b7 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part01.lean @@ -0,0 +1,950 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_322 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_322 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_322 : Fin 3 → Finset Cell := ![(placed21 3 (0, 4) required_7), (placed21 1 (0, 3) required_9), (placed21 0 (1, 0) required_321)] +def childrenD_322 : Fin 3 → Finset Cell := ![(placed21 3 (0, 4) envelope_7), (placed21 1 (0, 3) envelope_9), (placed21 0 (1, 0) envelope_321)] +theorem common_sub_322 : commonEnvelope childrenD_322 ⊆ insert (4, 4) required_322 := by decide +kernel +theorem child_required_sub_322 : ∀ j, childrenC_322 j ⊆ insert (4, 4) required_322 := by decide +kernel +theorem child_envelope_sub_322 : ∀ j, childrenD_322 j ⊆ envelope_322 := by decide +kernel +theorem pivot_mem_322 : (4, 4) ∈ envelope_322 := by decide +kernel +theorem children_work_322 : ∀ j, Template HasSnaky 8 (childrenC_322 j) (childrenD_322 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_321 0 (1, 0)).mono (by decide +kernel) +theorem row_works_322 : Template HasSnaky 9 required_322 envelope_322 := by + refine compose HasSnaky 8 childrenC_322 childrenD_322 children_work_322 (4, 4) + required_322 envelope_322 pivot_mem_322 child_required_sub_322 child_envelope_sub_322 ?_ + intro b hb + exact common_sub_322 (mem_commonEnvelope childrenD_322 b hb) +def required_325 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_325 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (2, 4), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_325 : Fin 2 → Finset Cell := ![(placed21 2 (4, 4) required_5), (placed21 0 (1, 0) required_321)] +def childrenD_325 : Fin 2 → Finset Cell := ![(placed21 2 (4, 4) envelope_5), (placed21 0 (1, 0) envelope_321)] +theorem common_sub_325 : commonEnvelope childrenD_325 ⊆ insert (3, 4) required_325 := by decide +kernel +theorem child_required_sub_325 : ∀ j, childrenC_325 j ⊆ insert (3, 4) required_325 := by decide +kernel +theorem child_envelope_sub_325 : ∀ j, childrenD_325 j ⊆ envelope_325 := by decide +kernel +theorem pivot_mem_325 : (3, 4) ∈ envelope_325 := by decide +kernel +theorem children_work_325 : ∀ j, Template HasSnaky 8 (childrenC_325 j) (childrenD_325 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_321 0 (1, 0)).mono (by decide +kernel) +theorem row_works_325 : Template HasSnaky 9 required_325 envelope_325 := by + refine compose HasSnaky 8 childrenC_325 childrenD_325 children_work_325 (3, 4) + required_325 envelope_325 pivot_mem_325 child_required_sub_325 child_envelope_sub_325 ?_ + intro b hb + exact common_sub_325 (mem_commonEnvelope childrenD_325 b hb) +def required_326 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_326 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 4), (3, 4), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_326 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) required_3), (placed21 0 (2, 0) required_321)] +def childrenD_326 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) envelope_3), (placed21 0 (2, 0) envelope_321)] +theorem common_sub_326 : commonEnvelope childrenD_326 ⊆ insert (2, 4) required_326 := by decide +kernel +theorem child_required_sub_326 : ∀ j, childrenC_326 j ⊆ insert (2, 4) required_326 := by decide +kernel +theorem child_envelope_sub_326 : ∀ j, childrenD_326 j ⊆ envelope_326 := by decide +kernel +theorem pivot_mem_326 : (2, 4) ∈ envelope_326 := by decide +kernel +theorem children_work_326 : ∀ j, Template HasSnaky 8 (childrenC_326 j) (childrenD_326 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 6 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_321 0 (2, 0)).mono (by decide +kernel) +theorem row_works_326 : Template HasSnaky 9 required_326 envelope_326 := by + refine compose HasSnaky 8 childrenC_326 childrenD_326 children_work_326 (2, 4) + required_326 envelope_326 pivot_mem_326 child_required_sub_326 child_envelope_sub_326 ?_ + intro b hb + exact common_sub_326 (mem_commonEnvelope childrenD_326 b hb) +def required_327 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 4), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_327 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_327 : Fin 2 → Finset Cell := ![(placed21 0 (1, 3) required_32), (placed21 2 (4, 0) required_321)] +def childrenD_327 : Fin 2 → Finset Cell := ![(placed21 0 (1, 3) envelope_32), (placed21 2 (4, 0) envelope_321)] +theorem common_sub_327 : commonEnvelope childrenD_327 ⊆ insert (4, 4) required_327 := by decide +kernel +theorem child_required_sub_327 : ∀ j, childrenC_327 j ⊆ insert (4, 4) required_327 := by decide +kernel +theorem child_envelope_sub_327 : ∀ j, childrenD_327 j ⊆ envelope_327 := by decide +kernel +theorem pivot_mem_327 : (4, 4) ∈ envelope_327 := by decide +kernel +theorem children_work_327 : ∀ j, Template HasSnaky 8 (childrenC_327 j) (childrenD_327 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_32 0 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_321 2 (4, 0)).mono (by decide +kernel) +theorem row_works_327 : Template HasSnaky 9 required_327 envelope_327 := by + refine compose HasSnaky 8 childrenC_327 childrenD_327 children_work_327 (4, 4) + required_327 envelope_327 pivot_mem_327 child_required_sub_327 child_envelope_sub_327 ?_ + intro b hb + exact common_sub_327 (mem_commonEnvelope childrenD_327 b hb) +def required_328 : Finset Cell := ⟨(([(1, 4), (2, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_328 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_328 : Fin 3 → Finset Cell := ![(placed21 1 (0, 4) required_7), (placed21 3 (0, 5) required_9), (placed21 0 (1, 0) required_321)] +def childrenD_328 : Fin 3 → Finset Cell := ![(placed21 1 (0, 4) envelope_7), (placed21 3 (0, 5) envelope_9), (placed21 0 (1, 0) envelope_321)] +theorem common_sub_328 : commonEnvelope childrenD_328 ⊆ insert (3, 4) required_328 := by decide +kernel +theorem child_required_sub_328 : ∀ j, childrenC_328 j ⊆ insert (3, 4) required_328 := by decide +kernel +theorem child_envelope_sub_328 : ∀ j, childrenD_328 j ⊆ envelope_328 := by decide +kernel +theorem pivot_mem_328 : (3, 4) ∈ envelope_328 := by decide +kernel +theorem children_work_328 : ∀ j, Template HasSnaky 8 (childrenC_328 j) (childrenD_328 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_9 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_321 0 (1, 0)).mono (by decide +kernel) +theorem row_works_328 : Template HasSnaky 9 required_328 envelope_328 := by + refine compose HasSnaky 8 childrenC_328 childrenD_328 children_work_328 (3, 4) + required_328 envelope_328 pivot_mem_328 child_required_sub_328 child_envelope_sub_328 ?_ + intro b hb + exact common_sub_328 (mem_commonEnvelope childrenD_328 b hb) +def required_330 : Finset Cell := ⟨(([(1, 4), (2, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_330 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_330 : Fin 3 → Finset Cell := ![(placed21 3 (0, 4) required_7), (placed21 1 (0, 3) required_9), (placed21 0 (1, 0) required_321)] +def childrenD_330 : Fin 3 → Finset Cell := ![(placed21 3 (0, 4) envelope_7), (placed21 1 (0, 3) envelope_9), (placed21 0 (1, 0) envelope_321)] +theorem common_sub_330 : commonEnvelope childrenD_330 ⊆ insert (3, 4) required_330 := by decide +kernel +theorem child_required_sub_330 : ∀ j, childrenC_330 j ⊆ insert (3, 4) required_330 := by decide +kernel +theorem child_envelope_sub_330 : ∀ j, childrenD_330 j ⊆ envelope_330 := by decide +kernel +theorem pivot_mem_330 : (3, 4) ∈ envelope_330 := by decide +kernel +theorem children_work_330 : ∀ j, Template HasSnaky 8 (childrenC_330 j) (childrenD_330 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_321 0 (1, 0)).mono (by decide +kernel) +theorem row_works_330 : Template HasSnaky 9 required_330 envelope_330 := by + refine compose HasSnaky 8 childrenC_330 childrenD_330 children_work_330 (3, 4) + required_330 envelope_330 pivot_mem_330 child_required_sub_330 child_envelope_sub_330 ?_ + intro b hb + exact common_sub_330 (mem_commonEnvelope childrenD_330 b hb) +def required_368 : Finset Cell := ⟨(([(1, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_368 : Finset Cell := ⟨(([(0, 6), (0, 7), (1, 4), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 5), (5, 6), (5, 7), (5, 8), (6, 5), (6, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_368 : Fin 7 → Finset Cell := ![(placed21 4 (3, 7) required_14), (placed21 4 (3, 7) required_31), (placed21 5 (6, 2) required_181), (placed21 0 (3, 1) required_189), (placed21 5 (7, 2) required_257), (placed21 4 (1, 6) required_355), (placed21 6 (5, 7) required_367)] +def childrenD_368 : Fin 7 → Finset Cell := ![(placed21 4 (3, 7) envelope_14), (placed21 4 (3, 7) envelope_31), (placed21 5 (6, 2) envelope_181), (placed21 0 (3, 1) envelope_189), (placed21 5 (7, 2) envelope_257), (placed21 4 (1, 6) envelope_355), (placed21 6 (5, 7) envelope_367)] +theorem common_sub_368 : commonEnvelope childrenD_368 ⊆ insert (4, 5) required_368 := by decide +kernel +theorem child_required_sub_368 : ∀ j, childrenC_368 j ⊆ insert (4, 5) required_368 := by decide +kernel +theorem child_envelope_sub_368 : ∀ j, childrenD_368 j ⊆ envelope_368 := by decide +kernel +theorem pivot_mem_368 : (4, 5) ∈ envelope_368 := by decide +kernel +theorem children_work_368 : ∀ j, Template HasSnaky 8 (childrenC_368 j) (childrenD_368 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_31 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_181 5 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_189 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_257 5 (7, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_355 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_367 6 (5, 7)).mono (by decide +kernel) +theorem row_works_368 : Template HasSnaky 9 required_368 envelope_368 := by + refine compose HasSnaky 8 childrenC_368 childrenD_368 children_work_368 (4, 5) + required_368 envelope_368 pivot_mem_368 child_required_sub_368 child_envelope_sub_368 ?_ + intro b hb + exact common_sub_368 (mem_commonEnvelope childrenD_368 b hb) +def required_380_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_380_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 3), (4, 4), (4, 5), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_380_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_5), (placed21 1 (1, 0) required_379)] +def childrenD_380_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_5), (placed21 1 (1, 0) envelope_379)] +theorem common_sub_380_i0 : commonEnvelope childrenD_380_i0 ⊆ insert (3, 0) required_380_i0 := by decide +kernel +theorem child_required_sub_380_i0 : ∀ j, childrenC_380_i0 j ⊆ insert (3, 0) required_380_i0 := by decide +kernel +theorem child_envelope_sub_380_i0 : ∀ j, childrenD_380_i0 j ⊆ envelope_380_i0 := by decide +kernel +theorem pivot_mem_380_i0 : (3, 0) ∈ envelope_380_i0 := by decide +kernel +theorem children_work_380_i0 : ∀ j, Template HasSnaky 7 (childrenC_380_i0 j) (childrenD_380_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_379 1 (1, 0)).mono (by decide +kernel) +theorem row_works_380_i0 : Template HasSnaky 8 required_380_i0 envelope_380_i0 := by + refine compose HasSnaky 7 childrenC_380_i0 childrenD_380_i0 children_work_380_i0 (3, 0) + required_380_i0 envelope_380_i0 pivot_mem_380_i0 child_required_sub_380_i0 child_envelope_sub_380_i0 ?_ + intro b hb + exact common_sub_380_i0 (mem_commonEnvelope childrenD_380_i0 b hb) +def required_380 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_380 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 2), (4, 3), (4, 4), (4, 5), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_380 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), required_380_i0] +def childrenD_380 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), envelope_380_i0] +theorem common_sub_380 : commonEnvelope childrenD_380 ⊆ insert (3, 2) required_380 := by decide +kernel +theorem child_required_sub_380 : ∀ j, childrenC_380 j ⊆ insert (3, 2) required_380 := by decide +kernel +theorem child_envelope_sub_380 : ∀ j, childrenD_380 j ⊆ envelope_380 := by decide +kernel +theorem pivot_mem_380 : (3, 2) ∈ envelope_380 := by decide +kernel +theorem children_work_380 : ∀ j, Template HasSnaky 8 (childrenC_380 j) (childrenD_380 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact row_works_380_i0.mono (by decide +kernel) +theorem row_works_380 : Template HasSnaky 9 required_380 envelope_380 := by + refine compose HasSnaky 8 childrenC_380 childrenD_380 children_work_380 (3, 2) + required_380 envelope_380 pivot_mem_380 child_required_sub_380 child_envelope_sub_380 ?_ + intro b hb + exact common_sub_380 (mem_commonEnvelope childrenD_380 b hb) +def required_396 : Finset Cell := ⟨(([(2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_396 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (1, 4), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_396 : Fin 3 → Finset Cell := ![(placed21 2 (2, 2) required_7), (placed21 2 (3, 2) required_9), (placed21 3 (0, 6) required_395)] +def childrenD_396 : Fin 3 → Finset Cell := ![(placed21 2 (2, 2) envelope_7), (placed21 2 (3, 2) envelope_9), (placed21 3 (0, 6) envelope_395)] +theorem common_sub_396 : commonEnvelope childrenD_396 ⊆ insert (2, 6) required_396 := by decide +kernel +theorem child_required_sub_396 : ∀ j, childrenC_396 j ⊆ insert (2, 6) required_396 := by decide +kernel +theorem child_envelope_sub_396 : ∀ j, childrenD_396 j ⊆ envelope_396 := by decide +kernel +theorem pivot_mem_396 : (2, 6) ∈ envelope_396 := by decide +kernel +theorem children_work_396 : ∀ j, Template HasSnaky 8 (childrenC_396 j) (childrenD_396 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_395 3 (0, 6)).mono (by decide +kernel) +theorem row_works_396 : Template HasSnaky 9 required_396 envelope_396 := by + refine compose HasSnaky 8 childrenC_396 childrenD_396 children_work_396 (2, 6) + required_396 envelope_396 pivot_mem_396 child_required_sub_396 child_envelope_sub_396 ?_ + intro b hb + exact common_sub_396 (mem_commonEnvelope childrenD_396 b hb) +def required_397 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_397 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_397 : Fin 4 → Finset Cell := ![(placed21 0 (0, 2) required_8), required_161, required_162, (placed21 0 (0, 1) required_395)] +def childrenD_397 : Fin 4 → Finset Cell := ![(placed21 0 (0, 2) envelope_8), envelope_161, envelope_162, (placed21 0 (0, 1) envelope_395)] +theorem common_sub_397 : commonEnvelope childrenD_397 ⊆ insert (3, 3) required_397 := by decide +kernel +theorem child_required_sub_397 : ∀ j, childrenC_397 j ⊆ insert (3, 3) required_397 := by decide +kernel +theorem child_envelope_sub_397 : ∀ j, childrenD_397 j ⊆ envelope_397 := by decide +kernel +theorem pivot_mem_397 : (3, 3) ∈ envelope_397 := by decide +kernel +theorem children_work_397 : ∀ j, Template HasSnaky 8 (childrenC_397 j) (childrenD_397 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (0, 2)).mono (by decide +kernel) + · exact row_works_161.mono (by decide +kernel) + · exact row_works_162.mono (by decide +kernel) + · exact (placed21_template row_works_395 0 (0, 1)).mono (by decide +kernel) +theorem row_works_397 : Template HasSnaky 9 required_397 envelope_397 := by + refine compose HasSnaky 8 childrenC_397 childrenD_397 children_work_397 (3, 3) + required_397 envelope_397 pivot_mem_397 child_required_sub_397 child_envelope_sub_397 ?_ + intro b hb + exact common_sub_397 (mem_commonEnvelope childrenD_397 b hb) +def required_398 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_398 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (6, 2), (6, 3), (6, 4), (6, 5), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_398 : Fin 5 → Finset Cell := ![required_171, (placed21 0 (0, 2) required_197), (placed21 4 (0, 4) required_197), required_285, (placed21 0 (0, 1) required_395)] +def childrenD_398 : Fin 5 → Finset Cell := ![envelope_171, (placed21 0 (0, 2) envelope_197), (placed21 4 (0, 4) envelope_197), envelope_285, (placed21 0 (0, 1) envelope_395)] +theorem common_sub_398 : commonEnvelope childrenD_398 ⊆ insert (3, 3) required_398 := by decide +kernel +theorem child_required_sub_398 : ∀ j, childrenC_398 j ⊆ insert (3, 3) required_398 := by decide +kernel +theorem child_envelope_sub_398 : ∀ j, childrenD_398 j ⊆ envelope_398 := by decide +kernel +theorem pivot_mem_398 : (3, 3) ∈ envelope_398 := by decide +kernel +theorem children_work_398 : ∀ j, Template HasSnaky 8 (childrenC_398 j) (childrenD_398 j) := by + intro j + fin_cases j + · exact row_works_171.mono (by decide +kernel) + · exact (placed21_template row_works_197 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_197 4 (0, 4)).mono (by decide +kernel) + · exact row_works_285.mono (by decide +kernel) + · exact (placed21_template row_works_395 0 (0, 1)).mono (by decide +kernel) +theorem row_works_398 : Template HasSnaky 9 required_398 envelope_398 := by + refine compose HasSnaky 8 childrenC_398 childrenD_398 children_work_398 (3, 3) + required_398 envelope_398 pivot_mem_398 child_required_sub_398 child_envelope_sub_398 ?_ + intro b hb + exact common_sub_398 (mem_commonEnvelope childrenD_398 b hb) +def required_400 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_400 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 3), (5, 4), (5, 5), (5, 6), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_400 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_5), (placed21 0 (1, 0) required_395)] +def childrenD_400 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_5), (placed21 0 (1, 0) envelope_395)] +theorem common_sub_400 : commonEnvelope childrenD_400 ⊆ insert (3, 2) required_400 := by decide +kernel +theorem child_required_sub_400 : ∀ j, childrenC_400 j ⊆ insert (3, 2) required_400 := by decide +kernel +theorem child_envelope_sub_400 : ∀ j, childrenD_400 j ⊆ envelope_400 := by decide +kernel +theorem pivot_mem_400 : (3, 2) ∈ envelope_400 := by decide +kernel +theorem children_work_400 : ∀ j, Template HasSnaky 8 (childrenC_400 j) (childrenD_400 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_395 0 (1, 0)).mono (by decide +kernel) +theorem row_works_400 : Template HasSnaky 9 required_400 envelope_400 := by + refine compose HasSnaky 8 childrenC_400 childrenD_400 children_work_400 (3, 2) + required_400 envelope_400 pivot_mem_400 child_required_sub_400 child_envelope_sub_400 ?_ + intro b hb + exact common_sub_400 (mem_commonEnvelope childrenD_400 b hb) +def required_406 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_406 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_406 : Fin 4 → Finset Cell := ![required_199, (placed21 4 (0, 6) required_199), (placed21 0 (0, 1) required_405), (placed21 4 (0, 5) required_405)] +def childrenD_406 : Fin 4 → Finset Cell := ![envelope_199, (placed21 4 (0, 6) envelope_199), (placed21 0 (0, 1) envelope_405), (placed21 4 (0, 5) envelope_405)] +theorem common_sub_406 : commonEnvelope childrenD_406 ⊆ insert (1, 4) required_406 := by decide +kernel +theorem child_required_sub_406 : ∀ j, childrenC_406 j ⊆ insert (1, 4) required_406 := by decide +kernel +theorem child_envelope_sub_406 : ∀ j, childrenD_406 j ⊆ envelope_406 := by decide +kernel +theorem pivot_mem_406 : (1, 4) ∈ envelope_406 := by decide +kernel +theorem children_work_406 : ∀ j, Template HasSnaky 8 (childrenC_406 j) (childrenD_406 j) := by + intro j + fin_cases j + · exact row_works_199.mono (by decide +kernel) + · exact (placed21_template row_works_199 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_405 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_405 4 (0, 5)).mono (by decide +kernel) +theorem row_works_406 : Template HasSnaky 9 required_406 envelope_406 := by + refine compose HasSnaky 8 childrenC_406 childrenD_406 children_work_406 (1, 4) + required_406 envelope_406 pivot_mem_406 child_required_sub_406 child_envelope_sub_406 ?_ + intro b hb + exact common_sub_406 (mem_commonEnvelope childrenD_406 b hb) +def required_407_i0 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_407_i0 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_407_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 1) required_5), (placed21 4 (0, 5) required_404)] +def childrenD_407_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 1) envelope_5), (placed21 4 (0, 5) envelope_404)] +theorem common_sub_407_i0 : commonEnvelope childrenD_407_i0 ⊆ insert (0, 4) required_407_i0 := by decide +kernel +theorem child_required_sub_407_i0 : ∀ j, childrenC_407_i0 j ⊆ insert (0, 4) required_407_i0 := by decide +kernel +theorem child_envelope_sub_407_i0 : ∀ j, childrenD_407_i0 j ⊆ envelope_407_i0 := by decide +kernel +theorem pivot_mem_407_i0 : (0, 4) ∈ envelope_407_i0 := by decide +kernel +theorem children_work_407_i0 : ∀ j, Template HasSnaky 7 (childrenC_407_i0 j) (childrenD_407_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_404 4 (0, 5)).mono (by decide +kernel) +theorem row_works_407_i0 : Template HasSnaky 8 required_407_i0 envelope_407_i0 := by + refine compose HasSnaky 7 childrenC_407_i0 childrenD_407_i0 children_work_407_i0 (0, 4) + required_407_i0 envelope_407_i0 pivot_mem_407_i0 child_required_sub_407_i0 child_envelope_sub_407_i0 ?_ + intro b hb + exact common_sub_407_i0 (mem_commonEnvelope childrenD_407_i0 b hb) +def required_407 : Finset Cell := ⟨(([(0, 3), (1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_407 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_407 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) required_7), (placed21 1 (0, 1) required_8), (placed21 2 (2, 0) required_9), required_407_i0] +def childrenD_407 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) envelope_7), (placed21 1 (0, 1) envelope_8), (placed21 2 (2, 0) envelope_9), envelope_407_i0] +theorem common_sub_407 : commonEnvelope childrenD_407 ⊆ insert (1, 4) required_407 := by decide +kernel +theorem child_required_sub_407 : ∀ j, childrenC_407 j ⊆ insert (1, 4) required_407 := by decide +kernel +theorem child_envelope_sub_407 : ∀ j, childrenD_407 j ⊆ envelope_407 := by decide +kernel +theorem pivot_mem_407 : (1, 4) ∈ envelope_407 := by decide +kernel +theorem children_work_407 : ∀ j, Template HasSnaky 8 (childrenC_407 j) (childrenD_407 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (2, 0)).mono (by decide +kernel) + · exact row_works_407_i0.mono (by decide +kernel) +theorem row_works_407 : Template HasSnaky 9 required_407 envelope_407 := by + refine compose HasSnaky 8 childrenC_407 childrenD_407 children_work_407 (1, 4) + required_407 envelope_407 pivot_mem_407 child_required_sub_407 child_envelope_sub_407 ?_ + intro b hb + exact common_sub_407 (mem_commonEnvelope childrenD_407 b hb) +def required_421 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_421 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_421 : Fin 3 → Finset Cell := ![(placed21 1 (0, 1) required_8), (placed21 0 (1, 0) required_11), required_419] +def childrenD_421 : Fin 3 → Finset Cell := ![(placed21 1 (0, 1) envelope_8), (placed21 0 (1, 0) envelope_11), envelope_419] +theorem common_sub_421 : commonEnvelope childrenD_421 ⊆ insert (1, 4) required_421 := by decide +kernel +theorem child_required_sub_421 : ∀ j, childrenC_421 j ⊆ insert (1, 4) required_421 := by decide +kernel +theorem child_envelope_sub_421 : ∀ j, childrenD_421 j ⊆ envelope_421 := by decide +kernel +theorem pivot_mem_421 : (1, 4) ∈ envelope_421 := by decide +kernel +theorem children_work_421 : ∀ j, Template HasSnaky 8 (childrenC_421 j) (childrenD_421 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_11 0 (1, 0)).mono (by decide +kernel) + · exact row_works_419.mono (by decide +kernel) +theorem row_works_421 : Template HasSnaky 9 required_421 envelope_421 := by + refine compose HasSnaky 8 childrenC_421 childrenD_421 children_work_421 (1, 4) + required_421 envelope_421 pivot_mem_421 child_required_sub_421 child_envelope_sub_421 ?_ + intro b hb + exact common_sub_421 (mem_commonEnvelope childrenD_421 b hb) +def required_434_i0 : Finset Cell := ⟨(([(1, 2), (3, 2), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_434_i0 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_434_i0 : Fin 2 → Finset Cell := ![(placed21 4 (1, 2) required_1), (placed21 2 (5, 0) required_10)] +def childrenD_434_i0 : Fin 2 → Finset Cell := ![(placed21 4 (1, 2) envelope_1), (placed21 2 (5, 0) envelope_10)] +theorem common_sub_434_i0 : commonEnvelope childrenD_434_i0 ⊆ insert (5, 1) required_434_i0 := by decide +kernel +theorem child_required_sub_434_i0 : ∀ j, childrenC_434_i0 j ⊆ insert (5, 1) required_434_i0 := by decide +kernel +theorem child_envelope_sub_434_i0 : ∀ j, childrenD_434_i0 j ⊆ envelope_434_i0 := by decide +kernel +theorem pivot_mem_434_i0 : (5, 1) ∈ envelope_434_i0 := by decide +kernel +theorem children_work_434_i0 : ∀ j, Template HasSnaky 4 (childrenC_434_i0 j) (childrenD_434_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 4 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_10 2 (5, 0)).mono (by decide +kernel) +theorem row_works_434_i0 : Template HasSnaky 5 required_434_i0 envelope_434_i0 := by + refine compose HasSnaky 4 childrenC_434_i0 childrenD_434_i0 children_work_434_i0 (5, 1) + required_434_i0 envelope_434_i0 pivot_mem_434_i0 child_required_sub_434_i0 child_envelope_sub_434_i0 ?_ + intro b hb + exact common_sub_434_i0 (mem_commonEnvelope childrenD_434_i0 b hb) +def required_434_i1 : Finset Cell := ⟨(([(3, 2), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_434_i1 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 4), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_434_i1 : Fin 5 → Finset Cell := ![(placed21 5 (5, 1) required_8), (placed21 0 (3, 1) required_41), (placed21 1 (1, 1) required_253), (placed21 5 (7, 1) required_256), (placed21 0 (3, 1) required_336)] +def childrenD_434_i1 : Fin 5 → Finset Cell := ![(placed21 5 (5, 1) envelope_8), (placed21 0 (3, 1) envelope_41), (placed21 1 (1, 1) envelope_253), (placed21 5 (7, 1) envelope_256), (placed21 0 (3, 1) envelope_336)] +theorem common_sub_434_i1 : commonEnvelope childrenD_434_i1 ⊆ insert (4, 4) required_434_i1 := by decide +kernel +theorem child_required_sub_434_i1 : ∀ j, childrenC_434_i1 j ⊆ insert (4, 4) required_434_i1 := by decide +kernel +theorem child_envelope_sub_434_i1 : ∀ j, childrenD_434_i1 j ⊆ envelope_434_i1 := by decide +kernel +theorem pivot_mem_434_i1 : (4, 4) ∈ envelope_434_i1 := by decide +kernel +theorem children_work_434_i1 : ∀ j, Template HasSnaky 7 (childrenC_434_i1 j) (childrenD_434_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 5 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_41 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_253 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_256 5 (7, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_336 0 (3, 1)).mono (by decide +kernel) +theorem row_works_434_i1 : Template HasSnaky 8 required_434_i1 envelope_434_i1 := by + refine compose HasSnaky 7 childrenC_434_i1 childrenD_434_i1 children_work_434_i1 (4, 4) + required_434_i1 envelope_434_i1 pivot_mem_434_i1 child_required_sub_434_i1 child_envelope_sub_434_i1 ?_ + intro b hb + exact common_sub_434_i1 (mem_commonEnvelope childrenD_434_i1 b hb) +def required_434 : Finset Cell := ⟨(([(1, 2), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_434 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 2), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 4), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_434 : Fin 3 → Finset Cell := ![(placed21 5 (5, 1) required_80), required_434_i0, required_434_i1] +def childrenD_434 : Fin 3 → Finset Cell := ![(placed21 5 (5, 1) envelope_80), envelope_434_i0, envelope_434_i1] +theorem common_sub_434 : commonEnvelope childrenD_434 ⊆ insert (3, 2) required_434 := by decide +kernel +theorem child_required_sub_434 : ∀ j, childrenC_434 j ⊆ insert (3, 2) required_434 := by decide +kernel +theorem child_envelope_sub_434 : ∀ j, childrenD_434 j ⊆ envelope_434 := by decide +kernel +theorem pivot_mem_434 : (3, 2) ∈ envelope_434 := by decide +kernel +theorem children_work_434 : ∀ j, Template HasSnaky 8 (childrenC_434 j) (childrenD_434 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_80 5 (5, 1)).mono (by decide +kernel) + · exact row_works_434_i0.mono (by decide +kernel) + · exact row_works_434_i1.mono (by decide +kernel) +theorem row_works_434 : Template HasSnaky 9 required_434 envelope_434 := by + refine compose HasSnaky 8 childrenC_434 childrenD_434 children_work_434 (3, 2) + required_434 envelope_434 pivot_mem_434 child_required_sub_434 child_envelope_sub_434 ?_ + intro b hb + exact common_sub_434 (mem_commonEnvelope childrenD_434 b hb) +def required_441 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_441 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 3), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_441 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) required_28), (placed21 2 (4, 1) required_58), required_440] +def childrenD_441 : Fin 3 → Finset Cell := ![(placed21 1 (0, 2) envelope_28), (placed21 2 (4, 1) envelope_58), envelope_440] +theorem common_sub_441 : commonEnvelope childrenD_441 ⊆ insert (3, 3) required_441 := by decide +kernel +theorem child_required_sub_441 : ∀ j, childrenC_441 j ⊆ insert (3, 3) required_441 := by decide +kernel +theorem child_envelope_sub_441 : ∀ j, childrenD_441 j ⊆ envelope_441 := by decide +kernel +theorem pivot_mem_441 : (3, 3) ∈ envelope_441 := by decide +kernel +theorem children_work_441 : ∀ j, Template HasSnaky 8 (childrenC_441 j) (childrenD_441 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_28 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_58 2 (4, 1)).mono (by decide +kernel) + · exact row_works_440.mono (by decide +kernel) +theorem row_works_441 : Template HasSnaky 9 required_441 envelope_441 := by + refine compose HasSnaky 8 childrenC_441 childrenD_441 children_work_441 (3, 3) + required_441 envelope_441 pivot_mem_441 child_required_sub_441 child_envelope_sub_441 ?_ + intro b hb + exact common_sub_441 (mem_commonEnvelope childrenD_441 b hb) +def required_442 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_442 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 3), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 2), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_442 : Fin 3 → Finset Cell := ![(placed21 7 (5, 4) required_40), (placed21 7 (5, 4) required_149), required_440] +def childrenD_442 : Fin 3 → Finset Cell := ![(placed21 7 (5, 4) envelope_40), (placed21 7 (5, 4) envelope_149), envelope_440] +theorem common_sub_442 : commonEnvelope childrenD_442 ⊆ insert (3, 3) required_442 := by decide +kernel +theorem child_required_sub_442 : ∀ j, childrenC_442 j ⊆ insert (3, 3) required_442 := by decide +kernel +theorem child_envelope_sub_442 : ∀ j, childrenD_442 j ⊆ envelope_442 := by decide +kernel +theorem pivot_mem_442 : (3, 3) ∈ envelope_442 := by decide +kernel +theorem children_work_442 : ∀ j, Template HasSnaky 8 (childrenC_442 j) (childrenD_442 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_40 7 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_149 7 (5, 4)).mono (by decide +kernel) + · exact row_works_440.mono (by decide +kernel) +theorem row_works_442 : Template HasSnaky 9 required_442 envelope_442 := by + refine compose HasSnaky 8 childrenC_442 childrenD_442 children_work_442 (3, 3) + required_442 envelope_442 pivot_mem_442 child_required_sub_442 child_envelope_sub_442 ?_ + intro b hb + exact common_sub_442 (mem_commonEnvelope childrenD_442 b hb) +def height_322 : ℕ := 9 +def childrenH_322 : Fin 3 → ℕ := ![height_7, height_9, height_321] +theorem height_exact_322 : height_322 = 1 + Finset.univ.sup childrenH_322 := by decide +kernel +theorem required_origin_322 : ∀ x ∈ required_322, + (∃ j, x ∈ childrenC_322 j) ∨ ∀ j, x ∈ childrenD_322 j := by decide +kernel +theorem required_exact_322 : required_322 = + ((Finset.univ.biUnion childrenC_322) ∪ commonEnvelope childrenD_322).erase (4, 4) := by + exact required_eq_combination childrenC_322 childrenD_322 (4, 4) required_322 + (by decide +kernel) child_required_sub_322 common_sub_322 required_origin_322 +theorem envelope_origin_322 : ∀ x ∈ envelope_322, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_322 j := by decide +kernel +theorem envelope_exact_322 : envelope_322 = + insert (4, 4) (Finset.univ.biUnion childrenD_322) := by + exact envelope_eq_combination childrenD_322 (4, 4) envelope_322 + pivot_mem_322 child_envelope_sub_322 envelope_origin_322 +def checked_322 : CheckedCard where + required := required_322 + envelope := envelope_322 + height := height_322 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_322 +def height_325 : ℕ := 9 +def childrenH_325 : Fin 2 → ℕ := ![height_5, height_321] +theorem height_exact_325 : height_325 = 1 + Finset.univ.sup childrenH_325 := by decide +kernel +theorem required_origin_325 : ∀ x ∈ required_325, + (∃ j, x ∈ childrenC_325 j) ∨ ∀ j, x ∈ childrenD_325 j := by decide +kernel +theorem required_exact_325 : required_325 = + ((Finset.univ.biUnion childrenC_325) ∪ commonEnvelope childrenD_325).erase (3, 4) := by + exact required_eq_combination childrenC_325 childrenD_325 (3, 4) required_325 + (by decide +kernel) child_required_sub_325 common_sub_325 required_origin_325 +theorem envelope_origin_325 : ∀ x ∈ envelope_325, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_325 j := by decide +kernel +theorem envelope_exact_325 : envelope_325 = + insert (3, 4) (Finset.univ.biUnion childrenD_325) := by + exact envelope_eq_combination childrenD_325 (3, 4) envelope_325 + pivot_mem_325 child_envelope_sub_325 envelope_origin_325 +def checked_325 : CheckedCard where + required := required_325 + envelope := envelope_325 + height := height_325 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_325 +def height_326 : ℕ := 9 +def childrenH_326 : Fin 2 → ℕ := ![height_3, height_321] +theorem height_exact_326 : height_326 = 1 + Finset.univ.sup childrenH_326 := by decide +kernel +theorem required_origin_326 : ∀ x ∈ required_326, + (∃ j, x ∈ childrenC_326 j) ∨ ∀ j, x ∈ childrenD_326 j := by decide +kernel +theorem required_exact_326 : required_326 = + ((Finset.univ.biUnion childrenC_326) ∪ commonEnvelope childrenD_326).erase (2, 4) := by + exact required_eq_combination childrenC_326 childrenD_326 (2, 4) required_326 + (by decide +kernel) child_required_sub_326 common_sub_326 required_origin_326 +theorem envelope_origin_326 : ∀ x ∈ envelope_326, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_326 j := by decide +kernel +theorem envelope_exact_326 : envelope_326 = + insert (2, 4) (Finset.univ.biUnion childrenD_326) := by + exact envelope_eq_combination childrenD_326 (2, 4) envelope_326 + pivot_mem_326 child_envelope_sub_326 envelope_origin_326 +def checked_326 : CheckedCard where + required := required_326 + envelope := envelope_326 + height := height_326 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_326 +def height_327 : ℕ := 9 +def childrenH_327 : Fin 2 → ℕ := ![height_32, height_321] +theorem height_exact_327 : height_327 = 1 + Finset.univ.sup childrenH_327 := by decide +kernel +theorem required_origin_327 : ∀ x ∈ required_327, + (∃ j, x ∈ childrenC_327 j) ∨ ∀ j, x ∈ childrenD_327 j := by decide +kernel +theorem required_exact_327 : required_327 = + ((Finset.univ.biUnion childrenC_327) ∪ commonEnvelope childrenD_327).erase (4, 4) := by + exact required_eq_combination childrenC_327 childrenD_327 (4, 4) required_327 + (by decide +kernel) child_required_sub_327 common_sub_327 required_origin_327 +theorem envelope_origin_327 : ∀ x ∈ envelope_327, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_327 j := by decide +kernel +theorem envelope_exact_327 : envelope_327 = + insert (4, 4) (Finset.univ.biUnion childrenD_327) := by + exact envelope_eq_combination childrenD_327 (4, 4) envelope_327 + pivot_mem_327 child_envelope_sub_327 envelope_origin_327 +def checked_327 : CheckedCard where + required := required_327 + envelope := envelope_327 + height := height_327 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_327 +def height_328 : ℕ := 9 +def childrenH_328 : Fin 3 → ℕ := ![height_7, height_9, height_321] +theorem height_exact_328 : height_328 = 1 + Finset.univ.sup childrenH_328 := by decide +kernel +theorem required_origin_328 : ∀ x ∈ required_328, + (∃ j, x ∈ childrenC_328 j) ∨ ∀ j, x ∈ childrenD_328 j := by decide +kernel +theorem required_exact_328 : required_328 = + ((Finset.univ.biUnion childrenC_328) ∪ commonEnvelope childrenD_328).erase (3, 4) := by + exact required_eq_combination childrenC_328 childrenD_328 (3, 4) required_328 + (by decide +kernel) child_required_sub_328 common_sub_328 required_origin_328 +theorem envelope_origin_328 : ∀ x ∈ envelope_328, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_328 j := by decide +kernel +theorem envelope_exact_328 : envelope_328 = + insert (3, 4) (Finset.univ.biUnion childrenD_328) := by + exact envelope_eq_combination childrenD_328 (3, 4) envelope_328 + pivot_mem_328 child_envelope_sub_328 envelope_origin_328 +def checked_328 : CheckedCard where + required := required_328 + envelope := envelope_328 + height := height_328 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_328 +def height_330 : ℕ := 9 +def childrenH_330 : Fin 3 → ℕ := ![height_7, height_9, height_321] +theorem height_exact_330 : height_330 = 1 + Finset.univ.sup childrenH_330 := by decide +kernel +theorem required_origin_330 : ∀ x ∈ required_330, + (∃ j, x ∈ childrenC_330 j) ∨ ∀ j, x ∈ childrenD_330 j := by decide +kernel +theorem required_exact_330 : required_330 = + ((Finset.univ.biUnion childrenC_330) ∪ commonEnvelope childrenD_330).erase (3, 4) := by + exact required_eq_combination childrenC_330 childrenD_330 (3, 4) required_330 + (by decide +kernel) child_required_sub_330 common_sub_330 required_origin_330 +theorem envelope_origin_330 : ∀ x ∈ envelope_330, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_330 j := by decide +kernel +theorem envelope_exact_330 : envelope_330 = + insert (3, 4) (Finset.univ.biUnion childrenD_330) := by + exact envelope_eq_combination childrenD_330 (3, 4) envelope_330 + pivot_mem_330 child_envelope_sub_330 envelope_origin_330 +def checked_330 : CheckedCard where + required := required_330 + envelope := envelope_330 + height := height_330 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_330 +def height_368 : ℕ := 9 +def childrenH_368 : Fin 7 → ℕ := ![height_14, height_31, height_181, height_189, height_257, height_355, height_367] +theorem height_exact_368 : height_368 = 1 + Finset.univ.sup childrenH_368 := by decide +kernel +theorem required_origin_368 : ∀ x ∈ required_368, + (∃ j, x ∈ childrenC_368 j) ∨ ∀ j, x ∈ childrenD_368 j := by decide +kernel +theorem required_exact_368 : required_368 = + ((Finset.univ.biUnion childrenC_368) ∪ commonEnvelope childrenD_368).erase (4, 5) := by + exact required_eq_combination childrenC_368 childrenD_368 (4, 5) required_368 + (by decide +kernel) child_required_sub_368 common_sub_368 required_origin_368 +theorem envelope_origin_368 : ∀ x ∈ envelope_368, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_368 j := by decide +kernel +theorem envelope_exact_368 : envelope_368 = + insert (4, 5) (Finset.univ.biUnion childrenD_368) := by + exact envelope_eq_combination childrenD_368 (4, 5) envelope_368 + pivot_mem_368 child_envelope_sub_368 envelope_origin_368 +def checked_368 : CheckedCard where + required := required_368 + envelope := envelope_368 + height := height_368 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_368 +def height_380_i0 : ℕ := 8 +def childrenH_380_i0 : Fin 2 → ℕ := ![height_5, height_379] +theorem height_exact_380_i0 : height_380_i0 = 1 + Finset.univ.sup childrenH_380_i0 := by decide +kernel +theorem required_origin_380_i0 : ∀ x ∈ required_380_i0, + (∃ j, x ∈ childrenC_380_i0 j) ∨ ∀ j, x ∈ childrenD_380_i0 j := by decide +kernel +theorem required_exact_380_i0 : required_380_i0 = + ((Finset.univ.biUnion childrenC_380_i0) ∪ commonEnvelope childrenD_380_i0).erase (3, 0) := by + exact required_eq_combination childrenC_380_i0 childrenD_380_i0 (3, 0) required_380_i0 + (by decide +kernel) child_required_sub_380_i0 common_sub_380_i0 required_origin_380_i0 +theorem envelope_origin_380_i0 : ∀ x ∈ envelope_380_i0, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_380_i0 j := by decide +kernel +theorem envelope_exact_380_i0 : envelope_380_i0 = + insert (3, 0) (Finset.univ.biUnion childrenD_380_i0) := by + exact envelope_eq_combination childrenD_380_i0 (3, 0) envelope_380_i0 + pivot_mem_380_i0 child_envelope_sub_380_i0 envelope_origin_380_i0 +def checked_380_i0 : CheckedCard where + required := required_380_i0 + envelope := envelope_380_i0 + height := height_380_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_380_i0 +def height_380 : ℕ := 9 +def childrenH_380 : Fin 2 → ℕ := ![height_5, height_380_i0] +theorem height_exact_380 : height_380 = 1 + Finset.univ.sup childrenH_380 := by decide +kernel +theorem required_origin_380 : ∀ x ∈ required_380, + (∃ j, x ∈ childrenC_380 j) ∨ ∀ j, x ∈ childrenD_380 j := by decide +kernel +theorem required_exact_380 : required_380 = + ((Finset.univ.biUnion childrenC_380) ∪ commonEnvelope childrenD_380).erase (3, 2) := by + exact required_eq_combination childrenC_380 childrenD_380 (3, 2) required_380 + (by decide +kernel) child_required_sub_380 common_sub_380 required_origin_380 +theorem envelope_origin_380 : ∀ x ∈ envelope_380, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_380 j := by decide +kernel +theorem envelope_exact_380 : envelope_380 = + insert (3, 2) (Finset.univ.biUnion childrenD_380) := by + exact envelope_eq_combination childrenD_380 (3, 2) envelope_380 + pivot_mem_380 child_envelope_sub_380 envelope_origin_380 +def checked_380 : CheckedCard where + required := required_380 + envelope := envelope_380 + height := height_380 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_380 +def height_396 : ℕ := 9 +def childrenH_396 : Fin 3 → ℕ := ![height_7, height_9, height_395] +theorem height_exact_396 : height_396 = 1 + Finset.univ.sup childrenH_396 := by decide +kernel +theorem required_origin_396 : ∀ x ∈ required_396, + (∃ j, x ∈ childrenC_396 j) ∨ ∀ j, x ∈ childrenD_396 j := by decide +kernel +theorem required_exact_396 : required_396 = + ((Finset.univ.biUnion childrenC_396) ∪ commonEnvelope childrenD_396).erase (2, 6) := by + exact required_eq_combination childrenC_396 childrenD_396 (2, 6) required_396 + (by decide +kernel) child_required_sub_396 common_sub_396 required_origin_396 +theorem envelope_origin_396 : ∀ x ∈ envelope_396, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_396 j := by decide +kernel +theorem envelope_exact_396 : envelope_396 = + insert (2, 6) (Finset.univ.biUnion childrenD_396) := by + exact envelope_eq_combination childrenD_396 (2, 6) envelope_396 + pivot_mem_396 child_envelope_sub_396 envelope_origin_396 +def checked_396 : CheckedCard where + required := required_396 + envelope := envelope_396 + height := height_396 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_396 +def height_397 : ℕ := 9 +def childrenH_397 : Fin 4 → ℕ := ![height_8, height_161, height_162, height_395] +theorem height_exact_397 : height_397 = 1 + Finset.univ.sup childrenH_397 := by decide +kernel +theorem required_origin_397 : ∀ x ∈ required_397, + (∃ j, x ∈ childrenC_397 j) ∨ ∀ j, x ∈ childrenD_397 j := by decide +kernel +theorem required_exact_397 : required_397 = + ((Finset.univ.biUnion childrenC_397) ∪ commonEnvelope childrenD_397).erase (3, 3) := by + exact required_eq_combination childrenC_397 childrenD_397 (3, 3) required_397 + (by decide +kernel) child_required_sub_397 common_sub_397 required_origin_397 +theorem envelope_origin_397 : ∀ x ∈ envelope_397, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_397 j := by decide +kernel +theorem envelope_exact_397 : envelope_397 = + insert (3, 3) (Finset.univ.biUnion childrenD_397) := by + exact envelope_eq_combination childrenD_397 (3, 3) envelope_397 + pivot_mem_397 child_envelope_sub_397 envelope_origin_397 +def checked_397 : CheckedCard where + required := required_397 + envelope := envelope_397 + height := height_397 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_397 +def height_398 : ℕ := 9 +def childrenH_398 : Fin 5 → ℕ := ![height_171, height_197, height_197, height_285, height_395] +theorem height_exact_398 : height_398 = 1 + Finset.univ.sup childrenH_398 := by decide +kernel +theorem required_origin_398 : ∀ x ∈ required_398, + (∃ j, x ∈ childrenC_398 j) ∨ ∀ j, x ∈ childrenD_398 j := by decide +kernel +theorem required_exact_398 : required_398 = + ((Finset.univ.biUnion childrenC_398) ∪ commonEnvelope childrenD_398).erase (3, 3) := by + exact required_eq_combination childrenC_398 childrenD_398 (3, 3) required_398 + (by decide +kernel) child_required_sub_398 common_sub_398 required_origin_398 +theorem envelope_origin_398 : ∀ x ∈ envelope_398, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_398 j := by decide +kernel +theorem envelope_exact_398 : envelope_398 = + insert (3, 3) (Finset.univ.biUnion childrenD_398) := by + exact envelope_eq_combination childrenD_398 (3, 3) envelope_398 + pivot_mem_398 child_envelope_sub_398 envelope_origin_398 +def checked_398 : CheckedCard where + required := required_398 + envelope := envelope_398 + height := height_398 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_398 +def height_400 : ℕ := 9 +def childrenH_400 : Fin 2 → ℕ := ![height_5, height_395] +theorem height_exact_400 : height_400 = 1 + Finset.univ.sup childrenH_400 := by decide +kernel +theorem required_origin_400 : ∀ x ∈ required_400, + (∃ j, x ∈ childrenC_400 j) ∨ ∀ j, x ∈ childrenD_400 j := by decide +kernel +theorem required_exact_400 : required_400 = + ((Finset.univ.biUnion childrenC_400) ∪ commonEnvelope childrenD_400).erase (3, 2) := by + exact required_eq_combination childrenC_400 childrenD_400 (3, 2) required_400 + (by decide +kernel) child_required_sub_400 common_sub_400 required_origin_400 +theorem envelope_origin_400 : ∀ x ∈ envelope_400, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_400 j := by decide +kernel +theorem envelope_exact_400 : envelope_400 = + insert (3, 2) (Finset.univ.biUnion childrenD_400) := by + exact envelope_eq_combination childrenD_400 (3, 2) envelope_400 + pivot_mem_400 child_envelope_sub_400 envelope_origin_400 +def checked_400 : CheckedCard where + required := required_400 + envelope := envelope_400 + height := height_400 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_400 +def height_406 : ℕ := 9 +def childrenH_406 : Fin 4 → ℕ := ![height_199, height_199, height_405, height_405] +theorem height_exact_406 : height_406 = 1 + Finset.univ.sup childrenH_406 := by decide +kernel +theorem required_origin_406 : ∀ x ∈ required_406, + (∃ j, x ∈ childrenC_406 j) ∨ ∀ j, x ∈ childrenD_406 j := by decide +kernel +theorem required_exact_406 : required_406 = + ((Finset.univ.biUnion childrenC_406) ∪ commonEnvelope childrenD_406).erase (1, 4) := by + exact required_eq_combination childrenC_406 childrenD_406 (1, 4) required_406 + (by decide +kernel) child_required_sub_406 common_sub_406 required_origin_406 +theorem envelope_origin_406 : ∀ x ∈ envelope_406, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_406 j := by decide +kernel +theorem envelope_exact_406 : envelope_406 = + insert (1, 4) (Finset.univ.biUnion childrenD_406) := by + exact envelope_eq_combination childrenD_406 (1, 4) envelope_406 + pivot_mem_406 child_envelope_sub_406 envelope_origin_406 +def checked_406 : CheckedCard where + required := required_406 + envelope := envelope_406 + height := height_406 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_406 +def height_407_i0 : ℕ := 8 +def childrenH_407_i0 : Fin 2 → ℕ := ![height_5, height_404] +theorem height_exact_407_i0 : height_407_i0 = 1 + Finset.univ.sup childrenH_407_i0 := by decide +kernel +theorem required_origin_407_i0 : ∀ x ∈ required_407_i0, + (∃ j, x ∈ childrenC_407_i0 j) ∨ ∀ j, x ∈ childrenD_407_i0 j := by decide +kernel +theorem required_exact_407_i0 : required_407_i0 = + ((Finset.univ.biUnion childrenC_407_i0) ∪ commonEnvelope childrenD_407_i0).erase (0, 4) := by + exact required_eq_combination childrenC_407_i0 childrenD_407_i0 (0, 4) required_407_i0 + (by decide +kernel) child_required_sub_407_i0 common_sub_407_i0 required_origin_407_i0 +theorem envelope_origin_407_i0 : ∀ x ∈ envelope_407_i0, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_407_i0 j := by decide +kernel +theorem envelope_exact_407_i0 : envelope_407_i0 = + insert (0, 4) (Finset.univ.biUnion childrenD_407_i0) := by + exact envelope_eq_combination childrenD_407_i0 (0, 4) envelope_407_i0 + pivot_mem_407_i0 child_envelope_sub_407_i0 envelope_origin_407_i0 +def checked_407_i0 : CheckedCard where + required := required_407_i0 + envelope := envelope_407_i0 + height := height_407_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_407_i0 +def height_407 : ℕ := 9 +def childrenH_407 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_407_i0] +theorem height_exact_407 : height_407 = 1 + Finset.univ.sup childrenH_407 := by decide +kernel +theorem required_origin_407 : ∀ x ∈ required_407, + (∃ j, x ∈ childrenC_407 j) ∨ ∀ j, x ∈ childrenD_407 j := by decide +kernel +theorem required_exact_407 : required_407 = + ((Finset.univ.biUnion childrenC_407) ∪ commonEnvelope childrenD_407).erase (1, 4) := by + exact required_eq_combination childrenC_407 childrenD_407 (1, 4) required_407 + (by decide +kernel) child_required_sub_407 common_sub_407 required_origin_407 +theorem envelope_origin_407 : ∀ x ∈ envelope_407, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_407 j := by decide +kernel +theorem envelope_exact_407 : envelope_407 = + insert (1, 4) (Finset.univ.biUnion childrenD_407) := by + exact envelope_eq_combination childrenD_407 (1, 4) envelope_407 + pivot_mem_407 child_envelope_sub_407 envelope_origin_407 +def checked_407 : CheckedCard where + required := required_407 + envelope := envelope_407 + height := height_407 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_407 +def height_421 : ℕ := 9 +def childrenH_421 : Fin 3 → ℕ := ![height_8, height_11, height_419] +theorem height_exact_421 : height_421 = 1 + Finset.univ.sup childrenH_421 := by decide +kernel +theorem required_origin_421 : ∀ x ∈ required_421, + (∃ j, x ∈ childrenC_421 j) ∨ ∀ j, x ∈ childrenD_421 j := by decide +kernel +theorem required_exact_421 : required_421 = + ((Finset.univ.biUnion childrenC_421) ∪ commonEnvelope childrenD_421).erase (1, 4) := by + exact required_eq_combination childrenC_421 childrenD_421 (1, 4) required_421 + (by decide +kernel) child_required_sub_421 common_sub_421 required_origin_421 +theorem envelope_origin_421 : ∀ x ∈ envelope_421, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_421 j := by decide +kernel +theorem envelope_exact_421 : envelope_421 = + insert (1, 4) (Finset.univ.biUnion childrenD_421) := by + exact envelope_eq_combination childrenD_421 (1, 4) envelope_421 + pivot_mem_421 child_envelope_sub_421 envelope_origin_421 +def checked_421 : CheckedCard where + required := required_421 + envelope := envelope_421 + height := height_421 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_421 +def height_434_i0 : ℕ := 5 +def childrenH_434_i0 : Fin 2 → ℕ := ![height_1, height_10] +theorem height_exact_434_i0 : height_434_i0 = 1 + Finset.univ.sup childrenH_434_i0 := by decide +kernel +theorem required_origin_434_i0 : ∀ x ∈ required_434_i0, + (∃ j, x ∈ childrenC_434_i0 j) ∨ ∀ j, x ∈ childrenD_434_i0 j := by decide +kernel +theorem required_exact_434_i0 : required_434_i0 = + ((Finset.univ.biUnion childrenC_434_i0) ∪ commonEnvelope childrenD_434_i0).erase (5, 1) := by + exact required_eq_combination childrenC_434_i0 childrenD_434_i0 (5, 1) required_434_i0 + (by decide +kernel) child_required_sub_434_i0 common_sub_434_i0 required_origin_434_i0 +theorem envelope_origin_434_i0 : ∀ x ∈ envelope_434_i0, + x = (5, 1) ∨ ∃ j, x ∈ childrenD_434_i0 j := by decide +kernel +theorem envelope_exact_434_i0 : envelope_434_i0 = + insert (5, 1) (Finset.univ.biUnion childrenD_434_i0) := by + exact envelope_eq_combination childrenD_434_i0 (5, 1) envelope_434_i0 + pivot_mem_434_i0 child_envelope_sub_434_i0 envelope_origin_434_i0 +def checked_434_i0 : CheckedCard where + required := required_434_i0 + envelope := envelope_434_i0 + height := height_434_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_434_i0 +def height_434_i1 : ℕ := 8 +def childrenH_434_i1 : Fin 5 → ℕ := ![height_8, height_41, height_253, height_256, height_336] +theorem height_exact_434_i1 : height_434_i1 = 1 + Finset.univ.sup childrenH_434_i1 := by decide +kernel +theorem required_origin_434_i1 : ∀ x ∈ required_434_i1, + (∃ j, x ∈ childrenC_434_i1 j) ∨ ∀ j, x ∈ childrenD_434_i1 j := by decide +kernel +theorem required_exact_434_i1 : required_434_i1 = + ((Finset.univ.biUnion childrenC_434_i1) ∪ commonEnvelope childrenD_434_i1).erase (4, 4) := by + exact required_eq_combination childrenC_434_i1 childrenD_434_i1 (4, 4) required_434_i1 + (by decide +kernel) child_required_sub_434_i1 common_sub_434_i1 required_origin_434_i1 +theorem envelope_origin_434_i1 : ∀ x ∈ envelope_434_i1, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_434_i1 j := by decide +kernel +theorem envelope_exact_434_i1 : envelope_434_i1 = + insert (4, 4) (Finset.univ.biUnion childrenD_434_i1) := by + exact envelope_eq_combination childrenD_434_i1 (4, 4) envelope_434_i1 + pivot_mem_434_i1 child_envelope_sub_434_i1 envelope_origin_434_i1 +def checked_434_i1 : CheckedCard where + required := required_434_i1 + envelope := envelope_434_i1 + height := height_434_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_434_i1 +def height_434 : ℕ := 9 +def childrenH_434 : Fin 3 → ℕ := ![height_80, height_434_i0, height_434_i1] +theorem height_exact_434 : height_434 = 1 + Finset.univ.sup childrenH_434 := by decide +kernel +theorem required_origin_434 : ∀ x ∈ required_434, + (∃ j, x ∈ childrenC_434 j) ∨ ∀ j, x ∈ childrenD_434 j := by decide +kernel +theorem required_exact_434 : required_434 = + ((Finset.univ.biUnion childrenC_434) ∪ commonEnvelope childrenD_434).erase (3, 2) := by + exact required_eq_combination childrenC_434 childrenD_434 (3, 2) required_434 + (by decide +kernel) child_required_sub_434 common_sub_434 required_origin_434 +theorem envelope_origin_434 : ∀ x ∈ envelope_434, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_434 j := by decide +kernel +theorem envelope_exact_434 : envelope_434 = + insert (3, 2) (Finset.univ.biUnion childrenD_434) := by + exact envelope_eq_combination childrenD_434 (3, 2) envelope_434 + pivot_mem_434 child_envelope_sub_434 envelope_origin_434 +def checked_434 : CheckedCard where + required := required_434 + envelope := envelope_434 + height := height_434 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_434 +def height_441 : ℕ := 9 +def childrenH_441 : Fin 3 → ℕ := ![height_28, height_58, height_440] +theorem height_exact_441 : height_441 = 1 + Finset.univ.sup childrenH_441 := by decide +kernel +theorem required_origin_441 : ∀ x ∈ required_441, + (∃ j, x ∈ childrenC_441 j) ∨ ∀ j, x ∈ childrenD_441 j := by decide +kernel +theorem required_exact_441 : required_441 = + ((Finset.univ.biUnion childrenC_441) ∪ commonEnvelope childrenD_441).erase (3, 3) := by + exact required_eq_combination childrenC_441 childrenD_441 (3, 3) required_441 + (by decide +kernel) child_required_sub_441 common_sub_441 required_origin_441 +theorem envelope_origin_441 : ∀ x ∈ envelope_441, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_441 j := by decide +kernel +theorem envelope_exact_441 : envelope_441 = + insert (3, 3) (Finset.univ.biUnion childrenD_441) := by + exact envelope_eq_combination childrenD_441 (3, 3) envelope_441 + pivot_mem_441 child_envelope_sub_441 envelope_origin_441 +def checked_441 : CheckedCard where + required := required_441 + envelope := envelope_441 + height := height_441 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_441 +def height_442 : ℕ := 9 +def childrenH_442 : Fin 3 → ℕ := ![height_40, height_149, height_440] +theorem height_exact_442 : height_442 = 1 + Finset.univ.sup childrenH_442 := by decide +kernel +theorem required_origin_442 : ∀ x ∈ required_442, + (∃ j, x ∈ childrenC_442 j) ∨ ∀ j, x ∈ childrenD_442 j := by decide +kernel +theorem required_exact_442 : required_442 = + ((Finset.univ.biUnion childrenC_442) ∪ commonEnvelope childrenD_442).erase (3, 3) := by + exact required_eq_combination childrenC_442 childrenD_442 (3, 3) required_442 + (by decide +kernel) child_required_sub_442 common_sub_442 required_origin_442 +theorem envelope_origin_442 : ∀ x ∈ envelope_442, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_442 j := by decide +kernel +theorem envelope_exact_442 : envelope_442 = + insert (3, 3) (Finset.univ.biUnion childrenD_442) := by + exact envelope_eq_combination childrenD_442 (3, 3) envelope_442 + pivot_mem_442 child_envelope_sub_442 envelope_origin_442 +def checked_442 : CheckedCard where + required := required_442 + envelope := envelope_442 + height := height_442 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_442 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part02.lean new file mode 100644 index 0000000..9e3bc09 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part02.lean @@ -0,0 +1,767 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_443_i6 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_443_i6 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_443_i6 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) required_3), (placed21 1 (4, 0) required_5)] +def childrenD_443_i6 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) envelope_3), (placed21 1 (4, 0) envelope_5)] +theorem common_sub_443_i6 : commonEnvelope childrenD_443_i6 ⊆ insert (5, 3) required_443_i6 := by decide +kernel +theorem child_required_sub_443_i6 : ∀ j, childrenC_443_i6 j ⊆ insert (5, 3) required_443_i6 := by decide +kernel +theorem child_envelope_sub_443_i6 : ∀ j, childrenD_443_i6 j ⊆ envelope_443_i6 := by decide +kernel +theorem pivot_mem_443_i6 : (5, 3) ∈ envelope_443_i6 := by decide +kernel +theorem children_work_443_i6 : ∀ j, Template HasSnaky 1 (childrenC_443_i6 j) (childrenD_443_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 2 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_5 1 (4, 0)).mono (by decide +kernel) +theorem row_works_443_i6 : Template HasSnaky 2 required_443_i6 envelope_443_i6 := by + refine compose HasSnaky 1 childrenC_443_i6 childrenD_443_i6 children_work_443_i6 (5, 3) + required_443_i6 envelope_443_i6 pivot_mem_443_i6 child_required_sub_443_i6 child_envelope_sub_443_i6 ?_ + intro b hb + exact common_sub_443_i6 (mem_commonEnvelope childrenD_443_i6 b hb) +def required_443_i5 : Finset Cell := ⟨(([(1, 4), (2, 4), (4, 0), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_443_i5 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_443_i5 : Fin 2 → Finset Cell := ![(placed21 5 (4, 0) required_5), required_443_i6] +def childrenD_443_i5 : Fin 2 → Finset Cell := ![(placed21 5 (4, 0) envelope_5), envelope_443_i6] +theorem common_sub_443_i5 : commonEnvelope childrenD_443_i5 ⊆ insert (3, 3) required_443_i5 := by decide +kernel +theorem child_required_sub_443_i5 : ∀ j, childrenC_443_i5 j ⊆ insert (3, 3) required_443_i5 := by decide +kernel +theorem child_envelope_sub_443_i5 : ∀ j, childrenD_443_i5 j ⊆ envelope_443_i5 := by decide +kernel +theorem pivot_mem_443_i5 : (3, 3) ∈ envelope_443_i5 := by decide +kernel +theorem children_work_443_i5 : ∀ j, Template HasSnaky 2 (childrenC_443_i5 j) (childrenD_443_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (4, 0)).mono (by decide +kernel) + · exact row_works_443_i6.mono (by decide +kernel) +theorem row_works_443_i5 : Template HasSnaky 3 required_443_i5 envelope_443_i5 := by + refine compose HasSnaky 2 childrenC_443_i5 childrenD_443_i5 children_work_443_i5 (3, 3) + required_443_i5 envelope_443_i5 pivot_mem_443_i5 child_required_sub_443_i5 child_envelope_sub_443_i5 ?_ + intro b hb + exact common_sub_443_i5 (mem_commonEnvelope childrenD_443_i5 b hb) +def required_443_i4 : Finset Cell := ⟨(([(1, 1), (1, 4), (2, 1), (2, 4), (3, 1), (4, 0), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_443_i4 : Finset Cell := ⟨(([(1, 1), (1, 4), (2, 1), (2, 3), (2, 4), (3, 1), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_443_i4 : Fin 2 → Finset Cell := ![(placed21 4 (1, 1) required_5), required_443_i5] +def childrenD_443_i4 : Fin 2 → Finset Cell := ![(placed21 4 (1, 1) envelope_5), envelope_443_i5] +theorem common_sub_443_i4 : commonEnvelope childrenD_443_i4 ⊆ insert (4, 1) required_443_i4 := by decide +kernel +theorem child_required_sub_443_i4 : ∀ j, childrenC_443_i4 j ⊆ insert (4, 1) required_443_i4 := by decide +kernel +theorem child_envelope_sub_443_i4 : ∀ j, childrenD_443_i4 j ⊆ envelope_443_i4 := by decide +kernel +theorem pivot_mem_443_i4 : (4, 1) ∈ envelope_443_i4 := by decide +kernel +theorem children_work_443_i4 : ∀ j, Template HasSnaky 3 (childrenC_443_i4 j) (childrenD_443_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (1, 1)).mono (by decide +kernel) + · exact row_works_443_i5.mono (by decide +kernel) +theorem row_works_443_i4 : Template HasSnaky 4 required_443_i4 envelope_443_i4 := by + refine compose HasSnaky 3 childrenC_443_i4 childrenD_443_i4 children_work_443_i4 (4, 1) + required_443_i4 envelope_443_i4 pivot_mem_443_i4 child_required_sub_443_i4 child_envelope_sub_443_i4 ?_ + intro b hb + exact common_sub_443_i4 (mem_commonEnvelope childrenD_443_i4 b hb) +def required_443_i3 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (3, 1), (4, 0), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_443_i3 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (2, 5), (3, 1), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_443_i3 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), required_443_i4] +def childrenD_443_i3 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), envelope_443_i4] +theorem common_sub_443_i3 : commonEnvelope childrenD_443_i3 ⊆ insert (2, 4) required_443_i3 := by decide +kernel +theorem child_required_sub_443_i3 : ∀ j, childrenC_443_i3 j ⊆ insert (2, 4) required_443_i3 := by decide +kernel +theorem child_envelope_sub_443_i3 : ∀ j, childrenD_443_i3 j ⊆ envelope_443_i3 := by decide +kernel +theorem pivot_mem_443_i3 : (2, 4) ∈ envelope_443_i3 := by decide +kernel +theorem children_work_443_i3 : ∀ j, Template HasSnaky 4 (childrenC_443_i3 j) (childrenD_443_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact row_works_443_i4.mono (by decide +kernel) +theorem row_works_443_i3 : Template HasSnaky 5 required_443_i3 envelope_443_i3 := by + refine compose HasSnaky 4 childrenC_443_i3 childrenD_443_i3 children_work_443_i3 (2, 4) + required_443_i3 envelope_443_i3 pivot_mem_443_i3 child_required_sub_443_i3 child_envelope_sub_443_i3 ?_ + intro b hb + exact common_sub_443_i3 (mem_commonEnvelope childrenD_443_i3 b hb) +def required_443_i2 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (3, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_443_i2 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_443_i2 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) required_4), required_443_i3] +def childrenD_443_i2 : Fin 2 → Finset Cell := ![(placed21 4 (0, 1) envelope_4), envelope_443_i3] +theorem common_sub_443_i2 : commonEnvelope childrenD_443_i2 ⊆ insert (4, 0) required_443_i2 := by decide +kernel +theorem child_required_sub_443_i2 : ∀ j, childrenC_443_i2 j ⊆ insert (4, 0) required_443_i2 := by decide +kernel +theorem child_envelope_sub_443_i2 : ∀ j, childrenD_443_i2 j ⊆ envelope_443_i2 := by decide +kernel +theorem pivot_mem_443_i2 : (4, 0) ∈ envelope_443_i2 := by decide +kernel +theorem children_work_443_i2 : ∀ j, Template HasSnaky 5 (childrenC_443_i2 j) (childrenD_443_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (0, 1)).mono (by decide +kernel) + · exact row_works_443_i3.mono (by decide +kernel) +theorem row_works_443_i2 : Template HasSnaky 6 required_443_i2 envelope_443_i2 := by + refine compose HasSnaky 5 childrenC_443_i2 childrenD_443_i2 children_work_443_i2 (4, 0) + required_443_i2 envelope_443_i2 pivot_mem_443_i2 child_required_sub_443_i2 child_envelope_sub_443_i2 ?_ + intro b hb + exact common_sub_443_i2 (mem_commonEnvelope childrenD_443_i2 b hb) +def required_443_i1 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_443_i1 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_443_i1 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_4), required_443_i2] +def childrenD_443_i1 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_4), envelope_443_i2] +theorem common_sub_443_i1 : commonEnvelope childrenD_443_i1 ⊆ insert (3, 1) required_443_i1 := by decide +kernel +theorem child_required_sub_443_i1 : ∀ j, childrenC_443_i1 j ⊆ insert (3, 1) required_443_i1 := by decide +kernel +theorem child_envelope_sub_443_i1 : ∀ j, childrenD_443_i1 j ⊆ envelope_443_i1 := by decide +kernel +theorem pivot_mem_443_i1 : (3, 1) ∈ envelope_443_i1 := by decide +kernel +theorem children_work_443_i1 : ∀ j, Template HasSnaky 6 (childrenC_443_i1 j) (childrenD_443_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 0 (0, 1)).mono (by decide +kernel) + · exact row_works_443_i2.mono (by decide +kernel) +theorem row_works_443_i1 : Template HasSnaky 7 required_443_i1 envelope_443_i1 := by + refine compose HasSnaky 6 childrenC_443_i1 childrenD_443_i1 children_work_443_i1 (3, 1) + required_443_i1 envelope_443_i1 pivot_mem_443_i1 child_required_sub_443_i1 child_envelope_sub_443_i1 ?_ + intro b hb + exact common_sub_443_i1 (mem_commonEnvelope childrenD_443_i1 b hb) +def required_443_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_443_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_443_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), required_443_i1] +def childrenD_443_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), envelope_443_i1] +theorem common_sub_443_i0 : commonEnvelope childrenD_443_i0 ⊆ insert (0, 1) required_443_i0 := by decide +kernel +theorem child_required_sub_443_i0 : ∀ j, childrenC_443_i0 j ⊆ insert (0, 1) required_443_i0 := by decide +kernel +theorem child_envelope_sub_443_i0 : ∀ j, childrenD_443_i0 j ⊆ envelope_443_i0 := by decide +kernel +theorem pivot_mem_443_i0 : (0, 1) ∈ envelope_443_i0 := by decide +kernel +theorem children_work_443_i0 : ∀ j, Template HasSnaky 7 (childrenC_443_i0 j) (childrenD_443_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact row_works_443_i1.mono (by decide +kernel) +theorem row_works_443_i0 : Template HasSnaky 8 required_443_i0 envelope_443_i0 := by + refine compose HasSnaky 7 childrenC_443_i0 childrenD_443_i0 children_work_443_i0 (0, 1) + required_443_i0 envelope_443_i0 pivot_mem_443_i0 child_required_sub_443_i0 child_envelope_sub_443_i0 ?_ + intro b hb + exact common_sub_443_i0 (mem_commonEnvelope childrenD_443_i0 b hb) +def required_443 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_443 : Finset Cell := ⟨(([(0, 0), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_443 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), required_443_i0] +def childrenD_443 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), envelope_443_i0] +theorem common_sub_443 : commonEnvelope childrenD_443 ⊆ insert (2, 1) required_443 := by decide +kernel +theorem child_required_sub_443 : ∀ j, childrenC_443 j ⊆ insert (2, 1) required_443 := by decide +kernel +theorem child_envelope_sub_443 : ∀ j, childrenD_443 j ⊆ envelope_443 := by decide +kernel +theorem pivot_mem_443 : (2, 1) ∈ envelope_443 := by decide +kernel +theorem children_work_443 : ∀ j, Template HasSnaky 8 (childrenC_443 j) (childrenD_443 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact row_works_443_i0.mono (by decide +kernel) +theorem row_works_443 : Template HasSnaky 9 required_443 envelope_443 := by + refine compose HasSnaky 8 childrenC_443 childrenD_443 children_work_443 (2, 1) + required_443 envelope_443 pivot_mem_443 child_required_sub_443 child_envelope_sub_443 ?_ + intro b hb + exact common_sub_443 (mem_commonEnvelope childrenD_443 b hb) +def required_449 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_449 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_449 : Fin 5 → Finset Cell := ![(placed21 3 (1, 4) required_10), (placed21 1 (1, 3) required_27), (placed21 3 (1, 4) required_48), (placed21 3 (1, 4) required_63), required_448] +def childrenD_449 : Fin 5 → Finset Cell := ![(placed21 3 (1, 4) envelope_10), (placed21 1 (1, 3) envelope_27), (placed21 3 (1, 4) envelope_48), (placed21 3 (1, 4) envelope_63), envelope_448] +theorem common_sub_449 : commonEnvelope childrenD_449 ⊆ insert (4, 3) required_449 := by decide +kernel +theorem child_required_sub_449 : ∀ j, childrenC_449 j ⊆ insert (4, 3) required_449 := by decide +kernel +theorem child_envelope_sub_449 : ∀ j, childrenD_449 j ⊆ envelope_449 := by decide +kernel +theorem pivot_mem_449 : (4, 3) ∈ envelope_449 := by decide +kernel +theorem children_work_449 : ∀ j, Template HasSnaky 8 (childrenC_449 j) (childrenD_449 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_27 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_48 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_63 3 (1, 4)).mono (by decide +kernel) + · exact row_works_448.mono (by decide +kernel) +theorem row_works_449 : Template HasSnaky 9 required_449 envelope_449 := by + refine compose HasSnaky 8 childrenC_449 childrenD_449 children_work_449 (4, 3) + required_449 envelope_449 pivot_mem_449 child_required_sub_449 child_envelope_sub_449 ?_ + intro b hb + exact common_sub_449 (mem_commonEnvelope childrenD_449 b hb) +def required_450 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_450 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_450 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) required_0), (placed21 4 (0, 7) required_448)] +def childrenD_450 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) envelope_0), (placed21 4 (0, 7) envelope_448)] +theorem common_sub_450 : commonEnvelope childrenD_450 ⊆ insert (3, 4) required_450 := by decide +kernel +theorem child_required_sub_450 : ∀ j, childrenC_450 j ⊆ insert (3, 4) required_450 := by decide +kernel +theorem child_envelope_sub_450 : ∀ j, childrenD_450 j ⊆ envelope_450 := by decide +kernel +theorem pivot_mem_450 : (3, 4) ∈ envelope_450 := by decide +kernel +theorem children_work_450 : ∀ j, Template HasSnaky 8 (childrenC_450 j) (childrenD_450 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_448 4 (0, 7)).mono (by decide +kernel) +theorem row_works_450 : Template HasSnaky 9 required_450 envelope_450 := by + refine compose HasSnaky 8 childrenC_450 childrenD_450 children_work_450 (3, 4) + required_450 envelope_450 pivot_mem_450 child_required_sub_450 child_envelope_sub_450 ?_ + intro b hb + exact common_sub_450 (mem_commonEnvelope childrenD_450 b hb) +def required_457 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_457 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_457 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) required_7), (placed21 1 (0, 1) required_8), (placed21 2 (2, 0) required_9), (placed21 4 (0, 5) required_456)] +def childrenD_457 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) envelope_7), (placed21 1 (0, 1) envelope_8), (placed21 2 (2, 0) envelope_9), (placed21 4 (0, 5) envelope_456)] +theorem common_sub_457 : commonEnvelope childrenD_457 ⊆ insert (1, 4) required_457 := by decide +kernel +theorem child_required_sub_457 : ∀ j, childrenC_457 j ⊆ insert (1, 4) required_457 := by decide +kernel +theorem child_envelope_sub_457 : ∀ j, childrenD_457 j ⊆ envelope_457 := by decide +kernel +theorem pivot_mem_457 : (1, 4) ∈ envelope_457 := by decide +kernel +theorem children_work_457 : ∀ j, Template HasSnaky 8 (childrenC_457 j) (childrenD_457 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_456 4 (0, 5)).mono (by decide +kernel) +theorem row_works_457 : Template HasSnaky 9 required_457 envelope_457 := by + refine compose HasSnaky 8 childrenC_457 childrenD_457 children_work_457 (1, 4) + required_457 envelope_457 pivot_mem_457 child_required_sub_457 child_envelope_sub_457 ?_ + intro b hb + exact common_sub_457 (mem_commonEnvelope childrenD_457 b hb) +def required_458 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_458 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (5, 0), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_458 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) required_7), required_9, required_62, required_456] +def childrenD_458 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) envelope_7), envelope_9, envelope_62, envelope_456] +theorem common_sub_458 : commonEnvelope childrenD_458 ⊆ insert (1, 4) required_458 := by decide +kernel +theorem child_required_sub_458 : ∀ j, childrenC_458 j ⊆ insert (1, 4) required_458 := by decide +kernel +theorem child_envelope_sub_458 : ∀ j, childrenD_458 j ⊆ envelope_458 := by decide +kernel +theorem pivot_mem_458 : (1, 4) ∈ envelope_458 := by decide +kernel +theorem children_work_458 : ∀ j, Template HasSnaky 8 (childrenC_458 j) (childrenD_458 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (1, 0)).mono (by decide +kernel) + · exact row_works_9.mono (by decide +kernel) + · exact row_works_62.mono (by decide +kernel) + · exact row_works_456.mono (by decide +kernel) +theorem row_works_458 : Template HasSnaky 9 required_458 envelope_458 := by + refine compose HasSnaky 8 childrenC_458 childrenD_458 children_work_458 (1, 4) + required_458 envelope_458 pivot_mem_458 child_required_sub_458 child_envelope_sub_458 ?_ + intro b hb + exact common_sub_458 (mem_commonEnvelope childrenD_458 b hb) +def required_470_i0 : Finset Cell := ⟨(([(1, 5), (2, 2), (2, 5), (3, 3), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_470_i0 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_470_i0 : Fin 2 → Finset Cell := ![(placed21 6 (3, 6) required_54), (placed21 6 (4, 6) required_78)] +def childrenD_470_i0 : Fin 2 → Finset Cell := ![(placed21 6 (3, 6) envelope_54), (placed21 6 (4, 6) envelope_78)] +theorem common_sub_470_i0 : commonEnvelope childrenD_470_i0 ⊆ insert (2, 3) required_470_i0 := by decide +kernel +theorem child_required_sub_470_i0 : ∀ j, childrenC_470_i0 j ⊆ insert (2, 3) required_470_i0 := by decide +kernel +theorem child_envelope_sub_470_i0 : ∀ j, childrenD_470_i0 j ⊆ envelope_470_i0 := by decide +kernel +theorem pivot_mem_470_i0 : (2, 3) ∈ envelope_470_i0 := by decide +kernel +theorem children_work_470_i0 : ∀ j, Template HasSnaky 3 (childrenC_470_i0 j) (childrenD_470_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 6 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_78 6 (4, 6)).mono (by decide +kernel) +theorem row_works_470_i0 : Template HasSnaky 4 required_470_i0 envelope_470_i0 := by + refine compose HasSnaky 3 childrenC_470_i0 childrenD_470_i0 children_work_470_i0 (2, 3) + required_470_i0 envelope_470_i0 pivot_mem_470_i0 child_required_sub_470_i0 child_envelope_sub_470_i0 ?_ + intro b hb + exact common_sub_470_i0 (mem_commonEnvelope childrenD_470_i0 b hb) +def required_470_i2 : Finset Cell := ⟨(([(1, 5), (2, 2), (2, 5), (3, 3), (3, 5), (3, 6), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_470_i2 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_470_i2 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) required_2), (placed21 6 (4, 6) required_78)] +def childrenD_470_i2 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) envelope_2), (placed21 6 (4, 6) envelope_78)] +theorem common_sub_470_i2 : commonEnvelope childrenD_470_i2 ⊆ insert (2, 3) required_470_i2 := by decide +kernel +theorem child_required_sub_470_i2 : ∀ j, childrenC_470_i2 j ⊆ insert (2, 3) required_470_i2 := by decide +kernel +theorem child_envelope_sub_470_i2 : ∀ j, childrenD_470_i2 j ⊆ envelope_470_i2 := by decide +kernel +theorem pivot_mem_470_i2 : (2, 3) ∈ envelope_470_i2 := by decide +kernel +theorem children_work_470_i2 : ∀ j, Template HasSnaky 3 (childrenC_470_i2 j) (childrenD_470_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 7 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_78 6 (4, 6)).mono (by decide +kernel) +theorem row_works_470_i2 : Template HasSnaky 4 required_470_i2 envelope_470_i2 := by + refine compose HasSnaky 3 childrenC_470_i2 childrenD_470_i2 children_work_470_i2 (2, 3) + required_470_i2 envelope_470_i2 pivot_mem_470_i2 child_required_sub_470_i2 child_envelope_sub_470_i2 ?_ + intro b hb + exact common_sub_470_i2 (mem_commonEnvelope childrenD_470_i2 b hb) +def required_470_i1 : Finset Cell := ⟨(([(1, 5), (2, 2), (2, 5), (3, 3), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_470_i1 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_470_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 8) required_56), required_470_i2] +def childrenD_470_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 8) envelope_56), envelope_470_i2] +theorem common_sub_470_i1 : commonEnvelope childrenD_470_i1 ⊆ insert (3, 6) required_470_i1 := by decide +kernel +theorem child_required_sub_470_i1 : ∀ j, childrenC_470_i1 j ⊆ insert (3, 6) required_470_i1 := by decide +kernel +theorem child_envelope_sub_470_i1 : ∀ j, childrenD_470_i1 j ⊆ envelope_470_i1 := by decide +kernel +theorem pivot_mem_470_i1 : (3, 6) ∈ envelope_470_i1 := by decide +kernel +theorem children_work_470_i1 : ∀ j, Template HasSnaky 4 (childrenC_470_i1 j) (childrenD_470_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_56 4 (1, 8)).mono (by decide +kernel) + · exact row_works_470_i2.mono (by decide +kernel) +theorem row_works_470_i1 : Template HasSnaky 5 required_470_i1 envelope_470_i1 := by + refine compose HasSnaky 4 childrenC_470_i1 childrenD_470_i1 children_work_470_i1 (3, 6) + required_470_i1 envelope_470_i1 pivot_mem_470_i1 child_required_sub_470_i1 child_envelope_sub_470_i1 ?_ + intro b hb + exact common_sub_470_i1 (mem_commonEnvelope childrenD_470_i1 b hb) +def required_470 : Finset Cell := ⟨(([(1, 5), (2, 2), (2, 5), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_470 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_470 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) required_319), (placed21 4 (1, 7) required_335), required_470_i0, required_470_i1] +def childrenD_470 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) envelope_319), (placed21 4 (1, 7) envelope_335), envelope_470_i0, envelope_470_i1] +theorem common_sub_470 : commonEnvelope childrenD_470 ⊆ insert (3, 3) required_470 := by decide +kernel +theorem child_required_sub_470 : ∀ j, childrenC_470 j ⊆ insert (3, 3) required_470 := by decide +kernel +theorem child_envelope_sub_470 : ∀ j, childrenD_470 j ⊆ envelope_470 := by decide +kernel +theorem pivot_mem_470 : (3, 3) ∈ envelope_470 := by decide +kernel +theorem children_work_470 : ∀ j, Template HasSnaky 8 (childrenC_470 j) (childrenD_470 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_319 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_335 4 (1, 7)).mono (by decide +kernel) + · exact row_works_470_i0.mono (by decide +kernel) + · exact row_works_470_i1.mono (by decide +kernel) +theorem row_works_470 : Template HasSnaky 9 required_470 envelope_470 := by + refine compose HasSnaky 8 childrenC_470 childrenD_470 children_work_470 (3, 3) + required_470 envelope_470 pivot_mem_470 child_required_sub_470 child_envelope_sub_470 ?_ + intro b hb + exact common_sub_470 (mem_commonEnvelope childrenD_470 b hb) +def required_474 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_474 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_474 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) required_7), (placed21 0 (1, 1) required_8), (placed21 3 (0, 3) required_9), (placed21 2 (5, 0) required_473)] +def childrenD_474 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) envelope_7), (placed21 0 (1, 1) envelope_8), (placed21 3 (0, 3) envelope_9), (placed21 2 (5, 0) envelope_473)] +theorem common_sub_474 : commonEnvelope childrenD_474 ⊆ insert (4, 2) required_474 := by decide +kernel +theorem child_required_sub_474 : ∀ j, childrenC_474 j ⊆ insert (4, 2) required_474 := by decide +kernel +theorem child_envelope_sub_474 : ∀ j, childrenD_474 j ⊆ envelope_474 := by decide +kernel +theorem pivot_mem_474 : (4, 2) ∈ envelope_474 := by decide +kernel +theorem children_work_474 : ∀ j, Template HasSnaky 8 (childrenC_474 j) (childrenD_474 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_8 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_473 2 (5, 0)).mono (by decide +kernel) +theorem row_works_474 : Template HasSnaky 9 required_474 envelope_474 := by + refine compose HasSnaky 8 childrenC_474 childrenD_474 children_work_474 (4, 2) + required_474 envelope_474 pivot_mem_474 child_required_sub_474 child_envelope_sub_474 ?_ + intro b hb + exact common_sub_474 (mem_commonEnvelope childrenD_474 b hb) +def required_477 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_477 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (5, 2), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_477 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) required_7), (placed21 1 (0, 1) required_9), (placed21 1 (0, 1) required_62), required_473] +def childrenD_477 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) envelope_7), (placed21 1 (0, 1) envelope_9), (placed21 1 (0, 1) envelope_62), envelope_473] +theorem common_sub_477 : commonEnvelope childrenD_477 ⊆ insert (4, 2) required_477 := by decide +kernel +theorem child_required_sub_477 : ∀ j, childrenC_477 j ⊆ insert (4, 2) required_477 := by decide +kernel +theorem child_envelope_sub_477 : ∀ j, childrenD_477 j ⊆ envelope_477 := by decide +kernel +theorem pivot_mem_477 : (4, 2) ∈ envelope_477 := by decide +kernel +theorem children_work_477 : ∀ j, Template HasSnaky 8 (childrenC_477 j) (childrenD_477 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_62 1 (0, 1)).mono (by decide +kernel) + · exact row_works_473.mono (by decide +kernel) +theorem row_works_477 : Template HasSnaky 9 required_477 envelope_477 := by + refine compose HasSnaky 8 childrenC_477 childrenD_477 children_work_477 (4, 2) + required_477 envelope_477 pivot_mem_477 child_required_sub_477 child_envelope_sub_477 ?_ + intro b hb + exact common_sub_477 (mem_commonEnvelope childrenD_477 b hb) +def height_443_i6 : ℕ := 2 +def childrenH_443_i6 : Fin 2 → ℕ := ![height_3, height_5] +theorem height_exact_443_i6 : height_443_i6 = 1 + Finset.univ.sup childrenH_443_i6 := by decide +kernel +theorem required_origin_443_i6 : ∀ x ∈ required_443_i6, + (∃ j, x ∈ childrenC_443_i6 j) ∨ ∀ j, x ∈ childrenD_443_i6 j := by decide +kernel +theorem required_exact_443_i6 : required_443_i6 = + ((Finset.univ.biUnion childrenC_443_i6) ∪ commonEnvelope childrenD_443_i6).erase (5, 3) := by + exact required_eq_combination childrenC_443_i6 childrenD_443_i6 (5, 3) required_443_i6 + (by decide +kernel) child_required_sub_443_i6 common_sub_443_i6 required_origin_443_i6 +theorem envelope_origin_443_i6 : ∀ x ∈ envelope_443_i6, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_443_i6 j := by decide +kernel +theorem envelope_exact_443_i6 : envelope_443_i6 = + insert (5, 3) (Finset.univ.biUnion childrenD_443_i6) := by + exact envelope_eq_combination childrenD_443_i6 (5, 3) envelope_443_i6 + pivot_mem_443_i6 child_envelope_sub_443_i6 envelope_origin_443_i6 +def checked_443_i6 : CheckedCard where + required := required_443_i6 + envelope := envelope_443_i6 + height := height_443_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_443_i6 +def height_443_i5 : ℕ := 3 +def childrenH_443_i5 : Fin 2 → ℕ := ![height_5, height_443_i6] +theorem height_exact_443_i5 : height_443_i5 = 1 + Finset.univ.sup childrenH_443_i5 := by decide +kernel +theorem required_origin_443_i5 : ∀ x ∈ required_443_i5, + (∃ j, x ∈ childrenC_443_i5 j) ∨ ∀ j, x ∈ childrenD_443_i5 j := by decide +kernel +theorem required_exact_443_i5 : required_443_i5 = + ((Finset.univ.biUnion childrenC_443_i5) ∪ commonEnvelope childrenD_443_i5).erase (3, 3) := by + exact required_eq_combination childrenC_443_i5 childrenD_443_i5 (3, 3) required_443_i5 + (by decide +kernel) child_required_sub_443_i5 common_sub_443_i5 required_origin_443_i5 +theorem envelope_origin_443_i5 : ∀ x ∈ envelope_443_i5, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_443_i5 j := by decide +kernel +theorem envelope_exact_443_i5 : envelope_443_i5 = + insert (3, 3) (Finset.univ.biUnion childrenD_443_i5) := by + exact envelope_eq_combination childrenD_443_i5 (3, 3) envelope_443_i5 + pivot_mem_443_i5 child_envelope_sub_443_i5 envelope_origin_443_i5 +def checked_443_i5 : CheckedCard where + required := required_443_i5 + envelope := envelope_443_i5 + height := height_443_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_443_i5 +def height_443_i4 : ℕ := 4 +def childrenH_443_i4 : Fin 2 → ℕ := ![height_5, height_443_i5] +theorem height_exact_443_i4 : height_443_i4 = 1 + Finset.univ.sup childrenH_443_i4 := by decide +kernel +theorem required_origin_443_i4 : ∀ x ∈ required_443_i4, + (∃ j, x ∈ childrenC_443_i4 j) ∨ ∀ j, x ∈ childrenD_443_i4 j := by decide +kernel +theorem required_exact_443_i4 : required_443_i4 = + ((Finset.univ.biUnion childrenC_443_i4) ∪ commonEnvelope childrenD_443_i4).erase (4, 1) := by + exact required_eq_combination childrenC_443_i4 childrenD_443_i4 (4, 1) required_443_i4 + (by decide +kernel) child_required_sub_443_i4 common_sub_443_i4 required_origin_443_i4 +theorem envelope_origin_443_i4 : ∀ x ∈ envelope_443_i4, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_443_i4 j := by decide +kernel +theorem envelope_exact_443_i4 : envelope_443_i4 = + insert (4, 1) (Finset.univ.biUnion childrenD_443_i4) := by + exact envelope_eq_combination childrenD_443_i4 (4, 1) envelope_443_i4 + pivot_mem_443_i4 child_envelope_sub_443_i4 envelope_origin_443_i4 +def checked_443_i4 : CheckedCard where + required := required_443_i4 + envelope := envelope_443_i4 + height := height_443_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_443_i4 +def height_443_i3 : ℕ := 5 +def childrenH_443_i3 : Fin 2 → ℕ := ![height_5, height_443_i4] +theorem height_exact_443_i3 : height_443_i3 = 1 + Finset.univ.sup childrenH_443_i3 := by decide +kernel +theorem required_origin_443_i3 : ∀ x ∈ required_443_i3, + (∃ j, x ∈ childrenC_443_i3 j) ∨ ∀ j, x ∈ childrenD_443_i3 j := by decide +kernel +theorem required_exact_443_i3 : required_443_i3 = + ((Finset.univ.biUnion childrenC_443_i3) ∪ commonEnvelope childrenD_443_i3).erase (2, 4) := by + exact required_eq_combination childrenC_443_i3 childrenD_443_i3 (2, 4) required_443_i3 + (by decide +kernel) child_required_sub_443_i3 common_sub_443_i3 required_origin_443_i3 +theorem envelope_origin_443_i3 : ∀ x ∈ envelope_443_i3, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_443_i3 j := by decide +kernel +theorem envelope_exact_443_i3 : envelope_443_i3 = + insert (2, 4) (Finset.univ.biUnion childrenD_443_i3) := by + exact envelope_eq_combination childrenD_443_i3 (2, 4) envelope_443_i3 + pivot_mem_443_i3 child_envelope_sub_443_i3 envelope_origin_443_i3 +def checked_443_i3 : CheckedCard where + required := required_443_i3 + envelope := envelope_443_i3 + height := height_443_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_443_i3 +def height_443_i2 : ℕ := 6 +def childrenH_443_i2 : Fin 2 → ℕ := ![height_4, height_443_i3] +theorem height_exact_443_i2 : height_443_i2 = 1 + Finset.univ.sup childrenH_443_i2 := by decide +kernel +theorem required_origin_443_i2 : ∀ x ∈ required_443_i2, + (∃ j, x ∈ childrenC_443_i2 j) ∨ ∀ j, x ∈ childrenD_443_i2 j := by decide +kernel +theorem required_exact_443_i2 : required_443_i2 = + ((Finset.univ.biUnion childrenC_443_i2) ∪ commonEnvelope childrenD_443_i2).erase (4, 0) := by + exact required_eq_combination childrenC_443_i2 childrenD_443_i2 (4, 0) required_443_i2 + (by decide +kernel) child_required_sub_443_i2 common_sub_443_i2 required_origin_443_i2 +theorem envelope_origin_443_i2 : ∀ x ∈ envelope_443_i2, + x = (4, 0) ∨ ∃ j, x ∈ childrenD_443_i2 j := by decide +kernel +theorem envelope_exact_443_i2 : envelope_443_i2 = + insert (4, 0) (Finset.univ.biUnion childrenD_443_i2) := by + exact envelope_eq_combination childrenD_443_i2 (4, 0) envelope_443_i2 + pivot_mem_443_i2 child_envelope_sub_443_i2 envelope_origin_443_i2 +def checked_443_i2 : CheckedCard where + required := required_443_i2 + envelope := envelope_443_i2 + height := height_443_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_443_i2 +def height_443_i1 : ℕ := 7 +def childrenH_443_i1 : Fin 2 → ℕ := ![height_4, height_443_i2] +theorem height_exact_443_i1 : height_443_i1 = 1 + Finset.univ.sup childrenH_443_i1 := by decide +kernel +theorem required_origin_443_i1 : ∀ x ∈ required_443_i1, + (∃ j, x ∈ childrenC_443_i1 j) ∨ ∀ j, x ∈ childrenD_443_i1 j := by decide +kernel +theorem required_exact_443_i1 : required_443_i1 = + ((Finset.univ.biUnion childrenC_443_i1) ∪ commonEnvelope childrenD_443_i1).erase (3, 1) := by + exact required_eq_combination childrenC_443_i1 childrenD_443_i1 (3, 1) required_443_i1 + (by decide +kernel) child_required_sub_443_i1 common_sub_443_i1 required_origin_443_i1 +theorem envelope_origin_443_i1 : ∀ x ∈ envelope_443_i1, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_443_i1 j := by decide +kernel +theorem envelope_exact_443_i1 : envelope_443_i1 = + insert (3, 1) (Finset.univ.biUnion childrenD_443_i1) := by + exact envelope_eq_combination childrenD_443_i1 (3, 1) envelope_443_i1 + pivot_mem_443_i1 child_envelope_sub_443_i1 envelope_origin_443_i1 +def checked_443_i1 : CheckedCard where + required := required_443_i1 + envelope := envelope_443_i1 + height := height_443_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_443_i1 +def height_443_i0 : ℕ := 8 +def childrenH_443_i0 : Fin 2 → ℕ := ![height_5, height_443_i1] +theorem height_exact_443_i0 : height_443_i0 = 1 + Finset.univ.sup childrenH_443_i0 := by decide +kernel +theorem required_origin_443_i0 : ∀ x ∈ required_443_i0, + (∃ j, x ∈ childrenC_443_i0 j) ∨ ∀ j, x ∈ childrenD_443_i0 j := by decide +kernel +theorem required_exact_443_i0 : required_443_i0 = + ((Finset.univ.biUnion childrenC_443_i0) ∪ commonEnvelope childrenD_443_i0).erase (0, 1) := by + exact required_eq_combination childrenC_443_i0 childrenD_443_i0 (0, 1) required_443_i0 + (by decide +kernel) child_required_sub_443_i0 common_sub_443_i0 required_origin_443_i0 +theorem envelope_origin_443_i0 : ∀ x ∈ envelope_443_i0, + x = (0, 1) ∨ ∃ j, x ∈ childrenD_443_i0 j := by decide +kernel +theorem envelope_exact_443_i0 : envelope_443_i0 = + insert (0, 1) (Finset.univ.biUnion childrenD_443_i0) := by + exact envelope_eq_combination childrenD_443_i0 (0, 1) envelope_443_i0 + pivot_mem_443_i0 child_envelope_sub_443_i0 envelope_origin_443_i0 +def checked_443_i0 : CheckedCard where + required := required_443_i0 + envelope := envelope_443_i0 + height := height_443_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_443_i0 +def height_443 : ℕ := 9 +def childrenH_443 : Fin 2 → ℕ := ![height_5, height_443_i0] +theorem height_exact_443 : height_443 = 1 + Finset.univ.sup childrenH_443 := by decide +kernel +theorem required_origin_443 : ∀ x ∈ required_443, + (∃ j, x ∈ childrenC_443 j) ∨ ∀ j, x ∈ childrenD_443 j := by decide +kernel +theorem required_exact_443 : required_443 = + ((Finset.univ.biUnion childrenC_443) ∪ commonEnvelope childrenD_443).erase (2, 1) := by + exact required_eq_combination childrenC_443 childrenD_443 (2, 1) required_443 + (by decide +kernel) child_required_sub_443 common_sub_443 required_origin_443 +theorem envelope_origin_443 : ∀ x ∈ envelope_443, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_443 j := by decide +kernel +theorem envelope_exact_443 : envelope_443 = + insert (2, 1) (Finset.univ.biUnion childrenD_443) := by + exact envelope_eq_combination childrenD_443 (2, 1) envelope_443 + pivot_mem_443 child_envelope_sub_443 envelope_origin_443 +def checked_443 : CheckedCard where + required := required_443 + envelope := envelope_443 + height := height_443 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_443 +def height_449 : ℕ := 9 +def childrenH_449 : Fin 5 → ℕ := ![height_10, height_27, height_48, height_63, height_448] +theorem height_exact_449 : height_449 = 1 + Finset.univ.sup childrenH_449 := by decide +kernel +theorem required_origin_449 : ∀ x ∈ required_449, + (∃ j, x ∈ childrenC_449 j) ∨ ∀ j, x ∈ childrenD_449 j := by decide +kernel +theorem required_exact_449 : required_449 = + ((Finset.univ.biUnion childrenC_449) ∪ commonEnvelope childrenD_449).erase (4, 3) := by + exact required_eq_combination childrenC_449 childrenD_449 (4, 3) required_449 + (by decide +kernel) child_required_sub_449 common_sub_449 required_origin_449 +theorem envelope_origin_449 : ∀ x ∈ envelope_449, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_449 j := by decide +kernel +theorem envelope_exact_449 : envelope_449 = + insert (4, 3) (Finset.univ.biUnion childrenD_449) := by + exact envelope_eq_combination childrenD_449 (4, 3) envelope_449 + pivot_mem_449 child_envelope_sub_449 envelope_origin_449 +def checked_449 : CheckedCard where + required := required_449 + envelope := envelope_449 + height := height_449 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_449 +def height_450 : ℕ := 9 +def childrenH_450 : Fin 2 → ℕ := ![height_0, height_448] +theorem height_exact_450 : height_450 = 1 + Finset.univ.sup childrenH_450 := by decide +kernel +theorem required_origin_450 : ∀ x ∈ required_450, + (∃ j, x ∈ childrenC_450 j) ∨ ∀ j, x ∈ childrenD_450 j := by decide +kernel +theorem required_exact_450 : required_450 = + ((Finset.univ.biUnion childrenC_450) ∪ commonEnvelope childrenD_450).erase (3, 4) := by + exact required_eq_combination childrenC_450 childrenD_450 (3, 4) required_450 + (by decide +kernel) child_required_sub_450 common_sub_450 required_origin_450 +theorem envelope_origin_450 : ∀ x ∈ envelope_450, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_450 j := by decide +kernel +theorem envelope_exact_450 : envelope_450 = + insert (3, 4) (Finset.univ.biUnion childrenD_450) := by + exact envelope_eq_combination childrenD_450 (3, 4) envelope_450 + pivot_mem_450 child_envelope_sub_450 envelope_origin_450 +def checked_450 : CheckedCard where + required := required_450 + envelope := envelope_450 + height := height_450 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_450 +def height_457 : ℕ := 9 +def childrenH_457 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_456] +theorem height_exact_457 : height_457 = 1 + Finset.univ.sup childrenH_457 := by decide +kernel +theorem required_origin_457 : ∀ x ∈ required_457, + (∃ j, x ∈ childrenC_457 j) ∨ ∀ j, x ∈ childrenD_457 j := by decide +kernel +theorem required_exact_457 : required_457 = + ((Finset.univ.biUnion childrenC_457) ∪ commonEnvelope childrenD_457).erase (1, 4) := by + exact required_eq_combination childrenC_457 childrenD_457 (1, 4) required_457 + (by decide +kernel) child_required_sub_457 common_sub_457 required_origin_457 +theorem envelope_origin_457 : ∀ x ∈ envelope_457, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_457 j := by decide +kernel +theorem envelope_exact_457 : envelope_457 = + insert (1, 4) (Finset.univ.biUnion childrenD_457) := by + exact envelope_eq_combination childrenD_457 (1, 4) envelope_457 + pivot_mem_457 child_envelope_sub_457 envelope_origin_457 +def checked_457 : CheckedCard where + required := required_457 + envelope := envelope_457 + height := height_457 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_457 +def height_458 : ℕ := 9 +def childrenH_458 : Fin 4 → ℕ := ![height_7, height_9, height_62, height_456] +theorem height_exact_458 : height_458 = 1 + Finset.univ.sup childrenH_458 := by decide +kernel +theorem required_origin_458 : ∀ x ∈ required_458, + (∃ j, x ∈ childrenC_458 j) ∨ ∀ j, x ∈ childrenD_458 j := by decide +kernel +theorem required_exact_458 : required_458 = + ((Finset.univ.biUnion childrenC_458) ∪ commonEnvelope childrenD_458).erase (1, 4) := by + exact required_eq_combination childrenC_458 childrenD_458 (1, 4) required_458 + (by decide +kernel) child_required_sub_458 common_sub_458 required_origin_458 +theorem envelope_origin_458 : ∀ x ∈ envelope_458, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_458 j := by decide +kernel +theorem envelope_exact_458 : envelope_458 = + insert (1, 4) (Finset.univ.biUnion childrenD_458) := by + exact envelope_eq_combination childrenD_458 (1, 4) envelope_458 + pivot_mem_458 child_envelope_sub_458 envelope_origin_458 +def checked_458 : CheckedCard where + required := required_458 + envelope := envelope_458 + height := height_458 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_458 +def height_470_i0 : ℕ := 4 +def childrenH_470_i0 : Fin 2 → ℕ := ![height_54, height_78] +theorem height_exact_470_i0 : height_470_i0 = 1 + Finset.univ.sup childrenH_470_i0 := by decide +kernel +theorem required_origin_470_i0 : ∀ x ∈ required_470_i0, + (∃ j, x ∈ childrenC_470_i0 j) ∨ ∀ j, x ∈ childrenD_470_i0 j := by decide +kernel +theorem required_exact_470_i0 : required_470_i0 = + ((Finset.univ.biUnion childrenC_470_i0) ∪ commonEnvelope childrenD_470_i0).erase (2, 3) := by + exact required_eq_combination childrenC_470_i0 childrenD_470_i0 (2, 3) required_470_i0 + (by decide +kernel) child_required_sub_470_i0 common_sub_470_i0 required_origin_470_i0 +theorem envelope_origin_470_i0 : ∀ x ∈ envelope_470_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_470_i0 j := by decide +kernel +theorem envelope_exact_470_i0 : envelope_470_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_470_i0) := by + exact envelope_eq_combination childrenD_470_i0 (2, 3) envelope_470_i0 + pivot_mem_470_i0 child_envelope_sub_470_i0 envelope_origin_470_i0 +def checked_470_i0 : CheckedCard where + required := required_470_i0 + envelope := envelope_470_i0 + height := height_470_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_470_i0 +def height_470_i2 : ℕ := 4 +def childrenH_470_i2 : Fin 2 → ℕ := ![height_2, height_78] +theorem height_exact_470_i2 : height_470_i2 = 1 + Finset.univ.sup childrenH_470_i2 := by decide +kernel +theorem required_origin_470_i2 : ∀ x ∈ required_470_i2, + (∃ j, x ∈ childrenC_470_i2 j) ∨ ∀ j, x ∈ childrenD_470_i2 j := by decide +kernel +theorem required_exact_470_i2 : required_470_i2 = + ((Finset.univ.biUnion childrenC_470_i2) ∪ commonEnvelope childrenD_470_i2).erase (2, 3) := by + exact required_eq_combination childrenC_470_i2 childrenD_470_i2 (2, 3) required_470_i2 + (by decide +kernel) child_required_sub_470_i2 common_sub_470_i2 required_origin_470_i2 +theorem envelope_origin_470_i2 : ∀ x ∈ envelope_470_i2, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_470_i2 j := by decide +kernel +theorem envelope_exact_470_i2 : envelope_470_i2 = + insert (2, 3) (Finset.univ.biUnion childrenD_470_i2) := by + exact envelope_eq_combination childrenD_470_i2 (2, 3) envelope_470_i2 + pivot_mem_470_i2 child_envelope_sub_470_i2 envelope_origin_470_i2 +def checked_470_i2 : CheckedCard where + required := required_470_i2 + envelope := envelope_470_i2 + height := height_470_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_470_i2 +def height_470_i1 : ℕ := 5 +def childrenH_470_i1 : Fin 2 → ℕ := ![height_56, height_470_i2] +theorem height_exact_470_i1 : height_470_i1 = 1 + Finset.univ.sup childrenH_470_i1 := by decide +kernel +theorem required_origin_470_i1 : ∀ x ∈ required_470_i1, + (∃ j, x ∈ childrenC_470_i1 j) ∨ ∀ j, x ∈ childrenD_470_i1 j := by decide +kernel +theorem required_exact_470_i1 : required_470_i1 = + ((Finset.univ.biUnion childrenC_470_i1) ∪ commonEnvelope childrenD_470_i1).erase (3, 6) := by + exact required_eq_combination childrenC_470_i1 childrenD_470_i1 (3, 6) required_470_i1 + (by decide +kernel) child_required_sub_470_i1 common_sub_470_i1 required_origin_470_i1 +theorem envelope_origin_470_i1 : ∀ x ∈ envelope_470_i1, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_470_i1 j := by decide +kernel +theorem envelope_exact_470_i1 : envelope_470_i1 = + insert (3, 6) (Finset.univ.biUnion childrenD_470_i1) := by + exact envelope_eq_combination childrenD_470_i1 (3, 6) envelope_470_i1 + pivot_mem_470_i1 child_envelope_sub_470_i1 envelope_origin_470_i1 +def checked_470_i1 : CheckedCard where + required := required_470_i1 + envelope := envelope_470_i1 + height := height_470_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_470_i1 +def height_470 : ℕ := 9 +def childrenH_470 : Fin 4 → ℕ := ![height_319, height_335, height_470_i0, height_470_i1] +theorem height_exact_470 : height_470 = 1 + Finset.univ.sup childrenH_470 := by decide +kernel +theorem required_origin_470 : ∀ x ∈ required_470, + (∃ j, x ∈ childrenC_470 j) ∨ ∀ j, x ∈ childrenD_470 j := by decide +kernel +theorem required_exact_470 : required_470 = + ((Finset.univ.biUnion childrenC_470) ∪ commonEnvelope childrenD_470).erase (3, 3) := by + exact required_eq_combination childrenC_470 childrenD_470 (3, 3) required_470 + (by decide +kernel) child_required_sub_470 common_sub_470 required_origin_470 +theorem envelope_origin_470 : ∀ x ∈ envelope_470, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_470 j := by decide +kernel +theorem envelope_exact_470 : envelope_470 = + insert (3, 3) (Finset.univ.biUnion childrenD_470) := by + exact envelope_eq_combination childrenD_470 (3, 3) envelope_470 + pivot_mem_470 child_envelope_sub_470 envelope_origin_470 +def checked_470 : CheckedCard where + required := required_470 + envelope := envelope_470 + height := height_470 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_470 +def height_474 : ℕ := 9 +def childrenH_474 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_473] +theorem height_exact_474 : height_474 = 1 + Finset.univ.sup childrenH_474 := by decide +kernel +theorem required_origin_474 : ∀ x ∈ required_474, + (∃ j, x ∈ childrenC_474 j) ∨ ∀ j, x ∈ childrenD_474 j := by decide +kernel +theorem required_exact_474 : required_474 = + ((Finset.univ.biUnion childrenC_474) ∪ commonEnvelope childrenD_474).erase (4, 2) := by + exact required_eq_combination childrenC_474 childrenD_474 (4, 2) required_474 + (by decide +kernel) child_required_sub_474 common_sub_474 required_origin_474 +theorem envelope_origin_474 : ∀ x ∈ envelope_474, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_474 j := by decide +kernel +theorem envelope_exact_474 : envelope_474 = + insert (4, 2) (Finset.univ.biUnion childrenD_474) := by + exact envelope_eq_combination childrenD_474 (4, 2) envelope_474 + pivot_mem_474 child_envelope_sub_474 envelope_origin_474 +def checked_474 : CheckedCard where + required := required_474 + envelope := envelope_474 + height := height_474 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_474 +def height_477 : ℕ := 9 +def childrenH_477 : Fin 4 → ℕ := ![height_7, height_9, height_62, height_473] +theorem height_exact_477 : height_477 = 1 + Finset.univ.sup childrenH_477 := by decide +kernel +theorem required_origin_477 : ∀ x ∈ required_477, + (∃ j, x ∈ childrenC_477 j) ∨ ∀ j, x ∈ childrenD_477 j := by decide +kernel +theorem required_exact_477 : required_477 = + ((Finset.univ.biUnion childrenC_477) ∪ commonEnvelope childrenD_477).erase (4, 2) := by + exact required_eq_combination childrenC_477 childrenD_477 (4, 2) required_477 + (by decide +kernel) child_required_sub_477 common_sub_477 required_origin_477 +theorem envelope_origin_477 : ∀ x ∈ envelope_477, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_477 j := by decide +kernel +theorem envelope_exact_477 : envelope_477 = + insert (4, 2) (Finset.univ.biUnion childrenD_477) := by + exact envelope_eq_combination childrenD_477 (4, 2) envelope_477 + pivot_mem_477 child_envelope_sub_477 envelope_origin_477 +def checked_477 : CheckedCard where + required := required_477 + envelope := envelope_477 + height := height_477 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_477 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part03.lean new file mode 100644 index 0000000..92ce48d --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part03.lean @@ -0,0 +1,902 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_512_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_512_i0 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_512_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_69), (placed21 0 (1, 1) required_416)] +def childrenD_512_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_69), (placed21 0 (1, 1) envelope_416)] +theorem common_sub_512_i0 : commonEnvelope childrenD_512_i0 ⊆ insert (3, 3) required_512_i0 := by decide +kernel +theorem child_required_sub_512_i0 : ∀ j, childrenC_512_i0 j ⊆ insert (3, 3) required_512_i0 := by decide +kernel +theorem child_envelope_sub_512_i0 : ∀ j, childrenD_512_i0 j ⊆ envelope_512_i0 := by decide +kernel +theorem pivot_mem_512_i0 : (3, 3) ∈ envelope_512_i0 := by decide +kernel +theorem children_work_512_i0 : ∀ j, Template HasSnaky 5 (childrenC_512_i0 j) (childrenD_512_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_69 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_416 0 (1, 1)).mono (by decide +kernel) +theorem row_works_512_i0 : Template HasSnaky 6 required_512_i0 envelope_512_i0 := by + refine compose HasSnaky 5 childrenC_512_i0 childrenD_512_i0 children_work_512_i0 (3, 3) + required_512_i0 envelope_512_i0 pivot_mem_512_i0 child_required_sub_512_i0 child_envelope_sub_512_i0 ?_ + intro b hb + exact common_sub_512_i0 (mem_commonEnvelope childrenD_512_i0 b hb) +def required_512_i3 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_512_i3 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (3, 4), (4, 4), (4, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_512_i3 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) required_0), (placed21 0 (1, 4) required_5)] +def childrenD_512_i3 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) envelope_0), (placed21 0 (1, 4) envelope_5)] +theorem common_sub_512_i3 : commonEnvelope childrenD_512_i3 ⊆ insert (3, 4) required_512_i3 := by decide +kernel +theorem child_required_sub_512_i3 : ∀ j, childrenC_512_i3 j ⊆ insert (3, 4) required_512_i3 := by decide +kernel +theorem child_envelope_sub_512_i3 : ∀ j, childrenD_512_i3 j ⊆ envelope_512_i3 := by decide +kernel +theorem pivot_mem_512_i3 : (3, 4) ∈ envelope_512_i3 := by decide +kernel +theorem children_work_512_i3 : ∀ j, Template HasSnaky 1 (childrenC_512_i3 j) (childrenD_512_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_5 0 (1, 4)).mono (by decide +kernel) +theorem row_works_512_i3 : Template HasSnaky 2 required_512_i3 envelope_512_i3 := by + refine compose HasSnaky 1 childrenC_512_i3 childrenD_512_i3 children_work_512_i3 (3, 4) + required_512_i3 envelope_512_i3 pivot_mem_512_i3 child_required_sub_512_i3 child_envelope_sub_512_i3 ?_ + intro b hb + exact common_sub_512_i3 (mem_commonEnvelope childrenD_512_i3 b hb) +def required_512_i4 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_512_i4 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_512_i4 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) required_18), (placed21 0 (1, 2) required_382)] +def childrenD_512_i4 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) envelope_18), (placed21 0 (1, 2) envelope_382)] +theorem common_sub_512_i4 : commonEnvelope childrenD_512_i4 ⊆ insert (3, 6) required_512_i4 := by decide +kernel +theorem child_required_sub_512_i4 : ∀ j, childrenC_512_i4 j ⊆ insert (3, 6) required_512_i4 := by decide +kernel +theorem child_envelope_sub_512_i4 : ∀ j, childrenD_512_i4 j ⊆ envelope_512_i4 := by decide +kernel +theorem pivot_mem_512_i4 : (3, 6) ∈ envelope_512_i4 := by decide +kernel +theorem children_work_512_i4 : ∀ j, Template HasSnaky 5 (childrenC_512_i4 j) (childrenD_512_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_382 0 (1, 2)).mono (by decide +kernel) +theorem row_works_512_i4 : Template HasSnaky 6 required_512_i4 envelope_512_i4 := by + refine compose HasSnaky 5 childrenC_512_i4 childrenD_512_i4 children_work_512_i4 (3, 6) + required_512_i4 envelope_512_i4 pivot_mem_512_i4 child_required_sub_512_i4 child_envelope_sub_512_i4 ?_ + intro b hb + exact common_sub_512_i4 (mem_commonEnvelope childrenD_512_i4 b hb) +def required_512_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_512_i2 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_512_i2 : Fin 2 → Finset Cell := ![required_512_i3, required_512_i4] +def childrenD_512_i2 : Fin 2 → Finset Cell := ![envelope_512_i3, envelope_512_i4] +theorem common_sub_512_i2 : commonEnvelope childrenD_512_i2 ⊆ insert (4, 5) required_512_i2 := by decide +kernel +theorem child_required_sub_512_i2 : ∀ j, childrenC_512_i2 j ⊆ insert (4, 5) required_512_i2 := by decide +kernel +theorem child_envelope_sub_512_i2 : ∀ j, childrenD_512_i2 j ⊆ envelope_512_i2 := by decide +kernel +theorem pivot_mem_512_i2 : (4, 5) ∈ envelope_512_i2 := by decide +kernel +theorem children_work_512_i2 : ∀ j, Template HasSnaky 6 (childrenC_512_i2 j) (childrenD_512_i2 j) := by + intro j + fin_cases j + · exact row_works_512_i3.mono (by decide +kernel) + · exact row_works_512_i4.mono (by decide +kernel) +theorem row_works_512_i2 : Template HasSnaky 7 required_512_i2 envelope_512_i2 := by + refine compose HasSnaky 6 childrenC_512_i2 childrenD_512_i2 children_work_512_i2 (4, 5) + required_512_i2 envelope_512_i2 pivot_mem_512_i2 child_required_sub_512_i2 child_envelope_sub_512_i2 ?_ + intro b hb + exact common_sub_512_i2 (mem_commonEnvelope childrenD_512_i2 b hb) +def required_512_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_512_i1 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_512_i1 : Fin 4 → Finset Cell := ![(placed21 3 (1, 4) required_30), (placed21 4 (1, 7) required_59), (placed21 0 (1, 1) required_511), required_512_i2] +def childrenD_512_i1 : Fin 4 → Finset Cell := ![(placed21 3 (1, 4) envelope_30), (placed21 4 (1, 7) envelope_59), (placed21 0 (1, 1) envelope_511), envelope_512_i2] +theorem common_sub_512_i1 : commonEnvelope childrenD_512_i1 ⊆ insert (4, 4) required_512_i1 := by decide +kernel +theorem child_required_sub_512_i1 : ∀ j, childrenC_512_i1 j ⊆ insert (4, 4) required_512_i1 := by decide +kernel +theorem child_envelope_sub_512_i1 : ∀ j, childrenD_512_i1 j ⊆ envelope_512_i1 := by decide +kernel +theorem pivot_mem_512_i1 : (4, 4) ∈ envelope_512_i1 := by decide +kernel +theorem children_work_512_i1 : ∀ j, Template HasSnaky 7 (childrenC_512_i1 j) (childrenD_512_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_30 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_59 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_511 0 (1, 1)).mono (by decide +kernel) + · exact row_works_512_i2.mono (by decide +kernel) +theorem row_works_512_i1 : Template HasSnaky 8 required_512_i1 envelope_512_i1 := by + refine compose HasSnaky 7 childrenC_512_i1 childrenD_512_i1 children_work_512_i1 (4, 4) + required_512_i1 envelope_512_i1 pivot_mem_512_i1 child_required_sub_512_i1 child_envelope_sub_512_i1 ?_ + intro b hb + exact common_sub_512_i1 (mem_commonEnvelope childrenD_512_i1 b hb) +def required_512 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_512 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_512 : Fin 4 → Finset Cell := ![(placed21 1 (1, 3) required_74), (placed21 0 (0, 1) required_108), required_512_i0, required_512_i1] +def childrenD_512 : Fin 4 → Finset Cell := ![(placed21 1 (1, 3) envelope_74), (placed21 0 (0, 1) envelope_108), envelope_512_i0, envelope_512_i1] +theorem common_sub_512 : commonEnvelope childrenD_512 ⊆ insert (4, 3) required_512 := by decide +kernel +theorem child_required_sub_512 : ∀ j, childrenC_512 j ⊆ insert (4, 3) required_512 := by decide +kernel +theorem child_envelope_sub_512 : ∀ j, childrenD_512 j ⊆ envelope_512 := by decide +kernel +theorem pivot_mem_512 : (4, 3) ∈ envelope_512 := by decide +kernel +theorem children_work_512 : ∀ j, Template HasSnaky 8 (childrenC_512 j) (childrenD_512 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_74 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_108 0 (0, 1)).mono (by decide +kernel) + · exact row_works_512_i0.mono (by decide +kernel) + · exact row_works_512_i1.mono (by decide +kernel) +theorem row_works_512 : Template HasSnaky 9 required_512 envelope_512 := by + refine compose HasSnaky 8 childrenC_512 childrenD_512 children_work_512 (4, 3) + required_512 envelope_512 pivot_mem_512 child_required_sub_512 child_envelope_sub_512 ?_ + intro b hb + exact common_sub_512 (mem_commonEnvelope childrenD_512 b hb) +def required_514 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_514 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_514 : Fin 3 → Finset Cell := ![(placed21 7 (5, 2) required_34), (placed21 5 (5, 1) required_149), required_513] +def childrenD_514 : Fin 3 → Finset Cell := ![(placed21 7 (5, 2) envelope_34), (placed21 5 (5, 1) envelope_149), envelope_513] +theorem common_sub_514 : commonEnvelope childrenD_514 ⊆ insert (3, 2) required_514 := by decide +kernel +theorem child_required_sub_514 : ∀ j, childrenC_514 j ⊆ insert (3, 2) required_514 := by decide +kernel +theorem child_envelope_sub_514 : ∀ j, childrenD_514 j ⊆ envelope_514 := by decide +kernel +theorem pivot_mem_514 : (3, 2) ∈ envelope_514 := by decide +kernel +theorem children_work_514 : ∀ j, Template HasSnaky 8 (childrenC_514 j) (childrenD_514 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_34 7 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_149 5 (5, 1)).mono (by decide +kernel) + · exact row_works_513.mono (by decide +kernel) +theorem row_works_514 : Template HasSnaky 9 required_514 envelope_514 := by + refine compose HasSnaky 8 childrenC_514 childrenD_514 children_work_514 (3, 2) + required_514 envelope_514 pivot_mem_514 child_required_sub_514 child_envelope_sub_514 ?_ + intro b hb + exact common_sub_514 (mem_commonEnvelope childrenD_514 b hb) +def required_519 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_519 : Finset Cell := ⟨(([(0, 6), (1, 3), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 5), (6, 2), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_519 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) required_10), (placed21 3 (1, 6) required_47), (placed21 6 (3, 6) required_52), (placed21 2 (6, 0) required_518)] +def childrenD_519 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) envelope_10), (placed21 3 (1, 6) envelope_47), (placed21 6 (3, 6) envelope_52), (placed21 2 (6, 0) envelope_518)] +theorem common_sub_519 : commonEnvelope childrenD_519 ⊆ insert (3, 5) required_519 := by decide +kernel +theorem child_required_sub_519 : ∀ j, childrenC_519 j ⊆ insert (3, 5) required_519 := by decide +kernel +theorem child_envelope_sub_519 : ∀ j, childrenD_519 j ⊆ envelope_519 := by decide +kernel +theorem pivot_mem_519 : (3, 5) ∈ envelope_519 := by decide +kernel +theorem children_work_519 : ∀ j, Template HasSnaky 8 (childrenC_519 j) (childrenD_519 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_47 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_518 2 (6, 0)).mono (by decide +kernel) +theorem row_works_519 : Template HasSnaky 9 required_519 envelope_519 := by + refine compose HasSnaky 8 childrenC_519 childrenD_519 children_work_519 (3, 5) + required_519 envelope_519 pivot_mem_519 child_required_sub_519 child_envelope_sub_519 ?_ + intro b hb + exact common_sub_519 (mem_commonEnvelope childrenD_519 b hb) +def required_528_i0 : Finset Cell := ⟨(([(0, 7), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_528_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_528_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 3) required_4), (placed21 7 (2, 6) required_49)] +def childrenD_528_i0 : Fin 2 → Finset Cell := ![(placed21 5 (1, 3) envelope_4), (placed21 7 (2, 6) envelope_49)] +theorem common_sub_528_i0 : commonEnvelope childrenD_528_i0 ⊆ insert (1, 3) required_528_i0 := by decide +kernel +theorem child_required_sub_528_i0 : ∀ j, childrenC_528_i0 j ⊆ insert (1, 3) required_528_i0 := by decide +kernel +theorem child_envelope_sub_528_i0 : ∀ j, childrenD_528_i0 j ⊆ envelope_528_i0 := by decide +kernel +theorem pivot_mem_528_i0 : (1, 3) ∈ envelope_528_i0 := by decide +kernel +theorem children_work_528_i0 : ∀ j, Template HasSnaky 4 (childrenC_528_i0 j) (childrenD_528_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 5 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_49 7 (2, 6)).mono (by decide +kernel) +theorem row_works_528_i0 : Template HasSnaky 5 required_528_i0 envelope_528_i0 := by + refine compose HasSnaky 4 childrenC_528_i0 childrenD_528_i0 children_work_528_i0 (1, 3) + required_528_i0 envelope_528_i0 pivot_mem_528_i0 child_required_sub_528_i0 child_envelope_sub_528_i0 ?_ + intro b hb + exact common_sub_528_i0 (mem_commonEnvelope childrenD_528_i0 b hb) +def required_528_i1 : Finset Cell := ⟨(([(0, 4), (0, 7), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_528_i1 : Finset Cell := ⟨(([(0, 4), (0, 7), (0, 8), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_528_i1 : Fin 2 → Finset Cell := ![(placed21 5 (1, 4) required_5), (placed21 0 (0, 1) required_446)] +def childrenD_528_i1 : Fin 2 → Finset Cell := ![(placed21 5 (1, 4) envelope_5), (placed21 0 (0, 1) envelope_446)] +theorem common_sub_528_i1 : commonEnvelope childrenD_528_i1 ⊆ insert (1, 7) required_528_i1 := by decide +kernel +theorem child_required_sub_528_i1 : ∀ j, childrenC_528_i1 j ⊆ insert (1, 7) required_528_i1 := by decide +kernel +theorem child_envelope_sub_528_i1 : ∀ j, childrenD_528_i1 j ⊆ envelope_528_i1 := by decide +kernel +theorem pivot_mem_528_i1 : (1, 7) ∈ envelope_528_i1 := by decide +kernel +theorem children_work_528_i1 : ∀ j, Template HasSnaky 7 (childrenC_528_i1 j) (childrenD_528_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_446 0 (0, 1)).mono (by decide +kernel) +theorem row_works_528_i1 : Template HasSnaky 8 required_528_i1 envelope_528_i1 := by + refine compose HasSnaky 7 childrenC_528_i1 childrenD_528_i1 children_work_528_i1 (1, 7) + required_528_i1 envelope_528_i1 pivot_mem_528_i1 child_required_sub_528_i1 child_envelope_sub_528_i1 ?_ + intro b hb + exact common_sub_528_i1 (mem_commonEnvelope childrenD_528_i1 b hb) +def required_528 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 5), (1, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_528 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 4), (0, 6), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_528 : Fin 3 → Finset Cell := ![(placed21 2 (1, 3) required_61), required_528_i0, required_528_i1] +def childrenD_528 : Fin 3 → Finset Cell := ![(placed21 2 (1, 3) envelope_61), envelope_528_i0, envelope_528_i1] +theorem common_sub_528 : commonEnvelope childrenD_528 ⊆ insert (0, 7) required_528 := by decide +kernel +theorem child_required_sub_528 : ∀ j, childrenC_528 j ⊆ insert (0, 7) required_528 := by decide +kernel +theorem child_envelope_sub_528 : ∀ j, childrenD_528 j ⊆ envelope_528 := by decide +kernel +theorem pivot_mem_528 : (0, 7) ∈ envelope_528 := by decide +kernel +theorem children_work_528 : ∀ j, Template HasSnaky 8 (childrenC_528 j) (childrenD_528 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_61 2 (1, 3)).mono (by decide +kernel) + · exact row_works_528_i0.mono (by decide +kernel) + · exact row_works_528_i1.mono (by decide +kernel) +theorem row_works_528 : Template HasSnaky 9 required_528 envelope_528 := by + refine compose HasSnaky 8 childrenC_528 childrenD_528 children_work_528 (0, 7) + required_528 envelope_528 pivot_mem_528 child_required_sub_528 child_envelope_sub_528 ?_ + intro b hb + exact common_sub_528 (mem_commonEnvelope childrenD_528 b hb) +def required_531 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 3), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_531 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_531 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) required_0), required_530] +def childrenD_531 : Fin 2 → Finset Cell := ![(placed21 1 (0, 0) envelope_0), envelope_530] +theorem common_sub_531 : commonEnvelope childrenD_531 ⊆ insert (1, 4) required_531 := by decide +kernel +theorem child_required_sub_531 : ∀ j, childrenC_531 j ⊆ insert (1, 4) required_531 := by decide +kernel +theorem child_envelope_sub_531 : ∀ j, childrenD_531 j ⊆ envelope_531 := by decide +kernel +theorem pivot_mem_531 : (1, 4) ∈ envelope_531 := by decide +kernel +theorem children_work_531 : ∀ j, Template HasSnaky 8 (childrenC_531 j) (childrenD_531 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 0)).mono (by decide +kernel) + · exact row_works_530.mono (by decide +kernel) +theorem row_works_531 : Template HasSnaky 9 required_531 envelope_531 := by + refine compose HasSnaky 8 childrenC_531 childrenD_531 children_work_531 (1, 4) + required_531 envelope_531 pivot_mem_531 child_required_sub_531 child_envelope_sub_531 ?_ + intro b hb + exact common_sub_531 (mem_commonEnvelope childrenD_531 b hb) +def required_536 : Finset Cell := ⟨(([(3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_536 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (6, 3), (6, 4), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_536 : Fin 4 → Finset Cell := ![(placed21 2 (4, 1) required_14), (placed21 7 (6, 6) required_88), (placed21 5 (6, 2) required_213), (placed21 3 (0, 6) required_534)] +def childrenD_536 : Fin 4 → Finset Cell := ![(placed21 2 (4, 1) envelope_14), (placed21 7 (6, 6) envelope_88), (placed21 5 (6, 2) envelope_213), (placed21 3 (0, 6) envelope_534)] +theorem common_sub_536 : commonEnvelope childrenD_536 ⊆ insert (3, 5) required_536 := by decide +kernel +theorem child_required_sub_536 : ∀ j, childrenC_536 j ⊆ insert (3, 5) required_536 := by decide +kernel +theorem child_envelope_sub_536 : ∀ j, childrenD_536 j ⊆ envelope_536 := by decide +kernel +theorem pivot_mem_536 : (3, 5) ∈ envelope_536 := by decide +kernel +theorem children_work_536 : ∀ j, Template HasSnaky 8 (childrenC_536 j) (childrenD_536 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_88 7 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_213 5 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_534 3 (0, 6)).mono (by decide +kernel) +theorem row_works_536 : Template HasSnaky 9 required_536 envelope_536 := by + refine compose HasSnaky 8 childrenC_536 childrenD_536 children_work_536 (3, 5) + required_536 envelope_536 pivot_mem_536 child_required_sub_536 child_envelope_sub_536 ?_ + intro b hb + exact common_sub_536 (mem_commonEnvelope childrenD_536 b hb) +def required_537_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_537_i0 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_537_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) required_45), (placed21 0 (1, 2) required_418)] +def childrenD_537_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) envelope_45), (placed21 0 (1, 2) envelope_418)] +theorem common_sub_537_i0 : commonEnvelope childrenD_537_i0 ⊆ insert (3, 3) required_537_i0 := by decide +kernel +theorem child_required_sub_537_i0 : ∀ j, childrenC_537_i0 j ⊆ insert (3, 3) required_537_i0 := by decide +kernel +theorem child_envelope_sub_537_i0 : ∀ j, childrenD_537_i0 j ⊆ envelope_537_i0 := by decide +kernel +theorem pivot_mem_537_i0 : (3, 3) ∈ envelope_537_i0 := by decide +kernel +theorem children_work_537_i0 : ∀ j, Template HasSnaky 7 (childrenC_537_i0 j) (childrenD_537_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_45 6 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_418 0 (1, 2)).mono (by decide +kernel) +theorem row_works_537_i0 : Template HasSnaky 8 required_537_i0 envelope_537_i0 := by + refine compose HasSnaky 7 childrenC_537_i0 childrenD_537_i0 children_work_537_i0 (3, 3) + required_537_i0 envelope_537_i0 pivot_mem_537_i0 child_required_sub_537_i0 child_envelope_sub_537_i0 ?_ + intro b hb + exact common_sub_537_i0 (mem_commonEnvelope childrenD_537_i0 b hb) +def required_537_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_537_i2 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_537_i2 : Fin 2 → Finset Cell := ![(placed21 6 (2, 6) required_15), (placed21 0 (1, 2) required_425)] +def childrenD_537_i2 : Fin 2 → Finset Cell := ![(placed21 6 (2, 6) envelope_15), (placed21 0 (1, 2) envelope_425)] +theorem common_sub_537_i2 : commonEnvelope childrenD_537_i2 ⊆ insert (2, 5) required_537_i2 := by decide +kernel +theorem child_required_sub_537_i2 : ∀ j, childrenC_537_i2 j ⊆ insert (2, 5) required_537_i2 := by decide +kernel +theorem child_envelope_sub_537_i2 : ∀ j, childrenD_537_i2 j ⊆ envelope_537_i2 := by decide +kernel +theorem pivot_mem_537_i2 : (2, 5) ∈ envelope_537_i2 := by decide +kernel +theorem children_work_537_i2 : ∀ j, Template HasSnaky 5 (childrenC_537_i2 j) (childrenD_537_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_425 0 (1, 2)).mono (by decide +kernel) +theorem row_works_537_i2 : Template HasSnaky 6 required_537_i2 envelope_537_i2 := by + refine compose HasSnaky 5 childrenC_537_i2 childrenD_537_i2 children_work_537_i2 (2, 5) + required_537_i2 envelope_537_i2 pivot_mem_537_i2 child_required_sub_537_i2 child_envelope_sub_537_i2 ?_ + intro b hb + exact common_sub_537_i2 (mem_commonEnvelope childrenD_537_i2 b hb) +def required_537_i6 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_537_i6 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_537_i6 : Fin 2 → Finset Cell := ![(placed21 1 (2, 2) required_0), (placed21 2 (2, 2) required_23)] +def childrenD_537_i6 : Fin 2 → Finset Cell := ![(placed21 1 (2, 2) envelope_0), (placed21 2 (2, 2) envelope_23)] +theorem common_sub_537_i6 : commonEnvelope childrenD_537_i6 ⊆ insert (2, 5) required_537_i6 := by decide +kernel +theorem child_required_sub_537_i6 : ∀ j, childrenC_537_i6 j ⊆ insert (2, 5) required_537_i6 := by decide +kernel +theorem child_envelope_sub_537_i6 : ∀ j, childrenD_537_i6 j ⊆ envelope_537_i6 := by decide +kernel +theorem pivot_mem_537_i6 : (2, 5) ∈ envelope_537_i6 := by decide +kernel +theorem children_work_537_i6 : ∀ j, Template HasSnaky 2 (childrenC_537_i6 j) (childrenD_537_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_23 2 (2, 2)).mono (by decide +kernel) +theorem row_works_537_i6 : Template HasSnaky 3 required_537_i6 envelope_537_i6 := by + refine compose HasSnaky 2 childrenC_537_i6 childrenD_537_i6 children_work_537_i6 (2, 5) + required_537_i6 envelope_537_i6 pivot_mem_537_i6 child_required_sub_537_i6 child_envelope_sub_537_i6 ?_ + intro b hb + exact common_sub_537_i6 (mem_commonEnvelope childrenD_537_i6 b hb) +def required_537_i5 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (3, 6), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_537_i5 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_537_i5 : Fin 2 → Finset Cell := ![(placed21 5 (4, 2) required_0), required_537_i6] +def childrenD_537_i5 : Fin 2 → Finset Cell := ![(placed21 5 (4, 2) envelope_0), envelope_537_i6] +theorem common_sub_537_i5 : commonEnvelope childrenD_537_i5 ⊆ insert (3, 5) required_537_i5 := by decide +kernel +theorem child_required_sub_537_i5 : ∀ j, childrenC_537_i5 j ⊆ insert (3, 5) required_537_i5 := by decide +kernel +theorem child_envelope_sub_537_i5 : ∀ j, childrenD_537_i5 j ⊆ envelope_537_i5 := by decide +kernel +theorem pivot_mem_537_i5 : (3, 5) ∈ envelope_537_i5 := by decide +kernel +theorem children_work_537_i5 : ∀ j, Template HasSnaky 3 (childrenC_537_i5 j) (childrenD_537_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 5 (4, 2)).mono (by decide +kernel) + · exact row_works_537_i6.mono (by decide +kernel) +theorem row_works_537_i5 : Template HasSnaky 4 required_537_i5 envelope_537_i5 := by + refine compose HasSnaky 3 childrenC_537_i5 childrenD_537_i5 children_work_537_i5 (3, 5) + required_537_i5 envelope_537_i5 pivot_mem_537_i5 child_required_sub_537_i5 child_envelope_sub_537_i5 ?_ + intro b hb + exact common_sub_537_i5 (mem_commonEnvelope childrenD_537_i5 b hb) +def required_537_i4 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_537_i4 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 6), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_537_i4 : Fin 3 → Finset Cell := ![(placed21 2 (4, 2) required_139), (placed21 0 (1, 2) required_382), required_537_i5] +def childrenD_537_i4 : Fin 3 → Finset Cell := ![(placed21 2 (4, 2) envelope_139), (placed21 0 (1, 2) envelope_382), envelope_537_i5] +theorem common_sub_537_i4 : commonEnvelope childrenD_537_i4 ⊆ insert (3, 6) required_537_i4 := by decide +kernel +theorem child_required_sub_537_i4 : ∀ j, childrenC_537_i4 j ⊆ insert (3, 6) required_537_i4 := by decide +kernel +theorem child_envelope_sub_537_i4 : ∀ j, childrenD_537_i4 j ⊆ envelope_537_i4 := by decide +kernel +theorem pivot_mem_537_i4 : (3, 6) ∈ envelope_537_i4 := by decide +kernel +theorem children_work_537_i4 : ∀ j, Template HasSnaky 5 (childrenC_537_i4 j) (childrenD_537_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_139 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_382 0 (1, 2)).mono (by decide +kernel) + · exact row_works_537_i5.mono (by decide +kernel) +theorem row_works_537_i4 : Template HasSnaky 6 required_537_i4 envelope_537_i4 := by + refine compose HasSnaky 5 childrenC_537_i4 childrenD_537_i4 children_work_537_i4 (3, 6) + required_537_i4 envelope_537_i4 pivot_mem_537_i4 child_required_sub_537_i4 child_envelope_sub_537_i4 ?_ + intro b hb + exact common_sub_537_i4 (mem_commonEnvelope childrenD_537_i4 b hb) +def required_537_i3 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_537_i3 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 6), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_537_i3 : Fin 3 → Finset Cell := ![(placed21 2 (5, 1) required_13), (placed21 3 (1, 4) required_30), required_537_i4] +def childrenD_537_i3 : Fin 3 → Finset Cell := ![(placed21 2 (5, 1) envelope_13), (placed21 3 (1, 4) envelope_30), envelope_537_i4] +theorem common_sub_537_i3 : commonEnvelope childrenD_537_i3 ⊆ insert (4, 4) required_537_i3 := by decide +kernel +theorem child_required_sub_537_i3 : ∀ j, childrenC_537_i3 j ⊆ insert (4, 4) required_537_i3 := by decide +kernel +theorem child_envelope_sub_537_i3 : ∀ j, childrenD_537_i3 j ⊆ envelope_537_i3 := by decide +kernel +theorem pivot_mem_537_i3 : (4, 4) ∈ envelope_537_i3 := by decide +kernel +theorem children_work_537_i3 : ∀ j, Template HasSnaky 6 (childrenC_537_i3 j) (childrenD_537_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 2 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_30 3 (1, 4)).mono (by decide +kernel) + · exact row_works_537_i4.mono (by decide +kernel) +theorem row_works_537_i3 : Template HasSnaky 7 required_537_i3 envelope_537_i3 := by + refine compose HasSnaky 6 childrenC_537_i3 childrenD_537_i3 children_work_537_i3 (4, 4) + required_537_i3 envelope_537_i3 pivot_mem_537_i3 child_required_sub_537_i3 child_envelope_sub_537_i3 ?_ + intro b hb + exact common_sub_537_i3 (mem_commonEnvelope childrenD_537_i3 b hb) +def required_537_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_537_i1 : Finset Cell := ⟨(([(1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_537_i1 : Fin 4 → Finset Cell := ![(placed21 0 (1, 1) required_166), (placed21 4 (1, 7) required_464), required_537_i2, required_537_i3] +def childrenD_537_i1 : Fin 4 → Finset Cell := ![(placed21 0 (1, 1) envelope_166), (placed21 4 (1, 7) envelope_464), envelope_537_i2, envelope_537_i3] +theorem common_sub_537_i1 : commonEnvelope childrenD_537_i1 ⊆ insert (4, 5) required_537_i1 := by decide +kernel +theorem child_required_sub_537_i1 : ∀ j, childrenC_537_i1 j ⊆ insert (4, 5) required_537_i1 := by decide +kernel +theorem child_envelope_sub_537_i1 : ∀ j, childrenD_537_i1 j ⊆ envelope_537_i1 := by decide +kernel +theorem pivot_mem_537_i1 : (4, 5) ∈ envelope_537_i1 := by decide +kernel +theorem children_work_537_i1 : ∀ j, Template HasSnaky 7 (childrenC_537_i1 j) (childrenD_537_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_166 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_464 4 (1, 7)).mono (by decide +kernel) + · exact row_works_537_i2.mono (by decide +kernel) + · exact row_works_537_i3.mono (by decide +kernel) +theorem row_works_537_i1 : Template HasSnaky 8 required_537_i1 envelope_537_i1 := by + refine compose HasSnaky 7 childrenC_537_i1 childrenD_537_i1 children_work_537_i1 (4, 5) + required_537_i1 envelope_537_i1 pivot_mem_537_i1 child_required_sub_537_i1 child_envelope_sub_537_i1 ?_ + intro b hb + exact common_sub_537_i1 (mem_commonEnvelope childrenD_537_i1 b hb) +def required_537 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_537 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_537 : Fin 4 → Finset Cell := ![(placed21 1 (1, 3) required_74), (placed21 0 (0, 1) required_108), required_537_i0, required_537_i1] +def childrenD_537 : Fin 4 → Finset Cell := ![(placed21 1 (1, 3) envelope_74), (placed21 0 (0, 1) envelope_108), envelope_537_i0, envelope_537_i1] +theorem common_sub_537 : commonEnvelope childrenD_537 ⊆ insert (4, 3) required_537 := by decide +kernel +theorem child_required_sub_537 : ∀ j, childrenC_537 j ⊆ insert (4, 3) required_537 := by decide +kernel +theorem child_envelope_sub_537 : ∀ j, childrenD_537 j ⊆ envelope_537 := by decide +kernel +theorem pivot_mem_537 : (4, 3) ∈ envelope_537 := by decide +kernel +theorem children_work_537 : ∀ j, Template HasSnaky 8 (childrenC_537 j) (childrenD_537 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_74 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_108 0 (0, 1)).mono (by decide +kernel) + · exact row_works_537_i0.mono (by decide +kernel) + · exact row_works_537_i1.mono (by decide +kernel) +theorem row_works_537 : Template HasSnaky 9 required_537 envelope_537 := by + refine compose HasSnaky 8 childrenC_537 childrenD_537 children_work_537 (4, 3) + required_537 envelope_537 pivot_mem_537 child_required_sub_537 child_envelope_sub_537 ?_ + intro b hb + exact common_sub_537 (mem_commonEnvelope childrenD_537 b hb) +def height_512_i0 : ℕ := 6 +def childrenH_512_i0 : Fin 2 → ℕ := ![height_69, height_416] +theorem height_exact_512_i0 : height_512_i0 = 1 + Finset.univ.sup childrenH_512_i0 := by decide +kernel +theorem required_origin_512_i0 : ∀ x ∈ required_512_i0, + (∃ j, x ∈ childrenC_512_i0 j) ∨ ∀ j, x ∈ childrenD_512_i0 j := by decide +kernel +theorem required_exact_512_i0 : required_512_i0 = + ((Finset.univ.biUnion childrenC_512_i0) ∪ commonEnvelope childrenD_512_i0).erase (3, 3) := by + exact required_eq_combination childrenC_512_i0 childrenD_512_i0 (3, 3) required_512_i0 + (by decide +kernel) child_required_sub_512_i0 common_sub_512_i0 required_origin_512_i0 +theorem envelope_origin_512_i0 : ∀ x ∈ envelope_512_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_512_i0 j := by decide +kernel +theorem envelope_exact_512_i0 : envelope_512_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_512_i0) := by + exact envelope_eq_combination childrenD_512_i0 (3, 3) envelope_512_i0 + pivot_mem_512_i0 child_envelope_sub_512_i0 envelope_origin_512_i0 +def checked_512_i0 : CheckedCard where + required := required_512_i0 + envelope := envelope_512_i0 + height := height_512_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_512_i0 +def height_512_i3 : ℕ := 2 +def childrenH_512_i3 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_512_i3 : height_512_i3 = 1 + Finset.univ.sup childrenH_512_i3 := by decide +kernel +theorem required_origin_512_i3 : ∀ x ∈ required_512_i3, + (∃ j, x ∈ childrenC_512_i3 j) ∨ ∀ j, x ∈ childrenD_512_i3 j := by decide +kernel +theorem required_exact_512_i3 : required_512_i3 = + ((Finset.univ.biUnion childrenC_512_i3) ∪ commonEnvelope childrenD_512_i3).erase (3, 4) := by + exact required_eq_combination childrenC_512_i3 childrenD_512_i3 (3, 4) required_512_i3 + (by decide +kernel) child_required_sub_512_i3 common_sub_512_i3 required_origin_512_i3 +theorem envelope_origin_512_i3 : ∀ x ∈ envelope_512_i3, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_512_i3 j := by decide +kernel +theorem envelope_exact_512_i3 : envelope_512_i3 = + insert (3, 4) (Finset.univ.biUnion childrenD_512_i3) := by + exact envelope_eq_combination childrenD_512_i3 (3, 4) envelope_512_i3 + pivot_mem_512_i3 child_envelope_sub_512_i3 envelope_origin_512_i3 +def checked_512_i3 : CheckedCard where + required := required_512_i3 + envelope := envelope_512_i3 + height := height_512_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_512_i3 +def height_512_i4 : ℕ := 6 +def childrenH_512_i4 : Fin 2 → ℕ := ![height_18, height_382] +theorem height_exact_512_i4 : height_512_i4 = 1 + Finset.univ.sup childrenH_512_i4 := by decide +kernel +theorem required_origin_512_i4 : ∀ x ∈ required_512_i4, + (∃ j, x ∈ childrenC_512_i4 j) ∨ ∀ j, x ∈ childrenD_512_i4 j := by decide +kernel +theorem required_exact_512_i4 : required_512_i4 = + ((Finset.univ.biUnion childrenC_512_i4) ∪ commonEnvelope childrenD_512_i4).erase (3, 6) := by + exact required_eq_combination childrenC_512_i4 childrenD_512_i4 (3, 6) required_512_i4 + (by decide +kernel) child_required_sub_512_i4 common_sub_512_i4 required_origin_512_i4 +theorem envelope_origin_512_i4 : ∀ x ∈ envelope_512_i4, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_512_i4 j := by decide +kernel +theorem envelope_exact_512_i4 : envelope_512_i4 = + insert (3, 6) (Finset.univ.biUnion childrenD_512_i4) := by + exact envelope_eq_combination childrenD_512_i4 (3, 6) envelope_512_i4 + pivot_mem_512_i4 child_envelope_sub_512_i4 envelope_origin_512_i4 +def checked_512_i4 : CheckedCard where + required := required_512_i4 + envelope := envelope_512_i4 + height := height_512_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_512_i4 +def height_512_i2 : ℕ := 7 +def childrenH_512_i2 : Fin 2 → ℕ := ![height_512_i3, height_512_i4] +theorem height_exact_512_i2 : height_512_i2 = 1 + Finset.univ.sup childrenH_512_i2 := by decide +kernel +theorem required_origin_512_i2 : ∀ x ∈ required_512_i2, + (∃ j, x ∈ childrenC_512_i2 j) ∨ ∀ j, x ∈ childrenD_512_i2 j := by decide +kernel +theorem required_exact_512_i2 : required_512_i2 = + ((Finset.univ.biUnion childrenC_512_i2) ∪ commonEnvelope childrenD_512_i2).erase (4, 5) := by + exact required_eq_combination childrenC_512_i2 childrenD_512_i2 (4, 5) required_512_i2 + (by decide +kernel) child_required_sub_512_i2 common_sub_512_i2 required_origin_512_i2 +theorem envelope_origin_512_i2 : ∀ x ∈ envelope_512_i2, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_512_i2 j := by decide +kernel +theorem envelope_exact_512_i2 : envelope_512_i2 = + insert (4, 5) (Finset.univ.biUnion childrenD_512_i2) := by + exact envelope_eq_combination childrenD_512_i2 (4, 5) envelope_512_i2 + pivot_mem_512_i2 child_envelope_sub_512_i2 envelope_origin_512_i2 +def checked_512_i2 : CheckedCard where + required := required_512_i2 + envelope := envelope_512_i2 + height := height_512_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_512_i2 +def height_512_i1 : ℕ := 8 +def childrenH_512_i1 : Fin 4 → ℕ := ![height_30, height_59, height_511, height_512_i2] +theorem height_exact_512_i1 : height_512_i1 = 1 + Finset.univ.sup childrenH_512_i1 := by decide +kernel +theorem required_origin_512_i1 : ∀ x ∈ required_512_i1, + (∃ j, x ∈ childrenC_512_i1 j) ∨ ∀ j, x ∈ childrenD_512_i1 j := by decide +kernel +theorem required_exact_512_i1 : required_512_i1 = + ((Finset.univ.biUnion childrenC_512_i1) ∪ commonEnvelope childrenD_512_i1).erase (4, 4) := by + exact required_eq_combination childrenC_512_i1 childrenD_512_i1 (4, 4) required_512_i1 + (by decide +kernel) child_required_sub_512_i1 common_sub_512_i1 required_origin_512_i1 +theorem envelope_origin_512_i1 : ∀ x ∈ envelope_512_i1, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_512_i1 j := by decide +kernel +theorem envelope_exact_512_i1 : envelope_512_i1 = + insert (4, 4) (Finset.univ.biUnion childrenD_512_i1) := by + exact envelope_eq_combination childrenD_512_i1 (4, 4) envelope_512_i1 + pivot_mem_512_i1 child_envelope_sub_512_i1 envelope_origin_512_i1 +def checked_512_i1 : CheckedCard where + required := required_512_i1 + envelope := envelope_512_i1 + height := height_512_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_512_i1 +def height_512 : ℕ := 9 +def childrenH_512 : Fin 4 → ℕ := ![height_74, height_108, height_512_i0, height_512_i1] +theorem height_exact_512 : height_512 = 1 + Finset.univ.sup childrenH_512 := by decide +kernel +theorem required_origin_512 : ∀ x ∈ required_512, + (∃ j, x ∈ childrenC_512 j) ∨ ∀ j, x ∈ childrenD_512 j := by decide +kernel +theorem required_exact_512 : required_512 = + ((Finset.univ.biUnion childrenC_512) ∪ commonEnvelope childrenD_512).erase (4, 3) := by + exact required_eq_combination childrenC_512 childrenD_512 (4, 3) required_512 + (by decide +kernel) child_required_sub_512 common_sub_512 required_origin_512 +theorem envelope_origin_512 : ∀ x ∈ envelope_512, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_512 j := by decide +kernel +theorem envelope_exact_512 : envelope_512 = + insert (4, 3) (Finset.univ.biUnion childrenD_512) := by + exact envelope_eq_combination childrenD_512 (4, 3) envelope_512 + pivot_mem_512 child_envelope_sub_512 envelope_origin_512 +def checked_512 : CheckedCard where + required := required_512 + envelope := envelope_512 + height := height_512 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_512 +def height_514 : ℕ := 9 +def childrenH_514 : Fin 3 → ℕ := ![height_34, height_149, height_513] +theorem height_exact_514 : height_514 = 1 + Finset.univ.sup childrenH_514 := by decide +kernel +theorem required_origin_514 : ∀ x ∈ required_514, + (∃ j, x ∈ childrenC_514 j) ∨ ∀ j, x ∈ childrenD_514 j := by decide +kernel +theorem required_exact_514 : required_514 = + ((Finset.univ.biUnion childrenC_514) ∪ commonEnvelope childrenD_514).erase (3, 2) := by + exact required_eq_combination childrenC_514 childrenD_514 (3, 2) required_514 + (by decide +kernel) child_required_sub_514 common_sub_514 required_origin_514 +theorem envelope_origin_514 : ∀ x ∈ envelope_514, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_514 j := by decide +kernel +theorem envelope_exact_514 : envelope_514 = + insert (3, 2) (Finset.univ.biUnion childrenD_514) := by + exact envelope_eq_combination childrenD_514 (3, 2) envelope_514 + pivot_mem_514 child_envelope_sub_514 envelope_origin_514 +def checked_514 : CheckedCard where + required := required_514 + envelope := envelope_514 + height := height_514 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_514 +def height_519 : ℕ := 9 +def childrenH_519 : Fin 4 → ℕ := ![height_10, height_47, height_52, height_518] +theorem height_exact_519 : height_519 = 1 + Finset.univ.sup childrenH_519 := by decide +kernel +theorem required_origin_519 : ∀ x ∈ required_519, + (∃ j, x ∈ childrenC_519 j) ∨ ∀ j, x ∈ childrenD_519 j := by decide +kernel +theorem required_exact_519 : required_519 = + ((Finset.univ.biUnion childrenC_519) ∪ commonEnvelope childrenD_519).erase (3, 5) := by + exact required_eq_combination childrenC_519 childrenD_519 (3, 5) required_519 + (by decide +kernel) child_required_sub_519 common_sub_519 required_origin_519 +theorem envelope_origin_519 : ∀ x ∈ envelope_519, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_519 j := by decide +kernel +theorem envelope_exact_519 : envelope_519 = + insert (3, 5) (Finset.univ.biUnion childrenD_519) := by + exact envelope_eq_combination childrenD_519 (3, 5) envelope_519 + pivot_mem_519 child_envelope_sub_519 envelope_origin_519 +def checked_519 : CheckedCard where + required := required_519 + envelope := envelope_519 + height := height_519 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_519 +def height_528_i0 : ℕ := 5 +def childrenH_528_i0 : Fin 2 → ℕ := ![height_4, height_49] +theorem height_exact_528_i0 : height_528_i0 = 1 + Finset.univ.sup childrenH_528_i0 := by decide +kernel +theorem required_origin_528_i0 : ∀ x ∈ required_528_i0, + (∃ j, x ∈ childrenC_528_i0 j) ∨ ∀ j, x ∈ childrenD_528_i0 j := by decide +kernel +theorem required_exact_528_i0 : required_528_i0 = + ((Finset.univ.biUnion childrenC_528_i0) ∪ commonEnvelope childrenD_528_i0).erase (1, 3) := by + exact required_eq_combination childrenC_528_i0 childrenD_528_i0 (1, 3) required_528_i0 + (by decide +kernel) child_required_sub_528_i0 common_sub_528_i0 required_origin_528_i0 +theorem envelope_origin_528_i0 : ∀ x ∈ envelope_528_i0, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_528_i0 j := by decide +kernel +theorem envelope_exact_528_i0 : envelope_528_i0 = + insert (1, 3) (Finset.univ.biUnion childrenD_528_i0) := by + exact envelope_eq_combination childrenD_528_i0 (1, 3) envelope_528_i0 + pivot_mem_528_i0 child_envelope_sub_528_i0 envelope_origin_528_i0 +def checked_528_i0 : CheckedCard where + required := required_528_i0 + envelope := envelope_528_i0 + height := height_528_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_528_i0 +def height_528_i1 : ℕ := 8 +def childrenH_528_i1 : Fin 2 → ℕ := ![height_5, height_446] +theorem height_exact_528_i1 : height_528_i1 = 1 + Finset.univ.sup childrenH_528_i1 := by decide +kernel +theorem required_origin_528_i1 : ∀ x ∈ required_528_i1, + (∃ j, x ∈ childrenC_528_i1 j) ∨ ∀ j, x ∈ childrenD_528_i1 j := by decide +kernel +theorem required_exact_528_i1 : required_528_i1 = + ((Finset.univ.biUnion childrenC_528_i1) ∪ commonEnvelope childrenD_528_i1).erase (1, 7) := by + exact required_eq_combination childrenC_528_i1 childrenD_528_i1 (1, 7) required_528_i1 + (by decide +kernel) child_required_sub_528_i1 common_sub_528_i1 required_origin_528_i1 +theorem envelope_origin_528_i1 : ∀ x ∈ envelope_528_i1, + x = (1, 7) ∨ ∃ j, x ∈ childrenD_528_i1 j := by decide +kernel +theorem envelope_exact_528_i1 : envelope_528_i1 = + insert (1, 7) (Finset.univ.biUnion childrenD_528_i1) := by + exact envelope_eq_combination childrenD_528_i1 (1, 7) envelope_528_i1 + pivot_mem_528_i1 child_envelope_sub_528_i1 envelope_origin_528_i1 +def checked_528_i1 : CheckedCard where + required := required_528_i1 + envelope := envelope_528_i1 + height := height_528_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_528_i1 +def height_528 : ℕ := 9 +def childrenH_528 : Fin 3 → ℕ := ![height_61, height_528_i0, height_528_i1] +theorem height_exact_528 : height_528 = 1 + Finset.univ.sup childrenH_528 := by decide +kernel +theorem required_origin_528 : ∀ x ∈ required_528, + (∃ j, x ∈ childrenC_528 j) ∨ ∀ j, x ∈ childrenD_528 j := by decide +kernel +theorem required_exact_528 : required_528 = + ((Finset.univ.biUnion childrenC_528) ∪ commonEnvelope childrenD_528).erase (0, 7) := by + exact required_eq_combination childrenC_528 childrenD_528 (0, 7) required_528 + (by decide +kernel) child_required_sub_528 common_sub_528 required_origin_528 +theorem envelope_origin_528 : ∀ x ∈ envelope_528, + x = (0, 7) ∨ ∃ j, x ∈ childrenD_528 j := by decide +kernel +theorem envelope_exact_528 : envelope_528 = + insert (0, 7) (Finset.univ.biUnion childrenD_528) := by + exact envelope_eq_combination childrenD_528 (0, 7) envelope_528 + pivot_mem_528 child_envelope_sub_528 envelope_origin_528 +def checked_528 : CheckedCard where + required := required_528 + envelope := envelope_528 + height := height_528 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_528 +def height_531 : ℕ := 9 +def childrenH_531 : Fin 2 → ℕ := ![height_0, height_530] +theorem height_exact_531 : height_531 = 1 + Finset.univ.sup childrenH_531 := by decide +kernel +theorem required_origin_531 : ∀ x ∈ required_531, + (∃ j, x ∈ childrenC_531 j) ∨ ∀ j, x ∈ childrenD_531 j := by decide +kernel +theorem required_exact_531 : required_531 = + ((Finset.univ.biUnion childrenC_531) ∪ commonEnvelope childrenD_531).erase (1, 4) := by + exact required_eq_combination childrenC_531 childrenD_531 (1, 4) required_531 + (by decide +kernel) child_required_sub_531 common_sub_531 required_origin_531 +theorem envelope_origin_531 : ∀ x ∈ envelope_531, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_531 j := by decide +kernel +theorem envelope_exact_531 : envelope_531 = + insert (1, 4) (Finset.univ.biUnion childrenD_531) := by + exact envelope_eq_combination childrenD_531 (1, 4) envelope_531 + pivot_mem_531 child_envelope_sub_531 envelope_origin_531 +def checked_531 : CheckedCard where + required := required_531 + envelope := envelope_531 + height := height_531 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_531 +def height_536 : ℕ := 9 +def childrenH_536 : Fin 4 → ℕ := ![height_14, height_88, height_213, height_534] +theorem height_exact_536 : height_536 = 1 + Finset.univ.sup childrenH_536 := by decide +kernel +theorem required_origin_536 : ∀ x ∈ required_536, + (∃ j, x ∈ childrenC_536 j) ∨ ∀ j, x ∈ childrenD_536 j := by decide +kernel +theorem required_exact_536 : required_536 = + ((Finset.univ.biUnion childrenC_536) ∪ commonEnvelope childrenD_536).erase (3, 5) := by + exact required_eq_combination childrenC_536 childrenD_536 (3, 5) required_536 + (by decide +kernel) child_required_sub_536 common_sub_536 required_origin_536 +theorem envelope_origin_536 : ∀ x ∈ envelope_536, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_536 j := by decide +kernel +theorem envelope_exact_536 : envelope_536 = + insert (3, 5) (Finset.univ.biUnion childrenD_536) := by + exact envelope_eq_combination childrenD_536 (3, 5) envelope_536 + pivot_mem_536 child_envelope_sub_536 envelope_origin_536 +def checked_536 : CheckedCard where + required := required_536 + envelope := envelope_536 + height := height_536 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_536 +def height_537_i0 : ℕ := 8 +def childrenH_537_i0 : Fin 2 → ℕ := ![height_45, height_418] +theorem height_exact_537_i0 : height_537_i0 = 1 + Finset.univ.sup childrenH_537_i0 := by decide +kernel +theorem required_origin_537_i0 : ∀ x ∈ required_537_i0, + (∃ j, x ∈ childrenC_537_i0 j) ∨ ∀ j, x ∈ childrenD_537_i0 j := by decide +kernel +theorem required_exact_537_i0 : required_537_i0 = + ((Finset.univ.biUnion childrenC_537_i0) ∪ commonEnvelope childrenD_537_i0).erase (3, 3) := by + exact required_eq_combination childrenC_537_i0 childrenD_537_i0 (3, 3) required_537_i0 + (by decide +kernel) child_required_sub_537_i0 common_sub_537_i0 required_origin_537_i0 +theorem envelope_origin_537_i0 : ∀ x ∈ envelope_537_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_537_i0 j := by decide +kernel +theorem envelope_exact_537_i0 : envelope_537_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_537_i0) := by + exact envelope_eq_combination childrenD_537_i0 (3, 3) envelope_537_i0 + pivot_mem_537_i0 child_envelope_sub_537_i0 envelope_origin_537_i0 +def checked_537_i0 : CheckedCard where + required := required_537_i0 + envelope := envelope_537_i0 + height := height_537_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_537_i0 +def height_537_i2 : ℕ := 6 +def childrenH_537_i2 : Fin 2 → ℕ := ![height_15, height_425] +theorem height_exact_537_i2 : height_537_i2 = 1 + Finset.univ.sup childrenH_537_i2 := by decide +kernel +theorem required_origin_537_i2 : ∀ x ∈ required_537_i2, + (∃ j, x ∈ childrenC_537_i2 j) ∨ ∀ j, x ∈ childrenD_537_i2 j := by decide +kernel +theorem required_exact_537_i2 : required_537_i2 = + ((Finset.univ.biUnion childrenC_537_i2) ∪ commonEnvelope childrenD_537_i2).erase (2, 5) := by + exact required_eq_combination childrenC_537_i2 childrenD_537_i2 (2, 5) required_537_i2 + (by decide +kernel) child_required_sub_537_i2 common_sub_537_i2 required_origin_537_i2 +theorem envelope_origin_537_i2 : ∀ x ∈ envelope_537_i2, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_537_i2 j := by decide +kernel +theorem envelope_exact_537_i2 : envelope_537_i2 = + insert (2, 5) (Finset.univ.biUnion childrenD_537_i2) := by + exact envelope_eq_combination childrenD_537_i2 (2, 5) envelope_537_i2 + pivot_mem_537_i2 child_envelope_sub_537_i2 envelope_origin_537_i2 +def checked_537_i2 : CheckedCard where + required := required_537_i2 + envelope := envelope_537_i2 + height := height_537_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_537_i2 +def height_537_i6 : ℕ := 3 +def childrenH_537_i6 : Fin 2 → ℕ := ![height_0, height_23] +theorem height_exact_537_i6 : height_537_i6 = 1 + Finset.univ.sup childrenH_537_i6 := by decide +kernel +theorem required_origin_537_i6 : ∀ x ∈ required_537_i6, + (∃ j, x ∈ childrenC_537_i6 j) ∨ ∀ j, x ∈ childrenD_537_i6 j := by decide +kernel +theorem required_exact_537_i6 : required_537_i6 = + ((Finset.univ.biUnion childrenC_537_i6) ∪ commonEnvelope childrenD_537_i6).erase (2, 5) := by + exact required_eq_combination childrenC_537_i6 childrenD_537_i6 (2, 5) required_537_i6 + (by decide +kernel) child_required_sub_537_i6 common_sub_537_i6 required_origin_537_i6 +theorem envelope_origin_537_i6 : ∀ x ∈ envelope_537_i6, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_537_i6 j := by decide +kernel +theorem envelope_exact_537_i6 : envelope_537_i6 = + insert (2, 5) (Finset.univ.biUnion childrenD_537_i6) := by + exact envelope_eq_combination childrenD_537_i6 (2, 5) envelope_537_i6 + pivot_mem_537_i6 child_envelope_sub_537_i6 envelope_origin_537_i6 +def checked_537_i6 : CheckedCard where + required := required_537_i6 + envelope := envelope_537_i6 + height := height_537_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_537_i6 +def height_537_i5 : ℕ := 4 +def childrenH_537_i5 : Fin 2 → ℕ := ![height_0, height_537_i6] +theorem height_exact_537_i5 : height_537_i5 = 1 + Finset.univ.sup childrenH_537_i5 := by decide +kernel +theorem required_origin_537_i5 : ∀ x ∈ required_537_i5, + (∃ j, x ∈ childrenC_537_i5 j) ∨ ∀ j, x ∈ childrenD_537_i5 j := by decide +kernel +theorem required_exact_537_i5 : required_537_i5 = + ((Finset.univ.biUnion childrenC_537_i5) ∪ commonEnvelope childrenD_537_i5).erase (3, 5) := by + exact required_eq_combination childrenC_537_i5 childrenD_537_i5 (3, 5) required_537_i5 + (by decide +kernel) child_required_sub_537_i5 common_sub_537_i5 required_origin_537_i5 +theorem envelope_origin_537_i5 : ∀ x ∈ envelope_537_i5, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_537_i5 j := by decide +kernel +theorem envelope_exact_537_i5 : envelope_537_i5 = + insert (3, 5) (Finset.univ.biUnion childrenD_537_i5) := by + exact envelope_eq_combination childrenD_537_i5 (3, 5) envelope_537_i5 + pivot_mem_537_i5 child_envelope_sub_537_i5 envelope_origin_537_i5 +def checked_537_i5 : CheckedCard where + required := required_537_i5 + envelope := envelope_537_i5 + height := height_537_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_537_i5 +def height_537_i4 : ℕ := 6 +def childrenH_537_i4 : Fin 3 → ℕ := ![height_139, height_382, height_537_i5] +theorem height_exact_537_i4 : height_537_i4 = 1 + Finset.univ.sup childrenH_537_i4 := by decide +kernel +theorem required_origin_537_i4 : ∀ x ∈ required_537_i4, + (∃ j, x ∈ childrenC_537_i4 j) ∨ ∀ j, x ∈ childrenD_537_i4 j := by decide +kernel +theorem required_exact_537_i4 : required_537_i4 = + ((Finset.univ.biUnion childrenC_537_i4) ∪ commonEnvelope childrenD_537_i4).erase (3, 6) := by + exact required_eq_combination childrenC_537_i4 childrenD_537_i4 (3, 6) required_537_i4 + (by decide +kernel) child_required_sub_537_i4 common_sub_537_i4 required_origin_537_i4 +theorem envelope_origin_537_i4 : ∀ x ∈ envelope_537_i4, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_537_i4 j := by decide +kernel +theorem envelope_exact_537_i4 : envelope_537_i4 = + insert (3, 6) (Finset.univ.biUnion childrenD_537_i4) := by + exact envelope_eq_combination childrenD_537_i4 (3, 6) envelope_537_i4 + pivot_mem_537_i4 child_envelope_sub_537_i4 envelope_origin_537_i4 +def checked_537_i4 : CheckedCard where + required := required_537_i4 + envelope := envelope_537_i4 + height := height_537_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_537_i4 +def height_537_i3 : ℕ := 7 +def childrenH_537_i3 : Fin 3 → ℕ := ![height_13, height_30, height_537_i4] +theorem height_exact_537_i3 : height_537_i3 = 1 + Finset.univ.sup childrenH_537_i3 := by decide +kernel +theorem required_origin_537_i3 : ∀ x ∈ required_537_i3, + (∃ j, x ∈ childrenC_537_i3 j) ∨ ∀ j, x ∈ childrenD_537_i3 j := by decide +kernel +theorem required_exact_537_i3 : required_537_i3 = + ((Finset.univ.biUnion childrenC_537_i3) ∪ commonEnvelope childrenD_537_i3).erase (4, 4) := by + exact required_eq_combination childrenC_537_i3 childrenD_537_i3 (4, 4) required_537_i3 + (by decide +kernel) child_required_sub_537_i3 common_sub_537_i3 required_origin_537_i3 +theorem envelope_origin_537_i3 : ∀ x ∈ envelope_537_i3, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_537_i3 j := by decide +kernel +theorem envelope_exact_537_i3 : envelope_537_i3 = + insert (4, 4) (Finset.univ.biUnion childrenD_537_i3) := by + exact envelope_eq_combination childrenD_537_i3 (4, 4) envelope_537_i3 + pivot_mem_537_i3 child_envelope_sub_537_i3 envelope_origin_537_i3 +def checked_537_i3 : CheckedCard where + required := required_537_i3 + envelope := envelope_537_i3 + height := height_537_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_537_i3 +def height_537_i1 : ℕ := 8 +def childrenH_537_i1 : Fin 4 → ℕ := ![height_166, height_464, height_537_i2, height_537_i3] +theorem height_exact_537_i1 : height_537_i1 = 1 + Finset.univ.sup childrenH_537_i1 := by decide +kernel +theorem required_origin_537_i1 : ∀ x ∈ required_537_i1, + (∃ j, x ∈ childrenC_537_i1 j) ∨ ∀ j, x ∈ childrenD_537_i1 j := by decide +kernel +theorem required_exact_537_i1 : required_537_i1 = + ((Finset.univ.biUnion childrenC_537_i1) ∪ commonEnvelope childrenD_537_i1).erase (4, 5) := by + exact required_eq_combination childrenC_537_i1 childrenD_537_i1 (4, 5) required_537_i1 + (by decide +kernel) child_required_sub_537_i1 common_sub_537_i1 required_origin_537_i1 +theorem envelope_origin_537_i1 : ∀ x ∈ envelope_537_i1, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_537_i1 j := by decide +kernel +theorem envelope_exact_537_i1 : envelope_537_i1 = + insert (4, 5) (Finset.univ.biUnion childrenD_537_i1) := by + exact envelope_eq_combination childrenD_537_i1 (4, 5) envelope_537_i1 + pivot_mem_537_i1 child_envelope_sub_537_i1 envelope_origin_537_i1 +def checked_537_i1 : CheckedCard where + required := required_537_i1 + envelope := envelope_537_i1 + height := height_537_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_537_i1 +def height_537 : ℕ := 9 +def childrenH_537 : Fin 4 → ℕ := ![height_74, height_108, height_537_i0, height_537_i1] +theorem height_exact_537 : height_537 = 1 + Finset.univ.sup childrenH_537 := by decide +kernel +theorem required_origin_537 : ∀ x ∈ required_537, + (∃ j, x ∈ childrenC_537 j) ∨ ∀ j, x ∈ childrenD_537 j := by decide +kernel +theorem required_exact_537 : required_537 = + ((Finset.univ.biUnion childrenC_537) ∪ commonEnvelope childrenD_537).erase (4, 3) := by + exact required_eq_combination childrenC_537 childrenD_537 (4, 3) required_537 + (by decide +kernel) child_required_sub_537 common_sub_537 required_origin_537 +theorem envelope_origin_537 : ∀ x ∈ envelope_537, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_537 j := by decide +kernel +theorem envelope_exact_537 : envelope_537 = + insert (4, 3) (Finset.univ.biUnion childrenD_537) := by + exact envelope_eq_combination childrenD_537 (4, 3) envelope_537 + pivot_mem_537 child_envelope_sub_537 envelope_origin_537 +def checked_537 : CheckedCard where + required := required_537 + envelope := envelope_537 + height := height_537 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_537 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part04.lean new file mode 100644 index 0000000..87f43f2 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part04.lean @@ -0,0 +1,941 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_539_i4 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i4 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i4 : Fin 2 → Finset Cell := ![(placed21 4 (0, 5) required_5), (placed21 4 (3, 5) required_6)] +def childrenD_539_i4 : Fin 2 → Finset Cell := ![(placed21 4 (0, 5) envelope_5), (placed21 4 (3, 5) envelope_6)] +theorem common_sub_539_i4 : commonEnvelope childrenD_539_i4 ⊆ insert (3, 5) required_539_i4 := by decide +kernel +theorem child_required_sub_539_i4 : ∀ j, childrenC_539_i4 j ⊆ insert (3, 5) required_539_i4 := by decide +kernel +theorem child_envelope_sub_539_i4 : ∀ j, childrenD_539_i4 j ⊆ envelope_539_i4 := by decide +kernel +theorem pivot_mem_539_i4 : (3, 5) ∈ envelope_539_i4 := by decide +kernel +theorem children_work_539_i4 : ∀ j, Template HasSnaky 2 (childrenC_539_i4 j) (childrenD_539_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_6 4 (3, 5)).mono (by decide +kernel) +theorem row_works_539_i4 : Template HasSnaky 3 required_539_i4 envelope_539_i4 := by + refine compose HasSnaky 2 childrenC_539_i4 childrenD_539_i4 children_work_539_i4 (3, 5) + required_539_i4 envelope_539_i4 pivot_mem_539_i4 child_required_sub_539_i4 child_envelope_sub_539_i4 ?_ + intro b hb + exact common_sub_539_i4 (mem_commonEnvelope childrenD_539_i4 b hb) +def required_539_i3 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 1), (2, 5), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i3 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 0), (2, 1), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i3 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) required_5), required_539_i4] +def childrenD_539_i3 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) envelope_5), envelope_539_i4] +theorem common_sub_539_i3 : commonEnvelope childrenD_539_i3 ⊆ insert (3, 4) required_539_i3 := by decide +kernel +theorem child_required_sub_539_i3 : ∀ j, childrenC_539_i3 j ⊆ insert (3, 4) required_539_i3 := by decide +kernel +theorem child_envelope_sub_539_i3 : ∀ j, childrenD_539_i3 j ⊆ envelope_539_i3 := by decide +kernel +theorem pivot_mem_539_i3 : (3, 4) ∈ envelope_539_i3 := by decide +kernel +theorem children_work_539_i3 : ∀ j, Template HasSnaky 3 (childrenC_539_i3 j) (childrenD_539_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (3, 4)).mono (by decide +kernel) + · exact row_works_539_i4.mono (by decide +kernel) +theorem row_works_539_i3 : Template HasSnaky 4 required_539_i3 envelope_539_i3 := by + refine compose HasSnaky 3 childrenC_539_i3 childrenD_539_i3 children_work_539_i3 (3, 4) + required_539_i3 envelope_539_i3 pivot_mem_539_i3 child_required_sub_539_i3 child_envelope_sub_539_i3 ?_ + intro b hb + exact common_sub_539_i3 (mem_commonEnvelope childrenD_539_i3 b hb) +def required_539_i7 : Finset Cell := ⟨(([(0, 1), (0, 5), (1, 5), (2, 1), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i7 : Finset Cell := ⟨(([(0, 1), (0, 5), (1, 1), (1, 5), (2, 1), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i7 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_1), (placed21 2 (4, 2) required_153)] +def childrenD_539_i7 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_1), (placed21 2 (4, 2) envelope_153)] +theorem common_sub_539_i7 : commonEnvelope childrenD_539_i7 ⊆ insert (4, 2) required_539_i7 := by decide +kernel +theorem child_required_sub_539_i7 : ∀ j, childrenC_539_i7 j ⊆ insert (4, 2) required_539_i7 := by decide +kernel +theorem child_envelope_sub_539_i7 : ∀ j, childrenD_539_i7 j ⊆ envelope_539_i7 := by decide +kernel +theorem pivot_mem_539_i7 : (4, 2) ∈ envelope_539_i7 := by decide +kernel +theorem children_work_539_i7 : ∀ j, Template HasSnaky 2 (childrenC_539_i7 j) (childrenD_539_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_153 2 (4, 2)).mono (by decide +kernel) +theorem row_works_539_i7 : Template HasSnaky 3 required_539_i7 envelope_539_i7 := by + refine compose HasSnaky 2 childrenC_539_i7 childrenD_539_i7 children_work_539_i7 (4, 2) + required_539_i7 envelope_539_i7 pivot_mem_539_i7 child_required_sub_539_i7 child_envelope_sub_539_i7 ?_ + intro b hb + exact common_sub_539_i7 (mem_commonEnvelope childrenD_539_i7 b hb) +def required_539_i6 : Finset Cell := ⟨(([(0, 1), (0, 5), (1, 5), (2, 1), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i6 : Finset Cell := ⟨(([(0, 1), (0, 5), (1, 1), (1, 5), (2, 1), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i6 : Fin 2 → Finset Cell := ![(placed21 4 (0, 5) required_5), required_539_i7] +def childrenD_539_i6 : Fin 2 → Finset Cell := ![(placed21 4 (0, 5) envelope_5), envelope_539_i7] +theorem common_sub_539_i6 : commonEnvelope childrenD_539_i6 ⊆ insert (3, 5) required_539_i6 := by decide +kernel +theorem child_required_sub_539_i6 : ∀ j, childrenC_539_i6 j ⊆ insert (3, 5) required_539_i6 := by decide +kernel +theorem child_envelope_sub_539_i6 : ∀ j, childrenD_539_i6 j ⊆ envelope_539_i6 := by decide +kernel +theorem pivot_mem_539_i6 : (3, 5) ∈ envelope_539_i6 := by decide +kernel +theorem children_work_539_i6 : ∀ j, Template HasSnaky 3 (childrenC_539_i6 j) (childrenD_539_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 5)).mono (by decide +kernel) + · exact row_works_539_i7.mono (by decide +kernel) +theorem row_works_539_i6 : Template HasSnaky 4 required_539_i6 envelope_539_i6 := by + refine compose HasSnaky 3 childrenC_539_i6 childrenD_539_i6 children_work_539_i6 (3, 5) + required_539_i6 envelope_539_i6 pivot_mem_539_i6 child_required_sub_539_i6 child_envelope_sub_539_i6 ?_ + intro b hb + exact common_sub_539_i6 (mem_commonEnvelope childrenD_539_i6 b hb) +def required_539_i5 : Finset Cell := ⟨(([(0, 1), (0, 5), (1, 5), (2, 1), (2, 5), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i5 : Finset Cell := ⟨(([(0, 1), (0, 5), (1, 1), (1, 5), (2, 0), (2, 1), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i5 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) required_5), required_539_i6] +def childrenD_539_i5 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) envelope_5), envelope_539_i6] +theorem common_sub_539_i5 : commonEnvelope childrenD_539_i5 ⊆ insert (3, 4) required_539_i5 := by decide +kernel +theorem child_required_sub_539_i5 : ∀ j, childrenC_539_i5 j ⊆ insert (3, 4) required_539_i5 := by decide +kernel +theorem child_envelope_sub_539_i5 : ∀ j, childrenD_539_i5 j ⊆ envelope_539_i5 := by decide +kernel +theorem pivot_mem_539_i5 : (3, 4) ∈ envelope_539_i5 := by decide +kernel +theorem children_work_539_i5 : ∀ j, Template HasSnaky 4 (childrenC_539_i5 j) (childrenD_539_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (3, 4)).mono (by decide +kernel) + · exact row_works_539_i6.mono (by decide +kernel) +theorem row_works_539_i5 : Template HasSnaky 5 required_539_i5 envelope_539_i5 := by + refine compose HasSnaky 4 childrenC_539_i5 childrenD_539_i5 children_work_539_i5 (3, 4) + required_539_i5 envelope_539_i5 pivot_mem_539_i5 child_required_sub_539_i5 child_envelope_sub_539_i5 ?_ + intro b hb + exact common_sub_539_i5 (mem_commonEnvelope childrenD_539_i5 b hb) +def required_539_i9 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 4), (1, 5), (2, 1), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i9 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (3, 1), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i9 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_0), (placed21 7 (1, 5) required_2)] +def childrenD_539_i9 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_0), (placed21 7 (1, 5) envelope_2)] +theorem common_sub_539_i9 : commonEnvelope childrenD_539_i9 ⊆ insert (1, 2) required_539_i9 := by decide +kernel +theorem child_required_sub_539_i9 : ∀ j, childrenC_539_i9 j ⊆ insert (1, 2) required_539_i9 := by decide +kernel +theorem child_envelope_sub_539_i9 : ∀ j, childrenD_539_i9 j ⊆ envelope_539_i9 := by decide +kernel +theorem pivot_mem_539_i9 : (1, 2) ∈ envelope_539_i9 := by decide +kernel +theorem children_work_539_i9 : ∀ j, Template HasSnaky 1 (childrenC_539_i9 j) (childrenD_539_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_2 7 (1, 5)).mono (by decide +kernel) +theorem row_works_539_i9 : Template HasSnaky 2 required_539_i9 envelope_539_i9 := by + refine compose HasSnaky 1 childrenC_539_i9 childrenD_539_i9 children_work_539_i9 (1, 2) + required_539_i9 envelope_539_i9 pivot_mem_539_i9 child_required_sub_539_i9 child_envelope_sub_539_i9 ?_ + intro b hb + exact common_sub_539_i9 (mem_commonEnvelope childrenD_539_i9 b hb) +def required_539_i8 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (1, 5), (2, 1), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i8 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (3, 1), (3, 2), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i8 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), required_539_i9] +def childrenD_539_i8 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), envelope_539_i9] +theorem common_sub_539_i8 : commonEnvelope childrenD_539_i8 ⊆ insert (1, 1) required_539_i8 := by decide +kernel +theorem child_required_sub_539_i8 : ∀ j, childrenC_539_i8 j ⊆ insert (1, 1) required_539_i8 := by decide +kernel +theorem child_envelope_sub_539_i8 : ∀ j, childrenD_539_i8 j ⊆ envelope_539_i8 := by decide +kernel +theorem pivot_mem_539_i8 : (1, 1) ∈ envelope_539_i8 := by decide +kernel +theorem children_work_539_i8 : ∀ j, Template HasSnaky 2 (childrenC_539_i8 j) (childrenD_539_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact row_works_539_i9.mono (by decide +kernel) +theorem row_works_539_i8 : Template HasSnaky 3 required_539_i8 envelope_539_i8 := by + refine compose HasSnaky 2 childrenC_539_i8 childrenD_539_i8 children_work_539_i8 (1, 1) + required_539_i8 envelope_539_i8 pivot_mem_539_i8 child_required_sub_539_i8 child_envelope_sub_539_i8 ?_ + intro b hb + exact common_sub_539_i8 (mem_commonEnvelope childrenD_539_i8 b hb) +def required_539_i10 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (1, 5), (2, 1), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i10 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i10 : Fin 2 → Finset Cell := ![(placed21 0 (2, 0) required_83), (placed21 5 (4, 1) required_281)] +def childrenD_539_i10 : Fin 2 → Finset Cell := ![(placed21 0 (2, 0) envelope_83), (placed21 5 (4, 1) envelope_281)] +theorem common_sub_539_i10 : commonEnvelope childrenD_539_i10 ⊆ insert (4, 1) required_539_i10 := by decide +kernel +theorem child_required_sub_539_i10 : ∀ j, childrenC_539_i10 j ⊆ insert (4, 1) required_539_i10 := by decide +kernel +theorem child_envelope_sub_539_i10 : ∀ j, childrenD_539_i10 j ⊆ envelope_539_i10 := by decide +kernel +theorem pivot_mem_539_i10 : (4, 1) ∈ envelope_539_i10 := by decide +kernel +theorem children_work_539_i10 : ∀ j, Template HasSnaky 2 (childrenC_539_i10 j) (childrenD_539_i10 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_83 0 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_281 5 (4, 1)).mono (by decide +kernel) +theorem row_works_539_i10 : Template HasSnaky 3 required_539_i10 envelope_539_i10 := by + refine compose HasSnaky 2 childrenC_539_i10 childrenD_539_i10 children_work_539_i10 (4, 1) + required_539_i10 envelope_539_i10 pivot_mem_539_i10 child_required_sub_539_i10 child_envelope_sub_539_i10 ?_ + intro b hb + exact common_sub_539_i10 (mem_commonEnvelope childrenD_539_i10 b hb) +def required_539_i2 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (1, 4), (1, 5), (2, 5), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i2 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i2 : Fin 4 → Finset Cell := ![required_539_i3, required_539_i5, required_539_i8, required_539_i10] +def childrenD_539_i2 : Fin 4 → Finset Cell := ![envelope_539_i3, envelope_539_i5, envelope_539_i8, envelope_539_i10] +theorem common_sub_539_i2 : commonEnvelope childrenD_539_i2 ⊆ insert (2, 1) required_539_i2 := by decide +kernel +theorem child_required_sub_539_i2 : ∀ j, childrenC_539_i2 j ⊆ insert (2, 1) required_539_i2 := by decide +kernel +theorem child_envelope_sub_539_i2 : ∀ j, childrenD_539_i2 j ⊆ envelope_539_i2 := by decide +kernel +theorem pivot_mem_539_i2 : (2, 1) ∈ envelope_539_i2 := by decide +kernel +theorem children_work_539_i2 : ∀ j, Template HasSnaky 5 (childrenC_539_i2 j) (childrenD_539_i2 j) := by + intro j + fin_cases j + · exact row_works_539_i3.mono (by decide +kernel) + · exact row_works_539_i5.mono (by decide +kernel) + · exact row_works_539_i8.mono (by decide +kernel) + · exact row_works_539_i10.mono (by decide +kernel) +theorem row_works_539_i2 : Template HasSnaky 6 required_539_i2 envelope_539_i2 := by + refine compose HasSnaky 5 childrenC_539_i2 childrenD_539_i2 children_work_539_i2 (2, 1) + required_539_i2 envelope_539_i2 pivot_mem_539_i2 child_required_sub_539_i2 child_envelope_sub_539_i2 ?_ + intro b hb + exact common_sub_539_i2 (mem_commonEnvelope childrenD_539_i2 b hb) +def required_539_i1 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i1 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i1 : Fin 2 → Finset Cell := ![(placed21 3 (1, 9) required_4), required_539_i2] +def childrenD_539_i1 : Fin 2 → Finset Cell := ![(placed21 3 (1, 9) envelope_4), envelope_539_i2] +theorem common_sub_539_i1 : commonEnvelope childrenD_539_i1 ⊆ insert (2, 5) required_539_i1 := by decide +kernel +theorem child_required_sub_539_i1 : ∀ j, childrenC_539_i1 j ⊆ insert (2, 5) required_539_i1 := by decide +kernel +theorem child_envelope_sub_539_i1 : ∀ j, childrenD_539_i1 j ⊆ envelope_539_i1 := by decide +kernel +theorem pivot_mem_539_i1 : (2, 5) ∈ envelope_539_i1 := by decide +kernel +theorem children_work_539_i1 : ∀ j, Template HasSnaky 6 (childrenC_539_i1 j) (childrenD_539_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 3 (1, 9)).mono (by decide +kernel) + · exact row_works_539_i2.mono (by decide +kernel) +theorem row_works_539_i1 : Template HasSnaky 7 required_539_i1 envelope_539_i1 := by + refine compose HasSnaky 6 childrenC_539_i1 childrenD_539_i1 children_work_539_i1 (2, 5) + required_539_i1 envelope_539_i1 pivot_mem_539_i1 child_required_sub_539_i1 child_envelope_sub_539_i1 ?_ + intro b hb + exact common_sub_539_i1 (mem_commonEnvelope childrenD_539_i1 b hb) +def required_539_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 8) required_5), required_539_i1] +def childrenD_539_i0 : Fin 2 → Finset Cell := ![(placed21 7 (1, 8) envelope_5), envelope_539_i1] +theorem common_sub_539_i0 : commonEnvelope childrenD_539_i0 ⊆ insert (0, 5) required_539_i0 := by decide +kernel +theorem child_required_sub_539_i0 : ∀ j, childrenC_539_i0 j ⊆ insert (0, 5) required_539_i0 := by decide +kernel +theorem child_envelope_sub_539_i0 : ∀ j, childrenD_539_i0 j ⊆ envelope_539_i0 := by decide +kernel +theorem pivot_mem_539_i0 : (0, 5) ∈ envelope_539_i0 := by decide +kernel +theorem children_work_539_i0 : ∀ j, Template HasSnaky 7 (childrenC_539_i0 j) (childrenD_539_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 8)).mono (by decide +kernel) + · exact row_works_539_i1.mono (by decide +kernel) +theorem row_works_539_i0 : Template HasSnaky 8 required_539_i0 envelope_539_i0 := by + refine compose HasSnaky 7 childrenC_539_i0 childrenD_539_i0 children_work_539_i0 (0, 5) + required_539_i0 envelope_539_i0 pivot_mem_539_i0 child_required_sub_539_i0 child_envelope_sub_539_i0 ?_ + intro b hb + exact common_sub_539_i0 (mem_commonEnvelope childrenD_539_i0 b hb) +def required_539 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_539 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 5), (2, 6), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_539 : Fin 2 → Finset Cell := ![(placed21 0 (1, 5) required_6), required_539_i0] +def childrenD_539 : Fin 2 → Finset Cell := ![(placed21 0 (1, 5) envelope_6), envelope_539_i0] +theorem common_sub_539 : commonEnvelope childrenD_539 ⊆ insert (1, 9) required_539 := by decide +kernel +theorem child_required_sub_539 : ∀ j, childrenC_539 j ⊆ insert (1, 9) required_539 := by decide +kernel +theorem child_envelope_sub_539 : ∀ j, childrenD_539 j ⊆ envelope_539 := by decide +kernel +theorem pivot_mem_539 : (1, 9) ∈ envelope_539 := by decide +kernel +theorem children_work_539 : ∀ j, Template HasSnaky 8 (childrenC_539 j) (childrenD_539 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (1, 5)).mono (by decide +kernel) + · exact row_works_539_i0.mono (by decide +kernel) +theorem row_works_539 : Template HasSnaky 9 required_539 envelope_539 := by + refine compose HasSnaky 8 childrenC_539 childrenD_539 children_work_539 (1, 9) + required_539 envelope_539 pivot_mem_539 child_required_sub_539 child_envelope_sub_539 ?_ + intro b hb + exact common_sub_539 (mem_commonEnvelope childrenD_539 b hb) +def required_548 : Finset Cell := ⟨(([(1, 5), (1, 6), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_548 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 7), (2, 8), (2, 9), (2, 10), (3, 5), (3, 6), (3, 7), (3, 8), (4, 6), (4, 7), (4, 8), (5, 6), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_548 : Fin 4 → Finset Cell := ![(placed21 2 (2, 4) required_10), (placed21 4 (1, 8) required_52), (placed21 0 (0, 3) required_189), (placed21 4 (0, 8) required_547)] +def childrenD_548 : Fin 4 → Finset Cell := ![(placed21 2 (2, 4) envelope_10), (placed21 4 (1, 8) envelope_52), (placed21 0 (0, 3) envelope_189), (placed21 4 (0, 8) envelope_547)] +theorem common_sub_548 : commonEnvelope childrenD_548 ⊆ insert (1, 7) required_548 := by decide +kernel +theorem child_required_sub_548 : ∀ j, childrenC_548 j ⊆ insert (1, 7) required_548 := by decide +kernel +theorem child_envelope_sub_548 : ∀ j, childrenD_548 j ⊆ envelope_548 := by decide +kernel +theorem pivot_mem_548 : (1, 7) ∈ envelope_548 := by decide +kernel +theorem children_work_548 : ∀ j, Template HasSnaky 8 (childrenC_548 j) (childrenD_548 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 2 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_52 4 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_189 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_547 4 (0, 8)).mono (by decide +kernel) +theorem row_works_548 : Template HasSnaky 9 required_548 envelope_548 := by + refine compose HasSnaky 8 childrenC_548 childrenD_548 children_work_548 (1, 7) + required_548 envelope_548 pivot_mem_548 child_required_sub_548 child_envelope_sub_548 ?_ + intro b hb + exact common_sub_548 (mem_commonEnvelope childrenD_548 b hb) +def required_549 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_549 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (5, 2), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_549 : Fin 4 → Finset Cell := ![(placed21 6 (2, 6) required_10), (placed21 0 (1, 2) required_52), (placed21 4 (0, 6) required_63), (placed21 0 (0, 2) required_547)] +def childrenD_549 : Fin 4 → Finset Cell := ![(placed21 6 (2, 6) envelope_10), (placed21 0 (1, 2) envelope_52), (placed21 4 (0, 6) envelope_63), (placed21 0 (0, 2) envelope_547)] +theorem common_sub_549 : commonEnvelope childrenD_549 ⊆ insert (1, 3) required_549 := by decide +kernel +theorem child_required_sub_549 : ∀ j, childrenC_549 j ⊆ insert (1, 3) required_549 := by decide +kernel +theorem child_envelope_sub_549 : ∀ j, childrenD_549 j ⊆ envelope_549 := by decide +kernel +theorem pivot_mem_549 : (1, 3) ∈ envelope_549 := by decide +kernel +theorem children_work_549 : ∀ j, Template HasSnaky 8 (childrenC_549 j) (childrenD_549 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_63 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_547 0 (0, 2)).mono (by decide +kernel) +theorem row_works_549 : Template HasSnaky 9 required_549 envelope_549 := by + refine compose HasSnaky 8 childrenC_549 childrenD_549 children_work_549 (1, 3) + required_549 envelope_549 pivot_mem_549 child_required_sub_549 child_envelope_sub_549 ?_ + intro b hb + exact common_sub_549 (mem_commonEnvelope childrenD_549 b hb) +def required_561_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 5), (2, 7), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_561_i0 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_561_i0 : Fin 2 → Finset Cell := ![(placed21 7 (2, 7) required_1), (placed21 0 (0, 2) required_57)] +def childrenD_561_i0 : Fin 2 → Finset Cell := ![(placed21 7 (2, 7) envelope_1), (placed21 0 (0, 2) envelope_57)] +theorem common_sub_561_i0 : commonEnvelope childrenD_561_i0 ⊆ insert (2, 4) required_561_i0 := by decide +kernel +theorem child_required_sub_561_i0 : ∀ j, childrenC_561_i0 j ⊆ insert (2, 4) required_561_i0 := by decide +kernel +theorem child_envelope_sub_561_i0 : ∀ j, childrenD_561_i0 j ⊆ envelope_561_i0 := by decide +kernel +theorem pivot_mem_561_i0 : (2, 4) ∈ envelope_561_i0 := by decide +kernel +theorem children_work_561_i0 : ∀ j, Template HasSnaky 4 (childrenC_561_i0 j) (childrenD_561_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 7 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_57 0 (0, 2)).mono (by decide +kernel) +theorem row_works_561_i0 : Template HasSnaky 5 required_561_i0 envelope_561_i0 := by + refine compose HasSnaky 4 childrenC_561_i0 childrenD_561_i0 children_work_561_i0 (2, 4) + required_561_i0 envelope_561_i0 pivot_mem_561_i0 child_required_sub_561_i0 child_envelope_sub_561_i0 ?_ + intro b hb + exact common_sub_561_i0 (mem_commonEnvelope childrenD_561_i0 b hb) +def required_561 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_561 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 8), (4, 9), (4, 10), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_561 : Fin 4 → Finset Cell := ![(placed21 0 (1, 3) required_154), (placed21 4 (0, 10) required_319), (placed21 0 (0, 3) required_335), required_561_i0] +def childrenD_561 : Fin 4 → Finset Cell := ![(placed21 0 (1, 3) envelope_154), (placed21 4 (0, 10) envelope_319), (placed21 0 (0, 3) envelope_335), envelope_561_i0] +theorem common_sub_561 : commonEnvelope childrenD_561 ⊆ insert (2, 7) required_561 := by decide +kernel +theorem child_required_sub_561 : ∀ j, childrenC_561 j ⊆ insert (2, 7) required_561 := by decide +kernel +theorem child_envelope_sub_561 : ∀ j, childrenD_561 j ⊆ envelope_561 := by decide +kernel +theorem pivot_mem_561 : (2, 7) ∈ envelope_561 := by decide +kernel +theorem children_work_561 : ∀ j, Template HasSnaky 8 (childrenC_561 j) (childrenD_561 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_154 0 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_319 4 (0, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_335 0 (0, 3)).mono (by decide +kernel) + · exact row_works_561_i0.mono (by decide +kernel) +theorem row_works_561 : Template HasSnaky 9 required_561 envelope_561 := by + refine compose HasSnaky 8 childrenC_561 childrenD_561 children_work_561 (2, 7) + required_561 envelope_561 pivot_mem_561 child_required_sub_561 child_envelope_sub_561 ?_ + intro b hb + exact common_sub_561 (mem_commonEnvelope childrenD_561 b hb) +def required_562_i0 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_562_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (6, 2), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_562_i0 : Fin 5 → Finset Cell := ![(placed21 2 (4, 1) required_13), (placed21 0 (2, 1) required_14), (placed21 2 (4, 1) required_33), (placed21 0 (1, 2) required_122), (placed21 4 (1, 6) required_388)] +def childrenD_562_i0 : Fin 5 → Finset Cell := ![(placed21 2 (4, 1) envelope_13), (placed21 0 (2, 1) envelope_14), (placed21 2 (4, 1) envelope_33), (placed21 0 (1, 2) envelope_122), (placed21 4 (1, 6) envelope_388)] +theorem common_sub_562_i0 : commonEnvelope childrenD_562_i0 ⊆ insert (3, 5) required_562_i0 := by decide +kernel +theorem child_required_sub_562_i0 : ∀ j, childrenC_562_i0 j ⊆ insert (3, 5) required_562_i0 := by decide +kernel +theorem child_envelope_sub_562_i0 : ∀ j, childrenD_562_i0 j ⊆ envelope_562_i0 := by decide +kernel +theorem pivot_mem_562_i0 : (3, 5) ∈ envelope_562_i0 := by decide +kernel +theorem children_work_562_i0 : ∀ j, Template HasSnaky 7 (childrenC_562_i0 j) (childrenD_562_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_14 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_33 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_122 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_388 4 (1, 6)).mono (by decide +kernel) +theorem row_works_562_i0 : Template HasSnaky 8 required_562_i0 envelope_562_i0 := by + refine compose HasSnaky 7 childrenC_562_i0 childrenD_562_i0 children_work_562_i0 (3, 5) + required_562_i0 envelope_562_i0 pivot_mem_562_i0 child_required_sub_562_i0 child_envelope_sub_562_i0 ?_ + intro b hb + exact common_sub_562_i0 (mem_commonEnvelope childrenD_562_i0 b hb) +def required_562 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_562 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (6, 2), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_562 : Fin 3 → Finset Cell := ![(placed21 3 (0, 4) required_52), (placed21 6 (4, 7) required_506), required_562_i0] +def childrenD_562 : Fin 3 → Finset Cell := ![(placed21 3 (0, 4) envelope_52), (placed21 6 (4, 7) envelope_506), envelope_562_i0] +theorem common_sub_562 : commonEnvelope childrenD_562 ⊆ insert (3, 3) required_562 := by decide +kernel +theorem child_required_sub_562 : ∀ j, childrenC_562 j ⊆ insert (3, 3) required_562 := by decide +kernel +theorem child_envelope_sub_562 : ∀ j, childrenD_562 j ⊆ envelope_562 := by decide +kernel +theorem pivot_mem_562 : (3, 3) ∈ envelope_562 := by decide +kernel +theorem children_work_562 : ∀ j, Template HasSnaky 8 (childrenC_562 j) (childrenD_562 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_506 6 (4, 7)).mono (by decide +kernel) + · exact row_works_562_i0.mono (by decide +kernel) +theorem row_works_562 : Template HasSnaky 9 required_562 envelope_562 := by + refine compose HasSnaky 8 childrenC_562 childrenD_562 children_work_562 (3, 3) + required_562 envelope_562 pivot_mem_562 child_required_sub_562 child_envelope_sub_562 ?_ + intro b hb + exact common_sub_562 (mem_commonEnvelope childrenD_562 b hb) +def required_570_i0 : Finset Cell := ⟨(([(3, 6), (4, 3), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_570_i0 : Finset Cell := ⟨(([(3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_570_i0 : Fin 2 → Finset Cell := ![(placed21 5 (4, 3) required_5), (placed21 4 (3, 9) required_446)] +def childrenD_570_i0 : Fin 2 → Finset Cell := ![(placed21 5 (4, 3) envelope_5), (placed21 4 (3, 9) envelope_446)] +theorem common_sub_570_i0 : commonEnvelope childrenD_570_i0 ⊆ insert (4, 5) required_570_i0 := by decide +kernel +theorem child_required_sub_570_i0 : ∀ j, childrenC_570_i0 j ⊆ insert (4, 5) required_570_i0 := by decide +kernel +theorem child_envelope_sub_570_i0 : ∀ j, childrenD_570_i0 j ⊆ envelope_570_i0 := by decide +kernel +theorem pivot_mem_570_i0 : (4, 5) ∈ envelope_570_i0 := by decide +kernel +theorem children_work_570_i0 : ∀ j, Template HasSnaky 7 (childrenC_570_i0 j) (childrenD_570_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_446 4 (3, 9)).mono (by decide +kernel) +theorem row_works_570_i0 : Template HasSnaky 8 required_570_i0 envelope_570_i0 := by + refine compose HasSnaky 7 childrenC_570_i0 childrenD_570_i0 children_work_570_i0 (4, 5) + required_570_i0 envelope_570_i0 pivot_mem_570_i0 child_required_sub_570_i0 child_envelope_sub_570_i0 ?_ + intro b hb + exact common_sub_570_i0 (mem_commonEnvelope childrenD_570_i0 b hb) +def required_570_i2 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_570_i2 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_570_i2 : Fin 3 → Finset Cell := ![(placed21 3 (2, 4) required_20), (placed21 1 (2, 3) required_29), (placed21 0 (2, 0) required_331)] +def childrenD_570_i2 : Fin 3 → Finset Cell := ![(placed21 3 (2, 4) envelope_20), (placed21 1 (2, 3) envelope_29), (placed21 0 (2, 0) envelope_331)] +theorem common_sub_570_i2 : commonEnvelope childrenD_570_i2 ⊆ insert (5, 3) required_570_i2 := by decide +kernel +theorem child_required_sub_570_i2 : ∀ j, childrenC_570_i2 j ⊆ insert (5, 3) required_570_i2 := by decide +kernel +theorem child_envelope_sub_570_i2 : ∀ j, childrenD_570_i2 j ⊆ envelope_570_i2 := by decide +kernel +theorem pivot_mem_570_i2 : (5, 3) ∈ envelope_570_i2 := by decide +kernel +theorem children_work_570_i2 : ∀ j, Template HasSnaky 6 (childrenC_570_i2 j) (childrenD_570_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_20 3 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_29 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_331 0 (2, 0)).mono (by decide +kernel) +theorem row_works_570_i2 : Template HasSnaky 7 required_570_i2 envelope_570_i2 := by + refine compose HasSnaky 6 childrenC_570_i2 childrenD_570_i2 children_work_570_i2 (5, 3) + required_570_i2 envelope_570_i2 pivot_mem_570_i2 child_required_sub_570_i2 child_envelope_sub_570_i2 ?_ + intro b hb + exact common_sub_570_i2 (mem_commonEnvelope childrenD_570_i2 b hb) +def required_570_i1 : Finset Cell := ⟨(([(0, 3), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_570_i1 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_570_i1 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_1), required_570_i2] +def childrenD_570_i1 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_1), envelope_570_i2] +theorem common_sub_570_i1 : commonEnvelope childrenD_570_i1 ⊆ insert (2, 3) required_570_i1 := by decide +kernel +theorem child_required_sub_570_i1 : ∀ j, childrenC_570_i1 j ⊆ insert (2, 3) required_570_i1 := by decide +kernel +theorem child_envelope_sub_570_i1 : ∀ j, childrenD_570_i1 j ⊆ envelope_570_i1 := by decide +kernel +theorem pivot_mem_570_i1 : (2, 3) ∈ envelope_570_i1 := by decide +kernel +theorem children_work_570_i1 : ∀ j, Template HasSnaky 7 (childrenC_570_i1 j) (childrenD_570_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (0, 3)).mono (by decide +kernel) + · exact row_works_570_i2.mono (by decide +kernel) +theorem row_works_570_i1 : Template HasSnaky 8 required_570_i1 envelope_570_i1 := by + refine compose HasSnaky 7 childrenC_570_i1 childrenD_570_i1 children_work_570_i1 (2, 3) + required_570_i1 envelope_570_i1 pivot_mem_570_i1 child_required_sub_570_i1 child_envelope_sub_570_i1 ?_ + intro b hb + exact common_sub_570_i1 (mem_commonEnvelope childrenD_570_i1 b hb) +def required_570 : Finset Cell := ⟨(([(0, 3), (3, 3), (3, 4), (3, 6), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_570 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3), (3, 4), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_570 : Fin 4 → Finset Cell := ![(placed21 4 (3, 7) required_150), (placed21 0 (0, 1) required_283), required_570_i0, required_570_i1] +def childrenD_570 : Fin 4 → Finset Cell := ![(placed21 4 (3, 7) envelope_150), (placed21 0 (0, 1) envelope_283), envelope_570_i0, envelope_570_i1] +theorem common_sub_570 : commonEnvelope childrenD_570 ⊆ insert (4, 3) required_570 := by decide +kernel +theorem child_required_sub_570 : ∀ j, childrenC_570 j ⊆ insert (4, 3) required_570 := by decide +kernel +theorem child_envelope_sub_570 : ∀ j, childrenD_570 j ⊆ envelope_570 := by decide +kernel +theorem pivot_mem_570 : (4, 3) ∈ envelope_570 := by decide +kernel +theorem children_work_570 : ∀ j, Template HasSnaky 8 (childrenC_570 j) (childrenD_570 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_150 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_283 0 (0, 1)).mono (by decide +kernel) + · exact row_works_570_i0.mono (by decide +kernel) + · exact row_works_570_i1.mono (by decide +kernel) +theorem row_works_570 : Template HasSnaky 9 required_570 envelope_570 := by + refine compose HasSnaky 8 childrenC_570 childrenD_570 children_work_570 (4, 3) + required_570 envelope_570 pivot_mem_570 child_required_sub_570 child_envelope_sub_570 ?_ + intro b hb + exact common_sub_570 (mem_commonEnvelope childrenD_570 b hb) +def height_539_i4 : ℕ := 3 +def childrenH_539_i4 : Fin 2 → ℕ := ![height_5, height_6] +theorem height_exact_539_i4 : height_539_i4 = 1 + Finset.univ.sup childrenH_539_i4 := by decide +kernel +theorem required_origin_539_i4 : ∀ x ∈ required_539_i4, + (∃ j, x ∈ childrenC_539_i4 j) ∨ ∀ j, x ∈ childrenD_539_i4 j := by decide +kernel +theorem required_exact_539_i4 : required_539_i4 = + ((Finset.univ.biUnion childrenC_539_i4) ∪ commonEnvelope childrenD_539_i4).erase (3, 5) := by + exact required_eq_combination childrenC_539_i4 childrenD_539_i4 (3, 5) required_539_i4 + (by decide +kernel) child_required_sub_539_i4 common_sub_539_i4 required_origin_539_i4 +theorem envelope_origin_539_i4 : ∀ x ∈ envelope_539_i4, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_539_i4 j := by decide +kernel +theorem envelope_exact_539_i4 : envelope_539_i4 = + insert (3, 5) (Finset.univ.biUnion childrenD_539_i4) := by + exact envelope_eq_combination childrenD_539_i4 (3, 5) envelope_539_i4 + pivot_mem_539_i4 child_envelope_sub_539_i4 envelope_origin_539_i4 +def checked_539_i4 : CheckedCard where + required := required_539_i4 + envelope := envelope_539_i4 + height := height_539_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i4 +def height_539_i3 : ℕ := 4 +def childrenH_539_i3 : Fin 2 → ℕ := ![height_5, height_539_i4] +theorem height_exact_539_i3 : height_539_i3 = 1 + Finset.univ.sup childrenH_539_i3 := by decide +kernel +theorem required_origin_539_i3 : ∀ x ∈ required_539_i3, + (∃ j, x ∈ childrenC_539_i3 j) ∨ ∀ j, x ∈ childrenD_539_i3 j := by decide +kernel +theorem required_exact_539_i3 : required_539_i3 = + ((Finset.univ.biUnion childrenC_539_i3) ∪ commonEnvelope childrenD_539_i3).erase (3, 4) := by + exact required_eq_combination childrenC_539_i3 childrenD_539_i3 (3, 4) required_539_i3 + (by decide +kernel) child_required_sub_539_i3 common_sub_539_i3 required_origin_539_i3 +theorem envelope_origin_539_i3 : ∀ x ∈ envelope_539_i3, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_539_i3 j := by decide +kernel +theorem envelope_exact_539_i3 : envelope_539_i3 = + insert (3, 4) (Finset.univ.biUnion childrenD_539_i3) := by + exact envelope_eq_combination childrenD_539_i3 (3, 4) envelope_539_i3 + pivot_mem_539_i3 child_envelope_sub_539_i3 envelope_origin_539_i3 +def checked_539_i3 : CheckedCard where + required := required_539_i3 + envelope := envelope_539_i3 + height := height_539_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i3 +def height_539_i7 : ℕ := 3 +def childrenH_539_i7 : Fin 2 → ℕ := ![height_1, height_153] +theorem height_exact_539_i7 : height_539_i7 = 1 + Finset.univ.sup childrenH_539_i7 := by decide +kernel +theorem required_origin_539_i7 : ∀ x ∈ required_539_i7, + (∃ j, x ∈ childrenC_539_i7 j) ∨ ∀ j, x ∈ childrenD_539_i7 j := by decide +kernel +theorem required_exact_539_i7 : required_539_i7 = + ((Finset.univ.biUnion childrenC_539_i7) ∪ commonEnvelope childrenD_539_i7).erase (4, 2) := by + exact required_eq_combination childrenC_539_i7 childrenD_539_i7 (4, 2) required_539_i7 + (by decide +kernel) child_required_sub_539_i7 common_sub_539_i7 required_origin_539_i7 +theorem envelope_origin_539_i7 : ∀ x ∈ envelope_539_i7, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_539_i7 j := by decide +kernel +theorem envelope_exact_539_i7 : envelope_539_i7 = + insert (4, 2) (Finset.univ.biUnion childrenD_539_i7) := by + exact envelope_eq_combination childrenD_539_i7 (4, 2) envelope_539_i7 + pivot_mem_539_i7 child_envelope_sub_539_i7 envelope_origin_539_i7 +def checked_539_i7 : CheckedCard where + required := required_539_i7 + envelope := envelope_539_i7 + height := height_539_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i7 +def height_539_i6 : ℕ := 4 +def childrenH_539_i6 : Fin 2 → ℕ := ![height_5, height_539_i7] +theorem height_exact_539_i6 : height_539_i6 = 1 + Finset.univ.sup childrenH_539_i6 := by decide +kernel +theorem required_origin_539_i6 : ∀ x ∈ required_539_i6, + (∃ j, x ∈ childrenC_539_i6 j) ∨ ∀ j, x ∈ childrenD_539_i6 j := by decide +kernel +theorem required_exact_539_i6 : required_539_i6 = + ((Finset.univ.biUnion childrenC_539_i6) ∪ commonEnvelope childrenD_539_i6).erase (3, 5) := by + exact required_eq_combination childrenC_539_i6 childrenD_539_i6 (3, 5) required_539_i6 + (by decide +kernel) child_required_sub_539_i6 common_sub_539_i6 required_origin_539_i6 +theorem envelope_origin_539_i6 : ∀ x ∈ envelope_539_i6, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_539_i6 j := by decide +kernel +theorem envelope_exact_539_i6 : envelope_539_i6 = + insert (3, 5) (Finset.univ.biUnion childrenD_539_i6) := by + exact envelope_eq_combination childrenD_539_i6 (3, 5) envelope_539_i6 + pivot_mem_539_i6 child_envelope_sub_539_i6 envelope_origin_539_i6 +def checked_539_i6 : CheckedCard where + required := required_539_i6 + envelope := envelope_539_i6 + height := height_539_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i6 +def height_539_i5 : ℕ := 5 +def childrenH_539_i5 : Fin 2 → ℕ := ![height_5, height_539_i6] +theorem height_exact_539_i5 : height_539_i5 = 1 + Finset.univ.sup childrenH_539_i5 := by decide +kernel +theorem required_origin_539_i5 : ∀ x ∈ required_539_i5, + (∃ j, x ∈ childrenC_539_i5 j) ∨ ∀ j, x ∈ childrenD_539_i5 j := by decide +kernel +theorem required_exact_539_i5 : required_539_i5 = + ((Finset.univ.biUnion childrenC_539_i5) ∪ commonEnvelope childrenD_539_i5).erase (3, 4) := by + exact required_eq_combination childrenC_539_i5 childrenD_539_i5 (3, 4) required_539_i5 + (by decide +kernel) child_required_sub_539_i5 common_sub_539_i5 required_origin_539_i5 +theorem envelope_origin_539_i5 : ∀ x ∈ envelope_539_i5, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_539_i5 j := by decide +kernel +theorem envelope_exact_539_i5 : envelope_539_i5 = + insert (3, 4) (Finset.univ.biUnion childrenD_539_i5) := by + exact envelope_eq_combination childrenD_539_i5 (3, 4) envelope_539_i5 + pivot_mem_539_i5 child_envelope_sub_539_i5 envelope_origin_539_i5 +def checked_539_i5 : CheckedCard where + required := required_539_i5 + envelope := envelope_539_i5 + height := height_539_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i5 +def height_539_i9 : ℕ := 2 +def childrenH_539_i9 : Fin 2 → ℕ := ![height_0, height_2] +theorem height_exact_539_i9 : height_539_i9 = 1 + Finset.univ.sup childrenH_539_i9 := by decide +kernel +theorem required_origin_539_i9 : ∀ x ∈ required_539_i9, + (∃ j, x ∈ childrenC_539_i9 j) ∨ ∀ j, x ∈ childrenD_539_i9 j := by decide +kernel +theorem required_exact_539_i9 : required_539_i9 = + ((Finset.univ.biUnion childrenC_539_i9) ∪ commonEnvelope childrenD_539_i9).erase (1, 2) := by + exact required_eq_combination childrenC_539_i9 childrenD_539_i9 (1, 2) required_539_i9 + (by decide +kernel) child_required_sub_539_i9 common_sub_539_i9 required_origin_539_i9 +theorem envelope_origin_539_i9 : ∀ x ∈ envelope_539_i9, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_539_i9 j := by decide +kernel +theorem envelope_exact_539_i9 : envelope_539_i9 = + insert (1, 2) (Finset.univ.biUnion childrenD_539_i9) := by + exact envelope_eq_combination childrenD_539_i9 (1, 2) envelope_539_i9 + pivot_mem_539_i9 child_envelope_sub_539_i9 envelope_origin_539_i9 +def checked_539_i9 : CheckedCard where + required := required_539_i9 + envelope := envelope_539_i9 + height := height_539_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i9 +def height_539_i8 : ℕ := 3 +def childrenH_539_i8 : Fin 2 → ℕ := ![height_5, height_539_i9] +theorem height_exact_539_i8 : height_539_i8 = 1 + Finset.univ.sup childrenH_539_i8 := by decide +kernel +theorem required_origin_539_i8 : ∀ x ∈ required_539_i8, + (∃ j, x ∈ childrenC_539_i8 j) ∨ ∀ j, x ∈ childrenD_539_i8 j := by decide +kernel +theorem required_exact_539_i8 : required_539_i8 = + ((Finset.univ.biUnion childrenC_539_i8) ∪ commonEnvelope childrenD_539_i8).erase (1, 1) := by + exact required_eq_combination childrenC_539_i8 childrenD_539_i8 (1, 1) required_539_i8 + (by decide +kernel) child_required_sub_539_i8 common_sub_539_i8 required_origin_539_i8 +theorem envelope_origin_539_i8 : ∀ x ∈ envelope_539_i8, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_539_i8 j := by decide +kernel +theorem envelope_exact_539_i8 : envelope_539_i8 = + insert (1, 1) (Finset.univ.biUnion childrenD_539_i8) := by + exact envelope_eq_combination childrenD_539_i8 (1, 1) envelope_539_i8 + pivot_mem_539_i8 child_envelope_sub_539_i8 envelope_origin_539_i8 +def checked_539_i8 : CheckedCard where + required := required_539_i8 + envelope := envelope_539_i8 + height := height_539_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i8 +def height_539_i10 : ℕ := 3 +def childrenH_539_i10 : Fin 2 → ℕ := ![height_83, height_281] +theorem height_exact_539_i10 : height_539_i10 = 1 + Finset.univ.sup childrenH_539_i10 := by decide +kernel +theorem required_origin_539_i10 : ∀ x ∈ required_539_i10, + (∃ j, x ∈ childrenC_539_i10 j) ∨ ∀ j, x ∈ childrenD_539_i10 j := by decide +kernel +theorem required_exact_539_i10 : required_539_i10 = + ((Finset.univ.biUnion childrenC_539_i10) ∪ commonEnvelope childrenD_539_i10).erase (4, 1) := by + exact required_eq_combination childrenC_539_i10 childrenD_539_i10 (4, 1) required_539_i10 + (by decide +kernel) child_required_sub_539_i10 common_sub_539_i10 required_origin_539_i10 +theorem envelope_origin_539_i10 : ∀ x ∈ envelope_539_i10, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_539_i10 j := by decide +kernel +theorem envelope_exact_539_i10 : envelope_539_i10 = + insert (4, 1) (Finset.univ.biUnion childrenD_539_i10) := by + exact envelope_eq_combination childrenD_539_i10 (4, 1) envelope_539_i10 + pivot_mem_539_i10 child_envelope_sub_539_i10 envelope_origin_539_i10 +def checked_539_i10 : CheckedCard where + required := required_539_i10 + envelope := envelope_539_i10 + height := height_539_i10 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i10 +def height_539_i2 : ℕ := 6 +def childrenH_539_i2 : Fin 4 → ℕ := ![height_539_i3, height_539_i5, height_539_i8, height_539_i10] +theorem height_exact_539_i2 : height_539_i2 = 1 + Finset.univ.sup childrenH_539_i2 := by decide +kernel +theorem required_origin_539_i2 : ∀ x ∈ required_539_i2, + (∃ j, x ∈ childrenC_539_i2 j) ∨ ∀ j, x ∈ childrenD_539_i2 j := by decide +kernel +theorem required_exact_539_i2 : required_539_i2 = + ((Finset.univ.biUnion childrenC_539_i2) ∪ commonEnvelope childrenD_539_i2).erase (2, 1) := by + exact required_eq_combination childrenC_539_i2 childrenD_539_i2 (2, 1) required_539_i2 + (by decide +kernel) child_required_sub_539_i2 common_sub_539_i2 required_origin_539_i2 +theorem envelope_origin_539_i2 : ∀ x ∈ envelope_539_i2, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_539_i2 j := by decide +kernel +theorem envelope_exact_539_i2 : envelope_539_i2 = + insert (2, 1) (Finset.univ.biUnion childrenD_539_i2) := by + exact envelope_eq_combination childrenD_539_i2 (2, 1) envelope_539_i2 + pivot_mem_539_i2 child_envelope_sub_539_i2 envelope_origin_539_i2 +def checked_539_i2 : CheckedCard where + required := required_539_i2 + envelope := envelope_539_i2 + height := height_539_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i2 +def height_539_i1 : ℕ := 7 +def childrenH_539_i1 : Fin 2 → ℕ := ![height_4, height_539_i2] +theorem height_exact_539_i1 : height_539_i1 = 1 + Finset.univ.sup childrenH_539_i1 := by decide +kernel +theorem required_origin_539_i1 : ∀ x ∈ required_539_i1, + (∃ j, x ∈ childrenC_539_i1 j) ∨ ∀ j, x ∈ childrenD_539_i1 j := by decide +kernel +theorem required_exact_539_i1 : required_539_i1 = + ((Finset.univ.biUnion childrenC_539_i1) ∪ commonEnvelope childrenD_539_i1).erase (2, 5) := by + exact required_eq_combination childrenC_539_i1 childrenD_539_i1 (2, 5) required_539_i1 + (by decide +kernel) child_required_sub_539_i1 common_sub_539_i1 required_origin_539_i1 +theorem envelope_origin_539_i1 : ∀ x ∈ envelope_539_i1, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_539_i1 j := by decide +kernel +theorem envelope_exact_539_i1 : envelope_539_i1 = + insert (2, 5) (Finset.univ.biUnion childrenD_539_i1) := by + exact envelope_eq_combination childrenD_539_i1 (2, 5) envelope_539_i1 + pivot_mem_539_i1 child_envelope_sub_539_i1 envelope_origin_539_i1 +def checked_539_i1 : CheckedCard where + required := required_539_i1 + envelope := envelope_539_i1 + height := height_539_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i1 +def height_539_i0 : ℕ := 8 +def childrenH_539_i0 : Fin 2 → ℕ := ![height_5, height_539_i1] +theorem height_exact_539_i0 : height_539_i0 = 1 + Finset.univ.sup childrenH_539_i0 := by decide +kernel +theorem required_origin_539_i0 : ∀ x ∈ required_539_i0, + (∃ j, x ∈ childrenC_539_i0 j) ∨ ∀ j, x ∈ childrenD_539_i0 j := by decide +kernel +theorem required_exact_539_i0 : required_539_i0 = + ((Finset.univ.biUnion childrenC_539_i0) ∪ commonEnvelope childrenD_539_i0).erase (0, 5) := by + exact required_eq_combination childrenC_539_i0 childrenD_539_i0 (0, 5) required_539_i0 + (by decide +kernel) child_required_sub_539_i0 common_sub_539_i0 required_origin_539_i0 +theorem envelope_origin_539_i0 : ∀ x ∈ envelope_539_i0, + x = (0, 5) ∨ ∃ j, x ∈ childrenD_539_i0 j := by decide +kernel +theorem envelope_exact_539_i0 : envelope_539_i0 = + insert (0, 5) (Finset.univ.biUnion childrenD_539_i0) := by + exact envelope_eq_combination childrenD_539_i0 (0, 5) envelope_539_i0 + pivot_mem_539_i0 child_envelope_sub_539_i0 envelope_origin_539_i0 +def checked_539_i0 : CheckedCard where + required := required_539_i0 + envelope := envelope_539_i0 + height := height_539_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539_i0 +def height_539 : ℕ := 9 +def childrenH_539 : Fin 2 → ℕ := ![height_6, height_539_i0] +theorem height_exact_539 : height_539 = 1 + Finset.univ.sup childrenH_539 := by decide +kernel +theorem required_origin_539 : ∀ x ∈ required_539, + (∃ j, x ∈ childrenC_539 j) ∨ ∀ j, x ∈ childrenD_539 j := by decide +kernel +theorem required_exact_539 : required_539 = + ((Finset.univ.biUnion childrenC_539) ∪ commonEnvelope childrenD_539).erase (1, 9) := by + exact required_eq_combination childrenC_539 childrenD_539 (1, 9) required_539 + (by decide +kernel) child_required_sub_539 common_sub_539 required_origin_539 +theorem envelope_origin_539 : ∀ x ∈ envelope_539, + x = (1, 9) ∨ ∃ j, x ∈ childrenD_539 j := by decide +kernel +theorem envelope_exact_539 : envelope_539 = + insert (1, 9) (Finset.univ.biUnion childrenD_539) := by + exact envelope_eq_combination childrenD_539 (1, 9) envelope_539 + pivot_mem_539 child_envelope_sub_539 envelope_origin_539 +def checked_539 : CheckedCard where + required := required_539 + envelope := envelope_539 + height := height_539 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_539 +def height_548 : ℕ := 9 +def childrenH_548 : Fin 4 → ℕ := ![height_10, height_52, height_189, height_547] +theorem height_exact_548 : height_548 = 1 + Finset.univ.sup childrenH_548 := by decide +kernel +theorem required_origin_548 : ∀ x ∈ required_548, + (∃ j, x ∈ childrenC_548 j) ∨ ∀ j, x ∈ childrenD_548 j := by decide +kernel +theorem required_exact_548 : required_548 = + ((Finset.univ.biUnion childrenC_548) ∪ commonEnvelope childrenD_548).erase (1, 7) := by + exact required_eq_combination childrenC_548 childrenD_548 (1, 7) required_548 + (by decide +kernel) child_required_sub_548 common_sub_548 required_origin_548 +theorem envelope_origin_548 : ∀ x ∈ envelope_548, + x = (1, 7) ∨ ∃ j, x ∈ childrenD_548 j := by decide +kernel +theorem envelope_exact_548 : envelope_548 = + insert (1, 7) (Finset.univ.biUnion childrenD_548) := by + exact envelope_eq_combination childrenD_548 (1, 7) envelope_548 + pivot_mem_548 child_envelope_sub_548 envelope_origin_548 +def checked_548 : CheckedCard where + required := required_548 + envelope := envelope_548 + height := height_548 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_548 +def height_549 : ℕ := 9 +def childrenH_549 : Fin 4 → ℕ := ![height_10, height_52, height_63, height_547] +theorem height_exact_549 : height_549 = 1 + Finset.univ.sup childrenH_549 := by decide +kernel +theorem required_origin_549 : ∀ x ∈ required_549, + (∃ j, x ∈ childrenC_549 j) ∨ ∀ j, x ∈ childrenD_549 j := by decide +kernel +theorem required_exact_549 : required_549 = + ((Finset.univ.biUnion childrenC_549) ∪ commonEnvelope childrenD_549).erase (1, 3) := by + exact required_eq_combination childrenC_549 childrenD_549 (1, 3) required_549 + (by decide +kernel) child_required_sub_549 common_sub_549 required_origin_549 +theorem envelope_origin_549 : ∀ x ∈ envelope_549, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_549 j := by decide +kernel +theorem envelope_exact_549 : envelope_549 = + insert (1, 3) (Finset.univ.biUnion childrenD_549) := by + exact envelope_eq_combination childrenD_549 (1, 3) envelope_549 + pivot_mem_549 child_envelope_sub_549 envelope_origin_549 +def checked_549 : CheckedCard where + required := required_549 + envelope := envelope_549 + height := height_549 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_549 +def height_561_i0 : ℕ := 5 +def childrenH_561_i0 : Fin 2 → ℕ := ![height_1, height_57] +theorem height_exact_561_i0 : height_561_i0 = 1 + Finset.univ.sup childrenH_561_i0 := by decide +kernel +theorem required_origin_561_i0 : ∀ x ∈ required_561_i0, + (∃ j, x ∈ childrenC_561_i0 j) ∨ ∀ j, x ∈ childrenD_561_i0 j := by decide +kernel +theorem required_exact_561_i0 : required_561_i0 = + ((Finset.univ.biUnion childrenC_561_i0) ∪ commonEnvelope childrenD_561_i0).erase (2, 4) := by + exact required_eq_combination childrenC_561_i0 childrenD_561_i0 (2, 4) required_561_i0 + (by decide +kernel) child_required_sub_561_i0 common_sub_561_i0 required_origin_561_i0 +theorem envelope_origin_561_i0 : ∀ x ∈ envelope_561_i0, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_561_i0 j := by decide +kernel +theorem envelope_exact_561_i0 : envelope_561_i0 = + insert (2, 4) (Finset.univ.biUnion childrenD_561_i0) := by + exact envelope_eq_combination childrenD_561_i0 (2, 4) envelope_561_i0 + pivot_mem_561_i0 child_envelope_sub_561_i0 envelope_origin_561_i0 +def checked_561_i0 : CheckedCard where + required := required_561_i0 + envelope := envelope_561_i0 + height := height_561_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_561_i0 +def height_561 : ℕ := 9 +def childrenH_561 : Fin 4 → ℕ := ![height_154, height_319, height_335, height_561_i0] +theorem height_exact_561 : height_561 = 1 + Finset.univ.sup childrenH_561 := by decide +kernel +theorem required_origin_561 : ∀ x ∈ required_561, + (∃ j, x ∈ childrenC_561 j) ∨ ∀ j, x ∈ childrenD_561 j := by decide +kernel +theorem required_exact_561 : required_561 = + ((Finset.univ.biUnion childrenC_561) ∪ commonEnvelope childrenD_561).erase (2, 7) := by + exact required_eq_combination childrenC_561 childrenD_561 (2, 7) required_561 + (by decide +kernel) child_required_sub_561 common_sub_561 required_origin_561 +theorem envelope_origin_561 : ∀ x ∈ envelope_561, + x = (2, 7) ∨ ∃ j, x ∈ childrenD_561 j := by decide +kernel +theorem envelope_exact_561 : envelope_561 = + insert (2, 7) (Finset.univ.biUnion childrenD_561) := by + exact envelope_eq_combination childrenD_561 (2, 7) envelope_561 + pivot_mem_561 child_envelope_sub_561 envelope_origin_561 +def checked_561 : CheckedCard where + required := required_561 + envelope := envelope_561 + height := height_561 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_561 +def height_562_i0 : ℕ := 8 +def childrenH_562_i0 : Fin 5 → ℕ := ![height_13, height_14, height_33, height_122, height_388] +theorem height_exact_562_i0 : height_562_i0 = 1 + Finset.univ.sup childrenH_562_i0 := by decide +kernel +theorem required_origin_562_i0 : ∀ x ∈ required_562_i0, + (∃ j, x ∈ childrenC_562_i0 j) ∨ ∀ j, x ∈ childrenD_562_i0 j := by decide +kernel +theorem required_exact_562_i0 : required_562_i0 = + ((Finset.univ.biUnion childrenC_562_i0) ∪ commonEnvelope childrenD_562_i0).erase (3, 5) := by + exact required_eq_combination childrenC_562_i0 childrenD_562_i0 (3, 5) required_562_i0 + (by decide +kernel) child_required_sub_562_i0 common_sub_562_i0 required_origin_562_i0 +theorem envelope_origin_562_i0 : ∀ x ∈ envelope_562_i0, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_562_i0 j := by decide +kernel +theorem envelope_exact_562_i0 : envelope_562_i0 = + insert (3, 5) (Finset.univ.biUnion childrenD_562_i0) := by + exact envelope_eq_combination childrenD_562_i0 (3, 5) envelope_562_i0 + pivot_mem_562_i0 child_envelope_sub_562_i0 envelope_origin_562_i0 +def checked_562_i0 : CheckedCard where + required := required_562_i0 + envelope := envelope_562_i0 + height := height_562_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_562_i0 +def height_562 : ℕ := 9 +def childrenH_562 : Fin 3 → ℕ := ![height_52, height_506, height_562_i0] +theorem height_exact_562 : height_562 = 1 + Finset.univ.sup childrenH_562 := by decide +kernel +theorem required_origin_562 : ∀ x ∈ required_562, + (∃ j, x ∈ childrenC_562 j) ∨ ∀ j, x ∈ childrenD_562 j := by decide +kernel +theorem required_exact_562 : required_562 = + ((Finset.univ.biUnion childrenC_562) ∪ commonEnvelope childrenD_562).erase (3, 3) := by + exact required_eq_combination childrenC_562 childrenD_562 (3, 3) required_562 + (by decide +kernel) child_required_sub_562 common_sub_562 required_origin_562 +theorem envelope_origin_562 : ∀ x ∈ envelope_562, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_562 j := by decide +kernel +theorem envelope_exact_562 : envelope_562 = + insert (3, 3) (Finset.univ.biUnion childrenD_562) := by + exact envelope_eq_combination childrenD_562 (3, 3) envelope_562 + pivot_mem_562 child_envelope_sub_562 envelope_origin_562 +def checked_562 : CheckedCard where + required := required_562 + envelope := envelope_562 + height := height_562 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_562 +def height_570_i0 : ℕ := 8 +def childrenH_570_i0 : Fin 2 → ℕ := ![height_5, height_446] +theorem height_exact_570_i0 : height_570_i0 = 1 + Finset.univ.sup childrenH_570_i0 := by decide +kernel +theorem required_origin_570_i0 : ∀ x ∈ required_570_i0, + (∃ j, x ∈ childrenC_570_i0 j) ∨ ∀ j, x ∈ childrenD_570_i0 j := by decide +kernel +theorem required_exact_570_i0 : required_570_i0 = + ((Finset.univ.biUnion childrenC_570_i0) ∪ commonEnvelope childrenD_570_i0).erase (4, 5) := by + exact required_eq_combination childrenC_570_i0 childrenD_570_i0 (4, 5) required_570_i0 + (by decide +kernel) child_required_sub_570_i0 common_sub_570_i0 required_origin_570_i0 +theorem envelope_origin_570_i0 : ∀ x ∈ envelope_570_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_570_i0 j := by decide +kernel +theorem envelope_exact_570_i0 : envelope_570_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_570_i0) := by + exact envelope_eq_combination childrenD_570_i0 (4, 5) envelope_570_i0 + pivot_mem_570_i0 child_envelope_sub_570_i0 envelope_origin_570_i0 +def checked_570_i0 : CheckedCard where + required := required_570_i0 + envelope := envelope_570_i0 + height := height_570_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_570_i0 +def height_570_i2 : ℕ := 7 +def childrenH_570_i2 : Fin 3 → ℕ := ![height_20, height_29, height_331] +theorem height_exact_570_i2 : height_570_i2 = 1 + Finset.univ.sup childrenH_570_i2 := by decide +kernel +theorem required_origin_570_i2 : ∀ x ∈ required_570_i2, + (∃ j, x ∈ childrenC_570_i2 j) ∨ ∀ j, x ∈ childrenD_570_i2 j := by decide +kernel +theorem required_exact_570_i2 : required_570_i2 = + ((Finset.univ.biUnion childrenC_570_i2) ∪ commonEnvelope childrenD_570_i2).erase (5, 3) := by + exact required_eq_combination childrenC_570_i2 childrenD_570_i2 (5, 3) required_570_i2 + (by decide +kernel) child_required_sub_570_i2 common_sub_570_i2 required_origin_570_i2 +theorem envelope_origin_570_i2 : ∀ x ∈ envelope_570_i2, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_570_i2 j := by decide +kernel +theorem envelope_exact_570_i2 : envelope_570_i2 = + insert (5, 3) (Finset.univ.biUnion childrenD_570_i2) := by + exact envelope_eq_combination childrenD_570_i2 (5, 3) envelope_570_i2 + pivot_mem_570_i2 child_envelope_sub_570_i2 envelope_origin_570_i2 +def checked_570_i2 : CheckedCard where + required := required_570_i2 + envelope := envelope_570_i2 + height := height_570_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_570_i2 +def height_570_i1 : ℕ := 8 +def childrenH_570_i1 : Fin 2 → ℕ := ![height_1, height_570_i2] +theorem height_exact_570_i1 : height_570_i1 = 1 + Finset.univ.sup childrenH_570_i1 := by decide +kernel +theorem required_origin_570_i1 : ∀ x ∈ required_570_i1, + (∃ j, x ∈ childrenC_570_i1 j) ∨ ∀ j, x ∈ childrenD_570_i1 j := by decide +kernel +theorem required_exact_570_i1 : required_570_i1 = + ((Finset.univ.biUnion childrenC_570_i1) ∪ commonEnvelope childrenD_570_i1).erase (2, 3) := by + exact required_eq_combination childrenC_570_i1 childrenD_570_i1 (2, 3) required_570_i1 + (by decide +kernel) child_required_sub_570_i1 common_sub_570_i1 required_origin_570_i1 +theorem envelope_origin_570_i1 : ∀ x ∈ envelope_570_i1, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_570_i1 j := by decide +kernel +theorem envelope_exact_570_i1 : envelope_570_i1 = + insert (2, 3) (Finset.univ.biUnion childrenD_570_i1) := by + exact envelope_eq_combination childrenD_570_i1 (2, 3) envelope_570_i1 + pivot_mem_570_i1 child_envelope_sub_570_i1 envelope_origin_570_i1 +def checked_570_i1 : CheckedCard where + required := required_570_i1 + envelope := envelope_570_i1 + height := height_570_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_570_i1 +def height_570 : ℕ := 9 +def childrenH_570 : Fin 4 → ℕ := ![height_150, height_283, height_570_i0, height_570_i1] +theorem height_exact_570 : height_570 = 1 + Finset.univ.sup childrenH_570 := by decide +kernel +theorem required_origin_570 : ∀ x ∈ required_570, + (∃ j, x ∈ childrenC_570 j) ∨ ∀ j, x ∈ childrenD_570 j := by decide +kernel +theorem required_exact_570 : required_570 = + ((Finset.univ.biUnion childrenC_570) ∪ commonEnvelope childrenD_570).erase (4, 3) := by + exact required_eq_combination childrenC_570 childrenD_570 (4, 3) required_570 + (by decide +kernel) child_required_sub_570 common_sub_570 required_origin_570 +theorem envelope_origin_570 : ∀ x ∈ envelope_570, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_570 j := by decide +kernel +theorem envelope_exact_570 : envelope_570 = + insert (4, 3) (Finset.univ.biUnion childrenD_570) := by + exact envelope_eq_combination childrenD_570 (4, 3) envelope_570 + pivot_mem_570 child_envelope_sub_570 envelope_origin_570 +def checked_570 : CheckedCard where + required := required_570 + envelope := envelope_570 + height := height_570 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_570 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part05.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part05.lean new file mode 100644 index 0000000..9fd42c3 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part05.lean @@ -0,0 +1,605 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_574_i1 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_574_i1 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_574_i1 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) required_43), (placed21 6 (4, 6) required_64)] +def childrenD_574_i1 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) envelope_43), (placed21 6 (4, 6) envelope_64)] +theorem common_sub_574_i1 : commonEnvelope childrenD_574_i1 ⊆ insert (3, 3) required_574_i1 := by decide +kernel +theorem child_required_sub_574_i1 : ∀ j, childrenC_574_i1 j ⊆ insert (3, 3) required_574_i1 := by decide +kernel +theorem child_envelope_sub_574_i1 : ∀ j, childrenD_574_i1 j ⊆ envelope_574_i1 := by decide +kernel +theorem pivot_mem_574_i1 : (3, 3) ∈ envelope_574_i1 := by decide +kernel +theorem children_work_574_i1 : ∀ j, Template HasSnaky 3 (childrenC_574_i1 j) (childrenD_574_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_43 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_64 6 (4, 6)).mono (by decide +kernel) +theorem row_works_574_i1 : Template HasSnaky 4 required_574_i1 envelope_574_i1 := by + refine compose HasSnaky 3 childrenC_574_i1 childrenD_574_i1 children_work_574_i1 (3, 3) + required_574_i1 envelope_574_i1 pivot_mem_574_i1 child_required_sub_574_i1 child_envelope_sub_574_i1 ?_ + intro b hb + exact common_sub_574_i1 (mem_commonEnvelope childrenD_574_i1 b hb) +def required_574_i3 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_574_i3 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_574_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) required_5), (placed21 0 (1, 1) required_223)] +def childrenD_574_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) envelope_5), (placed21 0 (1, 1) envelope_223)] +theorem common_sub_574_i3 : commonEnvelope childrenD_574_i3 ⊆ insert (4, 4) required_574_i3 := by decide +kernel +theorem child_required_sub_574_i3 : ∀ j, childrenC_574_i3 j ⊆ insert (4, 4) required_574_i3 := by decide +kernel +theorem child_envelope_sub_574_i3 : ∀ j, childrenD_574_i3 j ⊆ envelope_574_i3 := by decide +kernel +theorem pivot_mem_574_i3 : (4, 4) ∈ envelope_574_i3 := by decide +kernel +theorem children_work_574_i3 : ∀ j, Template HasSnaky 3 (childrenC_574_i3 j) (childrenD_574_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_223 0 (1, 1)).mono (by decide +kernel) +theorem row_works_574_i3 : Template HasSnaky 4 required_574_i3 envelope_574_i3 := by + refine compose HasSnaky 3 childrenC_574_i3 childrenD_574_i3 children_work_574_i3 (4, 4) + required_574_i3 envelope_574_i3 pivot_mem_574_i3 child_required_sub_574_i3 child_envelope_sub_574_i3 ?_ + intro b hb + exact common_sub_574_i3 (mem_commonEnvelope childrenD_574_i3 b hb) +def required_574_i2 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_574_i2 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 3), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_574_i2 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) required_5), required_574_i3] +def childrenD_574_i2 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) envelope_5), envelope_574_i3] +theorem common_sub_574_i2 : commonEnvelope childrenD_574_i2 ⊆ insert (4, 2) required_574_i2 := by decide +kernel +theorem child_required_sub_574_i2 : ∀ j, childrenC_574_i2 j ⊆ insert (4, 2) required_574_i2 := by decide +kernel +theorem child_envelope_sub_574_i2 : ∀ j, childrenD_574_i2 j ⊆ envelope_574_i2 := by decide +kernel +theorem pivot_mem_574_i2 : (4, 2) ∈ envelope_574_i2 := by decide +kernel +theorem children_work_574_i2 : ∀ j, Template HasSnaky 4 (childrenC_574_i2 j) (childrenD_574_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 2)).mono (by decide +kernel) + · exact row_works_574_i3.mono (by decide +kernel) +theorem row_works_574_i2 : Template HasSnaky 5 required_574_i2 envelope_574_i2 := by + refine compose HasSnaky 4 childrenC_574_i2 childrenD_574_i2 children_work_574_i2 (4, 2) + required_574_i2 envelope_574_i2 pivot_mem_574_i2 child_required_sub_574_i2 child_envelope_sub_574_i2 ?_ + intro b hb + exact common_sub_574_i2 (mem_commonEnvelope childrenD_574_i2 b hb) +def required_574_i5 : Finset Cell := ⟨(([(2, 2), (3, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_574_i5 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_574_i5 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) required_5), (placed21 6 (5, 6) required_236)] +def childrenD_574_i5 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) envelope_5), (placed21 6 (5, 6) envelope_236)] +theorem common_sub_574_i5 : commonEnvelope childrenD_574_i5 ⊆ insert (4, 2) required_574_i5 := by decide +kernel +theorem child_required_sub_574_i5 : ∀ j, childrenC_574_i5 j ⊆ insert (4, 2) required_574_i5 := by decide +kernel +theorem child_envelope_sub_574_i5 : ∀ j, childrenD_574_i5 j ⊆ envelope_574_i5 := by decide +kernel +theorem pivot_mem_574_i5 : (4, 2) ∈ envelope_574_i5 := by decide +kernel +theorem children_work_574_i5 : ∀ j, Template HasSnaky 3 (childrenC_574_i5 j) (childrenD_574_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_236 6 (5, 6)).mono (by decide +kernel) +theorem row_works_574_i5 : Template HasSnaky 4 required_574_i5 envelope_574_i5 := by + refine compose HasSnaky 3 childrenC_574_i5 childrenD_574_i5 children_work_574_i5 (4, 2) + required_574_i5 envelope_574_i5 pivot_mem_574_i5 child_required_sub_574_i5 child_envelope_sub_574_i5 ?_ + intro b hb + exact common_sub_574_i5 (mem_commonEnvelope childrenD_574_i5 b hb) +def required_574_i4 : Finset Cell := ⟨(([(2, 2), (3, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_574_i4 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 0), (3, 1), (3, 2), (3, 3), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_574_i4 : Fin 3 → Finset Cell := ![(placed21 0 (3, 2) required_18), (placed21 6 (4, 6) required_61), required_574_i5] +def childrenD_574_i4 : Fin 3 → Finset Cell := ![(placed21 0 (3, 2) envelope_18), (placed21 6 (4, 6) envelope_61), envelope_574_i5] +theorem common_sub_574_i4 : commonEnvelope childrenD_574_i4 ⊆ insert (4, 4) required_574_i4 := by decide +kernel +theorem child_required_sub_574_i4 : ∀ j, childrenC_574_i4 j ⊆ insert (4, 4) required_574_i4 := by decide +kernel +theorem child_envelope_sub_574_i4 : ∀ j, childrenD_574_i4 j ⊆ envelope_574_i4 := by decide +kernel +theorem pivot_mem_574_i4 : (4, 4) ∈ envelope_574_i4 := by decide +kernel +theorem children_work_574_i4 : ∀ j, Template HasSnaky 4 (childrenC_574_i4 j) (childrenD_574_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_61 6 (4, 6)).mono (by decide +kernel) + · exact row_works_574_i5.mono (by decide +kernel) +theorem row_works_574_i4 : Template HasSnaky 5 required_574_i4 envelope_574_i4 := by + refine compose HasSnaky 4 childrenC_574_i4 childrenD_574_i4 children_work_574_i4 (4, 4) + required_574_i4 envelope_574_i4 pivot_mem_574_i4 child_required_sub_574_i4 child_envelope_sub_574_i4 ?_ + intro b hb + exact common_sub_574_i4 (mem_commonEnvelope childrenD_574_i4 b hb) +def required_574_i0 : Finset Cell := ⟨(([(1, 2), (2, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_574_i0 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_574_i0 : Fin 4 → Finset Cell := ![(placed21 1 (1, 2) required_130), required_574_i1, required_574_i2, required_574_i4] +def childrenD_574_i0 : Fin 4 → Finset Cell := ![(placed21 1 (1, 2) envelope_130), envelope_574_i1, envelope_574_i2, envelope_574_i4] +theorem common_sub_574_i0 : commonEnvelope childrenD_574_i0 ⊆ insert (3, 2) required_574_i0 := by decide +kernel +theorem child_required_sub_574_i0 : ∀ j, childrenC_574_i0 j ⊆ insert (3, 2) required_574_i0 := by decide +kernel +theorem child_envelope_sub_574_i0 : ∀ j, childrenD_574_i0 j ⊆ envelope_574_i0 := by decide +kernel +theorem pivot_mem_574_i0 : (3, 2) ∈ envelope_574_i0 := by decide +kernel +theorem children_work_574_i0 : ∀ j, Template HasSnaky 5 (childrenC_574_i0 j) (childrenD_574_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_130 1 (1, 2)).mono (by decide +kernel) + · exact row_works_574_i1.mono (by decide +kernel) + · exact row_works_574_i2.mono (by decide +kernel) + · exact row_works_574_i4.mono (by decide +kernel) +theorem row_works_574_i0 : Template HasSnaky 6 required_574_i0 envelope_574_i0 := by + refine compose HasSnaky 5 childrenC_574_i0 childrenD_574_i0 children_work_574_i0 (3, 2) + required_574_i0 envelope_574_i0 pivot_mem_574_i0 child_required_sub_574_i0 child_envelope_sub_574_i0 ?_ + intro b hb + exact common_sub_574_i0 (mem_commonEnvelope childrenD_574_i0 b hb) +def required_574 : Finset Cell := ⟨(([(1, 2), (1, 5), (2, 2), (2, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_574 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_574 : Fin 6 → Finset Cell := ![(placed21 2 (5, 2) required_184), (placed21 1 (0, 2) required_384), (placed21 1 (0, 2) required_385), (placed21 1 (0, 2) required_493), (placed21 1 (0, 2) required_494), required_574_i0] +def childrenD_574 : Fin 6 → Finset Cell := ![(placed21 2 (5, 2) envelope_184), (placed21 1 (0, 2) envelope_384), (placed21 1 (0, 2) envelope_385), (placed21 1 (0, 2) envelope_493), (placed21 1 (0, 2) envelope_494), envelope_574_i0] +theorem common_sub_574 : commonEnvelope childrenD_574 ⊆ insert (4, 5) required_574 := by decide +kernel +theorem child_required_sub_574 : ∀ j, childrenC_574 j ⊆ insert (4, 5) required_574 := by decide +kernel +theorem child_envelope_sub_574 : ∀ j, childrenD_574 j ⊆ envelope_574 := by decide +kernel +theorem pivot_mem_574 : (4, 5) ∈ envelope_574 := by decide +kernel +theorem children_work_574 : ∀ j, Template HasSnaky 8 (childrenC_574 j) (childrenD_574 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_184 2 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_384 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_385 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_493 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_494 1 (0, 2)).mono (by decide +kernel) + · exact row_works_574_i0.mono (by decide +kernel) +theorem row_works_574 : Template HasSnaky 9 required_574 envelope_574 := by + refine compose HasSnaky 8 childrenC_574 childrenD_574 children_work_574 (4, 5) + required_574 envelope_574 pivot_mem_574 child_required_sub_574 child_envelope_sub_574 ?_ + intro b hb + exact common_sub_574 (mem_commonEnvelope childrenD_574 b hb) +def required_577_i1 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (3, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_577_i1 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_577_i1 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) required_15), (placed21 2 (4, 0) required_393)] +def childrenD_577_i1 : Fin 2 → Finset Cell := ![(placed21 0 (3, 0) envelope_15), (placed21 2 (4, 0) envelope_393)] +theorem common_sub_577_i1 : commonEnvelope childrenD_577_i1 ⊆ insert (3, 1) required_577_i1 := by decide +kernel +theorem child_required_sub_577_i1 : ∀ j, childrenC_577_i1 j ⊆ insert (3, 1) required_577_i1 := by decide +kernel +theorem child_envelope_sub_577_i1 : ∀ j, childrenD_577_i1 j ⊆ envelope_577_i1 := by decide +kernel +theorem pivot_mem_577_i1 : (3, 1) ∈ envelope_577_i1 := by decide +kernel +theorem children_work_577_i1 : ∀ j, Template HasSnaky 6 (childrenC_577_i1 j) (childrenD_577_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_393 2 (4, 0)).mono (by decide +kernel) +theorem row_works_577_i1 : Template HasSnaky 7 required_577_i1 envelope_577_i1 := by + refine compose HasSnaky 6 childrenC_577_i1 childrenD_577_i1 children_work_577_i1 (3, 1) + required_577_i1 envelope_577_i1 pivot_mem_577_i1 child_required_sub_577_i1 child_envelope_sub_577_i1 ?_ + intro b hb + exact common_sub_577_i1 (mem_commonEnvelope childrenD_577_i1 b hb) +def required_577_i0 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_577_i0 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_577_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_0), required_577_i1] +def childrenD_577_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_0), envelope_577_i1] +theorem common_sub_577_i0 : commonEnvelope childrenD_577_i0 ⊆ insert (3, 3) required_577_i0 := by decide +kernel +theorem child_required_sub_577_i0 : ∀ j, childrenC_577_i0 j ⊆ insert (3, 3) required_577_i0 := by decide +kernel +theorem child_envelope_sub_577_i0 : ∀ j, childrenD_577_i0 j ⊆ envelope_577_i0 := by decide +kernel +theorem pivot_mem_577_i0 : (3, 3) ∈ envelope_577_i0 := by decide +kernel +theorem children_work_577_i0 : ∀ j, Template HasSnaky 7 (childrenC_577_i0 j) (childrenD_577_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 0 (0, 2)).mono (by decide +kernel) + · exact row_works_577_i1.mono (by decide +kernel) +theorem row_works_577_i0 : Template HasSnaky 8 required_577_i0 envelope_577_i0 := by + refine compose HasSnaky 7 childrenC_577_i0 childrenD_577_i0 children_work_577_i0 (3, 3) + required_577_i0 envelope_577_i0 pivot_mem_577_i0 child_required_sub_577_i0 child_envelope_sub_577_i0 ?_ + intro b hb + exact common_sub_577_i0 (mem_commonEnvelope childrenD_577_i0 b hb) +def required_577 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_577 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_577 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) required_5), required_577_i0] +def childrenD_577 : Fin 2 → Finset Cell := ![(placed21 0 (1, 2) envelope_5), envelope_577_i0] +theorem common_sub_577 : commonEnvelope childrenD_577 ⊆ insert (4, 3) required_577 := by decide +kernel +theorem child_required_sub_577 : ∀ j, childrenC_577 j ⊆ insert (4, 3) required_577 := by decide +kernel +theorem child_envelope_sub_577 : ∀ j, childrenD_577 j ⊆ envelope_577 := by decide +kernel +theorem pivot_mem_577 : (4, 3) ∈ envelope_577 := by decide +kernel +theorem children_work_577 : ∀ j, Template HasSnaky 8 (childrenC_577 j) (childrenD_577 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 2)).mono (by decide +kernel) + · exact row_works_577_i0.mono (by decide +kernel) +theorem row_works_577 : Template HasSnaky 9 required_577 envelope_577 := by + refine compose HasSnaky 8 childrenC_577 childrenD_577 children_work_577 (4, 3) + required_577 envelope_577 pivot_mem_577 child_required_sub_577 child_envelope_sub_577 ?_ + intro b hb + exact common_sub_577 (mem_commonEnvelope childrenD_577 b hb) +def required_584_i1 : Finset Cell := ⟨(([(0, 2), (1, 1), (2, 1), (3, 1), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_584_i1 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (5, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_584_i1 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_4), (placed21 0 (1, 0) required_121)] +def childrenD_584_i1 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_4), (placed21 0 (1, 0) envelope_121)] +theorem common_sub_584_i1 : commonEnvelope childrenD_584_i1 ⊆ insert (4, 1) required_584_i1 := by decide +kernel +theorem child_required_sub_584_i1 : ∀ j, childrenC_584_i1 j ⊆ insert (4, 1) required_584_i1 := by decide +kernel +theorem child_envelope_sub_584_i1 : ∀ j, childrenD_584_i1 j ⊆ envelope_584_i1 := by decide +kernel +theorem pivot_mem_584_i1 : (4, 1) ∈ envelope_584_i1 := by decide +kernel +theorem children_work_584_i1 : ∀ j, Template HasSnaky 2 (childrenC_584_i1 j) (childrenD_584_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_121 0 (1, 0)).mono (by decide +kernel) +theorem row_works_584_i1 : Template HasSnaky 3 required_584_i1 envelope_584_i1 := by + refine compose HasSnaky 2 childrenC_584_i1 childrenD_584_i1 children_work_584_i1 (4, 1) + required_584_i1 envelope_584_i1 pivot_mem_584_i1 child_required_sub_584_i1 child_envelope_sub_584_i1 ?_ + intro b hb + exact common_sub_584_i1 (mem_commonEnvelope childrenD_584_i1 b hb) +def required_584_i2 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 4), (2, 1), (3, 1), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_584_i2 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (3, 1), (3, 4), (4, 1), (4, 3), (4, 4), (5, 3), (5, 4), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_584_i2 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) required_0), required_203] +def childrenD_584_i2 : Fin 2 → Finset Cell := ![(placed21 2 (4, 1) envelope_0), envelope_203] +theorem common_sub_584_i2 : commonEnvelope childrenD_584_i2 ⊆ insert (1, 2) required_584_i2 := by decide +kernel +theorem child_required_sub_584_i2 : ∀ j, childrenC_584_i2 j ⊆ insert (1, 2) required_584_i2 := by decide +kernel +theorem child_envelope_sub_584_i2 : ∀ j, childrenD_584_i2 j ⊆ envelope_584_i2 := by decide +kernel +theorem pivot_mem_584_i2 : (1, 2) ∈ envelope_584_i2 := by decide +kernel +theorem children_work_584_i2 : ∀ j, Template HasSnaky 6 (childrenC_584_i2 j) (childrenD_584_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 1)).mono (by decide +kernel) + · exact row_works_203.mono (by decide +kernel) +theorem row_works_584_i2 : Template HasSnaky 7 required_584_i2 envelope_584_i2 := by + refine compose HasSnaky 6 childrenC_584_i2 childrenD_584_i2 children_work_584_i2 (1, 2) + required_584_i2 envelope_584_i2 pivot_mem_584_i2 child_required_sub_584_i2 child_envelope_sub_584_i2 ?_ + intro b hb + exact common_sub_584_i2 (mem_commonEnvelope childrenD_584_i2 b hb) +def required_584_i0 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 4), (2, 1), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_584_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 3), (5, 4), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_584_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 0) required_39), required_584_i1, required_584_i2] +def childrenD_584_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 0) envelope_39), envelope_584_i1, envelope_584_i2] +theorem common_sub_584_i0 : commonEnvelope childrenD_584_i0 ⊆ insert (3, 4) required_584_i0 := by decide +kernel +theorem child_required_sub_584_i0 : ∀ j, childrenC_584_i0 j ⊆ insert (3, 4) required_584_i0 := by decide +kernel +theorem child_envelope_sub_584_i0 : ∀ j, childrenD_584_i0 j ⊆ envelope_584_i0 := by decide +kernel +theorem pivot_mem_584_i0 : (3, 4) ∈ envelope_584_i0 := by decide +kernel +theorem children_work_584_i0 : ∀ j, Template HasSnaky 7 (childrenC_584_i0 j) (childrenD_584_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_39 0 (2, 0)).mono (by decide +kernel) + · exact row_works_584_i1.mono (by decide +kernel) + · exact row_works_584_i2.mono (by decide +kernel) +theorem row_works_584_i0 : Template HasSnaky 8 required_584_i0 envelope_584_i0 := by + refine compose HasSnaky 7 childrenC_584_i0 childrenD_584_i0 children_work_584_i0 (3, 4) + required_584_i0 envelope_584_i0 pivot_mem_584_i0 child_required_sub_584_i0 child_envelope_sub_584_i0 ?_ + intro b hb + exact common_sub_584_i0 (mem_commonEnvelope childrenD_584_i0 b hb) +def required_584 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 1), (1, 4), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_584 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 3), (5, 4), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_584 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), required_584_i0] +def childrenD_584 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), envelope_584_i0] +theorem common_sub_584 : commonEnvelope childrenD_584 ⊆ insert (2, 1) required_584 := by decide +kernel +theorem child_required_sub_584 : ∀ j, childrenC_584 j ⊆ insert (2, 1) required_584 := by decide +kernel +theorem child_envelope_sub_584 : ∀ j, childrenD_584 j ⊆ envelope_584 := by decide +kernel +theorem pivot_mem_584 : (2, 1) ∈ envelope_584 := by decide +kernel +theorem children_work_584 : ∀ j, Template HasSnaky 8 (childrenC_584 j) (childrenD_584 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact row_works_584_i0.mono (by decide +kernel) +theorem row_works_584 : Template HasSnaky 9 required_584 envelope_584 := by + refine compose HasSnaky 8 childrenC_584 childrenD_584 children_work_584 (2, 1) + required_584 envelope_584 pivot_mem_584 child_required_sub_584 child_envelope_sub_584 ?_ + intro b hb + exact common_sub_584 (mem_commonEnvelope childrenD_584 b hb) +def height_574_i1 : ℕ := 4 +def childrenH_574_i1 : Fin 2 → ℕ := ![height_43, height_64] +theorem height_exact_574_i1 : height_574_i1 = 1 + Finset.univ.sup childrenH_574_i1 := by decide +kernel +theorem required_origin_574_i1 : ∀ x ∈ required_574_i1, + (∃ j, x ∈ childrenC_574_i1 j) ∨ ∀ j, x ∈ childrenD_574_i1 j := by decide +kernel +theorem required_exact_574_i1 : required_574_i1 = + ((Finset.univ.biUnion childrenC_574_i1) ∪ commonEnvelope childrenD_574_i1).erase (3, 3) := by + exact required_eq_combination childrenC_574_i1 childrenD_574_i1 (3, 3) required_574_i1 + (by decide +kernel) child_required_sub_574_i1 common_sub_574_i1 required_origin_574_i1 +theorem envelope_origin_574_i1 : ∀ x ∈ envelope_574_i1, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_574_i1 j := by decide +kernel +theorem envelope_exact_574_i1 : envelope_574_i1 = + insert (3, 3) (Finset.univ.biUnion childrenD_574_i1) := by + exact envelope_eq_combination childrenD_574_i1 (3, 3) envelope_574_i1 + pivot_mem_574_i1 child_envelope_sub_574_i1 envelope_origin_574_i1 +def checked_574_i1 : CheckedCard where + required := required_574_i1 + envelope := envelope_574_i1 + height := height_574_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_574_i1 +def height_574_i3 : ℕ := 4 +def childrenH_574_i3 : Fin 2 → ℕ := ![height_5, height_223] +theorem height_exact_574_i3 : height_574_i3 = 1 + Finset.univ.sup childrenH_574_i3 := by decide +kernel +theorem required_origin_574_i3 : ∀ x ∈ required_574_i3, + (∃ j, x ∈ childrenC_574_i3 j) ∨ ∀ j, x ∈ childrenD_574_i3 j := by decide +kernel +theorem required_exact_574_i3 : required_574_i3 = + ((Finset.univ.biUnion childrenC_574_i3) ∪ commonEnvelope childrenD_574_i3).erase (4, 4) := by + exact required_eq_combination childrenC_574_i3 childrenD_574_i3 (4, 4) required_574_i3 + (by decide +kernel) child_required_sub_574_i3 common_sub_574_i3 required_origin_574_i3 +theorem envelope_origin_574_i3 : ∀ x ∈ envelope_574_i3, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_574_i3 j := by decide +kernel +theorem envelope_exact_574_i3 : envelope_574_i3 = + insert (4, 4) (Finset.univ.biUnion childrenD_574_i3) := by + exact envelope_eq_combination childrenD_574_i3 (4, 4) envelope_574_i3 + pivot_mem_574_i3 child_envelope_sub_574_i3 envelope_origin_574_i3 +def checked_574_i3 : CheckedCard where + required := required_574_i3 + envelope := envelope_574_i3 + height := height_574_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_574_i3 +def height_574_i2 : ℕ := 5 +def childrenH_574_i2 : Fin 2 → ℕ := ![height_5, height_574_i3] +theorem height_exact_574_i2 : height_574_i2 = 1 + Finset.univ.sup childrenH_574_i2 := by decide +kernel +theorem required_origin_574_i2 : ∀ x ∈ required_574_i2, + (∃ j, x ∈ childrenC_574_i2 j) ∨ ∀ j, x ∈ childrenD_574_i2 j := by decide +kernel +theorem required_exact_574_i2 : required_574_i2 = + ((Finset.univ.biUnion childrenC_574_i2) ∪ commonEnvelope childrenD_574_i2).erase (4, 2) := by + exact required_eq_combination childrenC_574_i2 childrenD_574_i2 (4, 2) required_574_i2 + (by decide +kernel) child_required_sub_574_i2 common_sub_574_i2 required_origin_574_i2 +theorem envelope_origin_574_i2 : ∀ x ∈ envelope_574_i2, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_574_i2 j := by decide +kernel +theorem envelope_exact_574_i2 : envelope_574_i2 = + insert (4, 2) (Finset.univ.biUnion childrenD_574_i2) := by + exact envelope_eq_combination childrenD_574_i2 (4, 2) envelope_574_i2 + pivot_mem_574_i2 child_envelope_sub_574_i2 envelope_origin_574_i2 +def checked_574_i2 : CheckedCard where + required := required_574_i2 + envelope := envelope_574_i2 + height := height_574_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_574_i2 +def height_574_i5 : ℕ := 4 +def childrenH_574_i5 : Fin 2 → ℕ := ![height_5, height_236] +theorem height_exact_574_i5 : height_574_i5 = 1 + Finset.univ.sup childrenH_574_i5 := by decide +kernel +theorem required_origin_574_i5 : ∀ x ∈ required_574_i5, + (∃ j, x ∈ childrenC_574_i5 j) ∨ ∀ j, x ∈ childrenD_574_i5 j := by decide +kernel +theorem required_exact_574_i5 : required_574_i5 = + ((Finset.univ.biUnion childrenC_574_i5) ∪ commonEnvelope childrenD_574_i5).erase (4, 2) := by + exact required_eq_combination childrenC_574_i5 childrenD_574_i5 (4, 2) required_574_i5 + (by decide +kernel) child_required_sub_574_i5 common_sub_574_i5 required_origin_574_i5 +theorem envelope_origin_574_i5 : ∀ x ∈ envelope_574_i5, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_574_i5 j := by decide +kernel +theorem envelope_exact_574_i5 : envelope_574_i5 = + insert (4, 2) (Finset.univ.biUnion childrenD_574_i5) := by + exact envelope_eq_combination childrenD_574_i5 (4, 2) envelope_574_i5 + pivot_mem_574_i5 child_envelope_sub_574_i5 envelope_origin_574_i5 +def checked_574_i5 : CheckedCard where + required := required_574_i5 + envelope := envelope_574_i5 + height := height_574_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_574_i5 +def height_574_i4 : ℕ := 5 +def childrenH_574_i4 : Fin 3 → ℕ := ![height_18, height_61, height_574_i5] +theorem height_exact_574_i4 : height_574_i4 = 1 + Finset.univ.sup childrenH_574_i4 := by decide +kernel +theorem required_origin_574_i4 : ∀ x ∈ required_574_i4, + (∃ j, x ∈ childrenC_574_i4 j) ∨ ∀ j, x ∈ childrenD_574_i4 j := by decide +kernel +theorem required_exact_574_i4 : required_574_i4 = + ((Finset.univ.biUnion childrenC_574_i4) ∪ commonEnvelope childrenD_574_i4).erase (4, 4) := by + exact required_eq_combination childrenC_574_i4 childrenD_574_i4 (4, 4) required_574_i4 + (by decide +kernel) child_required_sub_574_i4 common_sub_574_i4 required_origin_574_i4 +theorem envelope_origin_574_i4 : ∀ x ∈ envelope_574_i4, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_574_i4 j := by decide +kernel +theorem envelope_exact_574_i4 : envelope_574_i4 = + insert (4, 4) (Finset.univ.biUnion childrenD_574_i4) := by + exact envelope_eq_combination childrenD_574_i4 (4, 4) envelope_574_i4 + pivot_mem_574_i4 child_envelope_sub_574_i4 envelope_origin_574_i4 +def checked_574_i4 : CheckedCard where + required := required_574_i4 + envelope := envelope_574_i4 + height := height_574_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_574_i4 +def height_574_i0 : ℕ := 6 +def childrenH_574_i0 : Fin 4 → ℕ := ![height_130, height_574_i1, height_574_i2, height_574_i4] +theorem height_exact_574_i0 : height_574_i0 = 1 + Finset.univ.sup childrenH_574_i0 := by decide +kernel +theorem required_origin_574_i0 : ∀ x ∈ required_574_i0, + (∃ j, x ∈ childrenC_574_i0 j) ∨ ∀ j, x ∈ childrenD_574_i0 j := by decide +kernel +theorem required_exact_574_i0 : required_574_i0 = + ((Finset.univ.biUnion childrenC_574_i0) ∪ commonEnvelope childrenD_574_i0).erase (3, 2) := by + exact required_eq_combination childrenC_574_i0 childrenD_574_i0 (3, 2) required_574_i0 + (by decide +kernel) child_required_sub_574_i0 common_sub_574_i0 required_origin_574_i0 +theorem envelope_origin_574_i0 : ∀ x ∈ envelope_574_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_574_i0 j := by decide +kernel +theorem envelope_exact_574_i0 : envelope_574_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_574_i0) := by + exact envelope_eq_combination childrenD_574_i0 (3, 2) envelope_574_i0 + pivot_mem_574_i0 child_envelope_sub_574_i0 envelope_origin_574_i0 +def checked_574_i0 : CheckedCard where + required := required_574_i0 + envelope := envelope_574_i0 + height := height_574_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_574_i0 +def height_574 : ℕ := 9 +def childrenH_574 : Fin 6 → ℕ := ![height_184, height_384, height_385, height_493, height_494, height_574_i0] +theorem height_exact_574 : height_574 = 1 + Finset.univ.sup childrenH_574 := by decide +kernel +theorem required_origin_574 : ∀ x ∈ required_574, + (∃ j, x ∈ childrenC_574 j) ∨ ∀ j, x ∈ childrenD_574 j := by decide +kernel +theorem required_exact_574 : required_574 = + ((Finset.univ.biUnion childrenC_574) ∪ commonEnvelope childrenD_574).erase (4, 5) := by + exact required_eq_combination childrenC_574 childrenD_574 (4, 5) required_574 + (by decide +kernel) child_required_sub_574 common_sub_574 required_origin_574 +theorem envelope_origin_574 : ∀ x ∈ envelope_574, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_574 j := by decide +kernel +theorem envelope_exact_574 : envelope_574 = + insert (4, 5) (Finset.univ.biUnion childrenD_574) := by + exact envelope_eq_combination childrenD_574 (4, 5) envelope_574 + pivot_mem_574 child_envelope_sub_574 envelope_origin_574 +def checked_574 : CheckedCard where + required := required_574 + envelope := envelope_574 + height := height_574 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_574 +def height_577_i1 : ℕ := 7 +def childrenH_577_i1 : Fin 2 → ℕ := ![height_15, height_393] +theorem height_exact_577_i1 : height_577_i1 = 1 + Finset.univ.sup childrenH_577_i1 := by decide +kernel +theorem required_origin_577_i1 : ∀ x ∈ required_577_i1, + (∃ j, x ∈ childrenC_577_i1 j) ∨ ∀ j, x ∈ childrenD_577_i1 j := by decide +kernel +theorem required_exact_577_i1 : required_577_i1 = + ((Finset.univ.biUnion childrenC_577_i1) ∪ commonEnvelope childrenD_577_i1).erase (3, 1) := by + exact required_eq_combination childrenC_577_i1 childrenD_577_i1 (3, 1) required_577_i1 + (by decide +kernel) child_required_sub_577_i1 common_sub_577_i1 required_origin_577_i1 +theorem envelope_origin_577_i1 : ∀ x ∈ envelope_577_i1, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_577_i1 j := by decide +kernel +theorem envelope_exact_577_i1 : envelope_577_i1 = + insert (3, 1) (Finset.univ.biUnion childrenD_577_i1) := by + exact envelope_eq_combination childrenD_577_i1 (3, 1) envelope_577_i1 + pivot_mem_577_i1 child_envelope_sub_577_i1 envelope_origin_577_i1 +def checked_577_i1 : CheckedCard where + required := required_577_i1 + envelope := envelope_577_i1 + height := height_577_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_577_i1 +def height_577_i0 : ℕ := 8 +def childrenH_577_i0 : Fin 2 → ℕ := ![height_0, height_577_i1] +theorem height_exact_577_i0 : height_577_i0 = 1 + Finset.univ.sup childrenH_577_i0 := by decide +kernel +theorem required_origin_577_i0 : ∀ x ∈ required_577_i0, + (∃ j, x ∈ childrenC_577_i0 j) ∨ ∀ j, x ∈ childrenD_577_i0 j := by decide +kernel +theorem required_exact_577_i0 : required_577_i0 = + ((Finset.univ.biUnion childrenC_577_i0) ∪ commonEnvelope childrenD_577_i0).erase (3, 3) := by + exact required_eq_combination childrenC_577_i0 childrenD_577_i0 (3, 3) required_577_i0 + (by decide +kernel) child_required_sub_577_i0 common_sub_577_i0 required_origin_577_i0 +theorem envelope_origin_577_i0 : ∀ x ∈ envelope_577_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_577_i0 j := by decide +kernel +theorem envelope_exact_577_i0 : envelope_577_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_577_i0) := by + exact envelope_eq_combination childrenD_577_i0 (3, 3) envelope_577_i0 + pivot_mem_577_i0 child_envelope_sub_577_i0 envelope_origin_577_i0 +def checked_577_i0 : CheckedCard where + required := required_577_i0 + envelope := envelope_577_i0 + height := height_577_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_577_i0 +def height_577 : ℕ := 9 +def childrenH_577 : Fin 2 → ℕ := ![height_5, height_577_i0] +theorem height_exact_577 : height_577 = 1 + Finset.univ.sup childrenH_577 := by decide +kernel +theorem required_origin_577 : ∀ x ∈ required_577, + (∃ j, x ∈ childrenC_577 j) ∨ ∀ j, x ∈ childrenD_577 j := by decide +kernel +theorem required_exact_577 : required_577 = + ((Finset.univ.biUnion childrenC_577) ∪ commonEnvelope childrenD_577).erase (4, 3) := by + exact required_eq_combination childrenC_577 childrenD_577 (4, 3) required_577 + (by decide +kernel) child_required_sub_577 common_sub_577 required_origin_577 +theorem envelope_origin_577 : ∀ x ∈ envelope_577, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_577 j := by decide +kernel +theorem envelope_exact_577 : envelope_577 = + insert (4, 3) (Finset.univ.biUnion childrenD_577) := by + exact envelope_eq_combination childrenD_577 (4, 3) envelope_577 + pivot_mem_577 child_envelope_sub_577 envelope_origin_577 +def checked_577 : CheckedCard where + required := required_577 + envelope := envelope_577 + height := height_577 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_577 +def height_584_i1 : ℕ := 3 +def childrenH_584_i1 : Fin 2 → ℕ := ![height_4, height_121] +theorem height_exact_584_i1 : height_584_i1 = 1 + Finset.univ.sup childrenH_584_i1 := by decide +kernel +theorem required_origin_584_i1 : ∀ x ∈ required_584_i1, + (∃ j, x ∈ childrenC_584_i1 j) ∨ ∀ j, x ∈ childrenD_584_i1 j := by decide +kernel +theorem required_exact_584_i1 : required_584_i1 = + ((Finset.univ.biUnion childrenC_584_i1) ∪ commonEnvelope childrenD_584_i1).erase (4, 1) := by + exact required_eq_combination childrenC_584_i1 childrenD_584_i1 (4, 1) required_584_i1 + (by decide +kernel) child_required_sub_584_i1 common_sub_584_i1 required_origin_584_i1 +theorem envelope_origin_584_i1 : ∀ x ∈ envelope_584_i1, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_584_i1 j := by decide +kernel +theorem envelope_exact_584_i1 : envelope_584_i1 = + insert (4, 1) (Finset.univ.biUnion childrenD_584_i1) := by + exact envelope_eq_combination childrenD_584_i1 (4, 1) envelope_584_i1 + pivot_mem_584_i1 child_envelope_sub_584_i1 envelope_origin_584_i1 +def checked_584_i1 : CheckedCard where + required := required_584_i1 + envelope := envelope_584_i1 + height := height_584_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_584_i1 +def height_584_i2 : ℕ := 7 +def childrenH_584_i2 : Fin 2 → ℕ := ![height_0, height_203] +theorem height_exact_584_i2 : height_584_i2 = 1 + Finset.univ.sup childrenH_584_i2 := by decide +kernel +theorem required_origin_584_i2 : ∀ x ∈ required_584_i2, + (∃ j, x ∈ childrenC_584_i2 j) ∨ ∀ j, x ∈ childrenD_584_i2 j := by decide +kernel +theorem required_exact_584_i2 : required_584_i2 = + ((Finset.univ.biUnion childrenC_584_i2) ∪ commonEnvelope childrenD_584_i2).erase (1, 2) := by + exact required_eq_combination childrenC_584_i2 childrenD_584_i2 (1, 2) required_584_i2 + (by decide +kernel) child_required_sub_584_i2 common_sub_584_i2 required_origin_584_i2 +theorem envelope_origin_584_i2 : ∀ x ∈ envelope_584_i2, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_584_i2 j := by decide +kernel +theorem envelope_exact_584_i2 : envelope_584_i2 = + insert (1, 2) (Finset.univ.biUnion childrenD_584_i2) := by + exact envelope_eq_combination childrenD_584_i2 (1, 2) envelope_584_i2 + pivot_mem_584_i2 child_envelope_sub_584_i2 envelope_origin_584_i2 +def checked_584_i2 : CheckedCard where + required := required_584_i2 + envelope := envelope_584_i2 + height := height_584_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_584_i2 +def height_584_i0 : ℕ := 8 +def childrenH_584_i0 : Fin 3 → ℕ := ![height_39, height_584_i1, height_584_i2] +theorem height_exact_584_i0 : height_584_i0 = 1 + Finset.univ.sup childrenH_584_i0 := by decide +kernel +theorem required_origin_584_i0 : ∀ x ∈ required_584_i0, + (∃ j, x ∈ childrenC_584_i0 j) ∨ ∀ j, x ∈ childrenD_584_i0 j := by decide +kernel +theorem required_exact_584_i0 : required_584_i0 = + ((Finset.univ.biUnion childrenC_584_i0) ∪ commonEnvelope childrenD_584_i0).erase (3, 4) := by + exact required_eq_combination childrenC_584_i0 childrenD_584_i0 (3, 4) required_584_i0 + (by decide +kernel) child_required_sub_584_i0 common_sub_584_i0 required_origin_584_i0 +theorem envelope_origin_584_i0 : ∀ x ∈ envelope_584_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_584_i0 j := by decide +kernel +theorem envelope_exact_584_i0 : envelope_584_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_584_i0) := by + exact envelope_eq_combination childrenD_584_i0 (3, 4) envelope_584_i0 + pivot_mem_584_i0 child_envelope_sub_584_i0 envelope_origin_584_i0 +def checked_584_i0 : CheckedCard where + required := required_584_i0 + envelope := envelope_584_i0 + height := height_584_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_584_i0 +def height_584 : ℕ := 9 +def childrenH_584 : Fin 2 → ℕ := ![height_5, height_584_i0] +theorem height_exact_584 : height_584 = 1 + Finset.univ.sup childrenH_584 := by decide +kernel +theorem required_origin_584 : ∀ x ∈ required_584, + (∃ j, x ∈ childrenC_584 j) ∨ ∀ j, x ∈ childrenD_584 j := by decide +kernel +theorem required_exact_584 : required_584 = + ((Finset.univ.biUnion childrenC_584) ∪ commonEnvelope childrenD_584).erase (2, 1) := by + exact required_eq_combination childrenC_584 childrenD_584 (2, 1) required_584 + (by decide +kernel) child_required_sub_584 common_sub_584 required_origin_584 +theorem envelope_origin_584 : ∀ x ∈ envelope_584, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_584 j := by decide +kernel +theorem envelope_exact_584 : envelope_584 = + insert (2, 1) (Finset.univ.biUnion childrenD_584) := by + exact envelope_eq_combination childrenD_584 (2, 1) envelope_584 + pivot_mem_584 child_envelope_sub_584 envelope_origin_584 +def checked_584 : CheckedCard where + required := required_584 + envelope := envelope_584 + height := height_584 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_584 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part06.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part06.lean new file mode 100644 index 0000000..2abf0ce --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part06.lean @@ -0,0 +1,808 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_595_i6 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (5, 0), (5, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i6 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (4, 0), (4, 1), (5, 0), (5, 1), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i6 : Fin 2 → Finset Cell := ![(placed21 4 (1, 1) required_4), (placed21 4 (2, 1) required_5)] +def childrenD_595_i6 : Fin 2 → Finset Cell := ![(placed21 4 (1, 1) envelope_4), (placed21 4 (2, 1) envelope_5)] +theorem common_sub_595_i6 : commonEnvelope childrenD_595_i6 ⊆ insert (4, 1) required_595_i6 := by decide +kernel +theorem child_required_sub_595_i6 : ∀ j, childrenC_595_i6 j ⊆ insert (4, 1) required_595_i6 := by decide +kernel +theorem child_envelope_sub_595_i6 : ∀ j, childrenD_595_i6 j ⊆ envelope_595_i6 := by decide +kernel +theorem pivot_mem_595_i6 : (4, 1) ∈ envelope_595_i6 := by decide +kernel +theorem children_work_595_i6 : ∀ j, Template HasSnaky 1 (childrenC_595_i6 j) (childrenD_595_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_5 4 (2, 1)).mono (by decide +kernel) +theorem row_works_595_i6 : Template HasSnaky 2 required_595_i6 envelope_595_i6 := by + refine compose HasSnaky 1 childrenC_595_i6 childrenD_595_i6 children_work_595_i6 (4, 1) + required_595_i6 envelope_595_i6 pivot_mem_595_i6 child_required_sub_595_i6 child_envelope_sub_595_i6 ?_ + intro b hb + exact common_sub_595_i6 (mem_commonEnvelope childrenD_595_i6 b hb) +def required_595_i5 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (5, 1), (6, 2), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i5 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (4, 0), (4, 1), (5, 0), (5, 1), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i5 : Fin 2 → Finset Cell := ![(placed21 7 (6, 4) required_3), required_595_i6] +def childrenD_595_i5 : Fin 2 → Finset Cell := ![(placed21 7 (6, 4) envelope_3), envelope_595_i6] +theorem common_sub_595_i5 : commonEnvelope childrenD_595_i5 ⊆ insert (5, 0) required_595_i5 := by decide +kernel +theorem child_required_sub_595_i5 : ∀ j, childrenC_595_i5 j ⊆ insert (5, 0) required_595_i5 := by decide +kernel +theorem child_envelope_sub_595_i5 : ∀ j, childrenD_595_i5 j ⊆ envelope_595_i5 := by decide +kernel +theorem pivot_mem_595_i5 : (5, 0) ∈ envelope_595_i5 := by decide +kernel +theorem children_work_595_i5 : ∀ j, Template HasSnaky 2 (childrenC_595_i5 j) (childrenD_595_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 7 (6, 4)).mono (by decide +kernel) + · exact row_works_595_i6.mono (by decide +kernel) +theorem row_works_595_i5 : Template HasSnaky 3 required_595_i5 envelope_595_i5 := by + refine compose HasSnaky 2 childrenC_595_i5 childrenD_595_i5 children_work_595_i5 (5, 0) + required_595_i5 envelope_595_i5 pivot_mem_595_i5 child_required_sub_595_i5 child_envelope_sub_595_i5 ?_ + intro b hb + exact common_sub_595_i5 (mem_commonEnvelope childrenD_595_i5 b hb) +def required_595_i4 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (6, 2), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i4 : Finset Cell := ⟨(([(1, 1), (2, 1), (3, 1), (4, 0), (4, 1), (5, 0), (5, 1), (5, 2), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i4 : Fin 2 → Finset Cell := ![(placed21 7 (6, 5) required_4), required_595_i5] +def childrenD_595_i4 : Fin 2 → Finset Cell := ![(placed21 7 (6, 5) envelope_4), envelope_595_i5] +theorem common_sub_595_i4 : commonEnvelope childrenD_595_i4 ⊆ insert (5, 1) required_595_i4 := by decide +kernel +theorem child_required_sub_595_i4 : ∀ j, childrenC_595_i4 j ⊆ insert (5, 1) required_595_i4 := by decide +kernel +theorem child_envelope_sub_595_i4 : ∀ j, childrenD_595_i4 j ⊆ envelope_595_i4 := by decide +kernel +theorem pivot_mem_595_i4 : (5, 1) ∈ envelope_595_i4 := by decide +kernel +theorem children_work_595_i4 : ∀ j, Template HasSnaky 3 (childrenC_595_i4 j) (childrenD_595_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (6, 5)).mono (by decide +kernel) + · exact row_works_595_i5.mono (by decide +kernel) +theorem row_works_595_i4 : Template HasSnaky 4 required_595_i4 envelope_595_i4 := by + refine compose HasSnaky 3 childrenC_595_i4 childrenD_595_i4 children_work_595_i4 (5, 1) + required_595_i4 envelope_595_i4 pivot_mem_595_i4 child_required_sub_595_i4 child_envelope_sub_595_i4 ?_ + intro b hb + exact common_sub_595_i4 (mem_commonEnvelope childrenD_595_i4 b hb) +def required_595_i3 : Finset Cell := ⟨(([(0, 1), (1, 1), (3, 1), (3, 2), (6, 2), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i3 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i3 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_5), required_595_i4] +def childrenD_595_i3 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_5), envelope_595_i4] +theorem common_sub_595_i3 : commonEnvelope childrenD_595_i3 ⊆ insert (2, 1) required_595_i3 := by decide +kernel +theorem child_required_sub_595_i3 : ∀ j, childrenC_595_i3 j ⊆ insert (2, 1) required_595_i3 := by decide +kernel +theorem child_envelope_sub_595_i3 : ∀ j, childrenD_595_i3 j ⊆ envelope_595_i3 := by decide +kernel +theorem pivot_mem_595_i3 : (2, 1) ∈ envelope_595_i3 := by decide +kernel +theorem children_work_595_i3 : ∀ j, Template HasSnaky 4 (childrenC_595_i3 j) (childrenD_595_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (0, 1)).mono (by decide +kernel) + · exact row_works_595_i4.mono (by decide +kernel) +theorem row_works_595_i3 : Template HasSnaky 5 required_595_i3 envelope_595_i3 := by + refine compose HasSnaky 4 childrenC_595_i3 childrenD_595_i3 children_work_595_i3 (2, 1) + required_595_i3 envelope_595_i3 pivot_mem_595_i3 child_required_sub_595_i3 child_envelope_sub_595_i3 ?_ + intro b hb + exact common_sub_595_i3 (mem_commonEnvelope childrenD_595_i3 b hb) +def required_595_i7 : Finset Cell := ⟨(([(0, 1), (1, 1), (3, 1), (3, 2), (6, 2), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i7 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (5, 0), (5, 1), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i7 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_2), (placed21 7 (7, 5) required_208)] +def childrenD_595_i7 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_2), (placed21 7 (7, 5) envelope_208)] +theorem common_sub_595_i7 : commonEnvelope childrenD_595_i7 ⊆ insert (4, 2) required_595_i7 := by decide +kernel +theorem child_required_sub_595_i7 : ∀ j, childrenC_595_i7 j ⊆ insert (4, 2) required_595_i7 := by decide +kernel +theorem child_envelope_sub_595_i7 : ∀ j, childrenD_595_i7 j ⊆ envelope_595_i7 := by decide +kernel +theorem pivot_mem_595_i7 : (4, 2) ∈ envelope_595_i7 := by decide +kernel +theorem children_work_595_i7 : ∀ j, Template HasSnaky 4 (childrenC_595_i7 j) (childrenD_595_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_208 7 (7, 5)).mono (by decide +kernel) +theorem row_works_595_i7 : Template HasSnaky 5 required_595_i7 envelope_595_i7 := by + refine compose HasSnaky 4 childrenC_595_i7 childrenD_595_i7 children_work_595_i7 (4, 2) + required_595_i7 envelope_595_i7 pivot_mem_595_i7 child_required_sub_595_i7 child_envelope_sub_595_i7 ?_ + intro b hb + exact common_sub_595_i7 (mem_commonEnvelope childrenD_595_i7 b hb) +def required_595_i9 : Finset Cell := ⟨(([(3, 1), (3, 2), (5, 2), (6, 2), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i9 : Finset Cell := ⟨(([(2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (5, 2), (6, 2), (6, 3), (6, 4), (6, 5), (7, 1), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i9 : Fin 2 → Finset Cell := ![(placed21 6 (6, 2) required_5), (placed21 1 (3, 1) required_153)] +def childrenD_595_i9 : Fin 2 → Finset Cell := ![(placed21 6 (6, 2) envelope_5), (placed21 1 (3, 1) envelope_153)] +theorem common_sub_595_i9 : commonEnvelope childrenD_595_i9 ⊆ insert (4, 2) required_595_i9 := by decide +kernel +theorem child_required_sub_595_i9 : ∀ j, childrenC_595_i9 j ⊆ insert (4, 2) required_595_i9 := by decide +kernel +theorem child_envelope_sub_595_i9 : ∀ j, childrenD_595_i9 j ⊆ envelope_595_i9 := by decide +kernel +theorem pivot_mem_595_i9 : (4, 2) ∈ envelope_595_i9 := by decide +kernel +theorem children_work_595_i9 : ∀ j, Template HasSnaky 2 (childrenC_595_i9 j) (childrenD_595_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_153 1 (3, 1)).mono (by decide +kernel) +theorem row_works_595_i9 : Template HasSnaky 3 required_595_i9 envelope_595_i9 := by + refine compose HasSnaky 2 childrenC_595_i9 childrenD_595_i9 children_work_595_i9 (4, 2) + required_595_i9 envelope_595_i9 pivot_mem_595_i9 child_required_sub_595_i9 child_envelope_sub_595_i9 ?_ + intro b hb + exact common_sub_595_i9 (mem_commonEnvelope childrenD_595_i9 b hb) +def required_595_i8 : Finset Cell := ⟨(([(3, 1), (3, 2), (6, 2), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i8 : Finset Cell := ⟨(([(2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (5, 1), (5, 2), (6, 2), (6, 3), (6, 4), (6, 5), (7, 1), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i8 : Fin 2 → Finset Cell := ![(placed21 7 (6, 5) required_5), required_595_i9] +def childrenD_595_i8 : Fin 2 → Finset Cell := ![(placed21 7 (6, 5) envelope_5), envelope_595_i9] +theorem common_sub_595_i8 : commonEnvelope childrenD_595_i8 ⊆ insert (5, 2) required_595_i8 := by decide +kernel +theorem child_required_sub_595_i8 : ∀ j, childrenC_595_i8 j ⊆ insert (5, 2) required_595_i8 := by decide +kernel +theorem child_envelope_sub_595_i8 : ∀ j, childrenD_595_i8 j ⊆ envelope_595_i8 := by decide +kernel +theorem pivot_mem_595_i8 : (5, 2) ∈ envelope_595_i8 := by decide +kernel +theorem children_work_595_i8 : ∀ j, Template HasSnaky 3 (childrenC_595_i8 j) (childrenD_595_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (6, 5)).mono (by decide +kernel) + · exact row_works_595_i9.mono (by decide +kernel) +theorem row_works_595_i8 : Template HasSnaky 4 required_595_i8 envelope_595_i8 := by + refine compose HasSnaky 3 childrenC_595_i8 childrenD_595_i8 children_work_595_i8 (5, 2) + required_595_i8 envelope_595_i8 pivot_mem_595_i8 child_required_sub_595_i8 child_envelope_sub_595_i8 ?_ + intro b hb + exact common_sub_595_i8 (mem_commonEnvelope childrenD_595_i8 b hb) +def required_595_i10 : Finset Cell := ⟨(([(0, 1), (1, 1), (3, 1), (3, 2), (6, 2), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i10 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (4, 2), (5, 2), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i10 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_2), (placed21 7 (7, 5) required_157)] +def childrenD_595_i10 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_2), (placed21 7 (7, 5) envelope_157)] +theorem common_sub_595_i10 : commonEnvelope childrenD_595_i10 ⊆ insert (4, 2) required_595_i10 := by decide +kernel +theorem child_required_sub_595_i10 : ∀ j, childrenC_595_i10 j ⊆ insert (4, 2) required_595_i10 := by decide +kernel +theorem child_envelope_sub_595_i10 : ∀ j, childrenD_595_i10 j ⊆ envelope_595_i10 := by decide +kernel +theorem pivot_mem_595_i10 : (4, 2) ∈ envelope_595_i10 := by decide +kernel +theorem children_work_595_i10 : ∀ j, Template HasSnaky 3 (childrenC_595_i10 j) (childrenD_595_i10 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_157 7 (7, 5)).mono (by decide +kernel) +theorem row_works_595_i10 : Template HasSnaky 4 required_595_i10 envelope_595_i10 := by + refine compose HasSnaky 3 childrenC_595_i10 childrenD_595_i10 children_work_595_i10 (4, 2) + required_595_i10 envelope_595_i10 pivot_mem_595_i10 child_required_sub_595_i10 child_envelope_sub_595_i10 ?_ + intro b hb + exact common_sub_595_i10 (mem_commonEnvelope childrenD_595_i10 b hb) +def required_595_i2 : Finset Cell := ⟨(([(0, 1), (1, 1), (3, 1), (3, 2), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i2 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i2 : Fin 5 → Finset Cell := ![(placed21 7 (7, 5) required_8), required_595_i3, required_595_i7, required_595_i8, required_595_i10] +def childrenD_595_i2 : Fin 5 → Finset Cell := ![(placed21 7 (7, 5) envelope_8), envelope_595_i3, envelope_595_i7, envelope_595_i8, envelope_595_i10] +theorem common_sub_595_i2 : commonEnvelope childrenD_595_i2 ⊆ insert (6, 2) required_595_i2 := by decide +kernel +theorem child_required_sub_595_i2 : ∀ j, childrenC_595_i2 j ⊆ insert (6, 2) required_595_i2 := by decide +kernel +theorem child_envelope_sub_595_i2 : ∀ j, childrenD_595_i2 j ⊆ envelope_595_i2 := by decide +kernel +theorem pivot_mem_595_i2 : (6, 2) ∈ envelope_595_i2 := by decide +kernel +theorem children_work_595_i2 : ∀ j, Template HasSnaky 5 (childrenC_595_i2 j) (childrenD_595_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 7 (7, 5)).mono (by decide +kernel) + · exact row_works_595_i3.mono (by decide +kernel) + · exact row_works_595_i7.mono (by decide +kernel) + · exact row_works_595_i8.mono (by decide +kernel) + · exact row_works_595_i10.mono (by decide +kernel) +theorem row_works_595_i2 : Template HasSnaky 6 required_595_i2 envelope_595_i2 := by + refine compose HasSnaky 5 childrenC_595_i2 childrenD_595_i2 children_work_595_i2 (6, 2) + required_595_i2 envelope_595_i2 pivot_mem_595_i2 child_required_sub_595_i2 child_envelope_sub_595_i2 ?_ + intro b hb + exact common_sub_595_i2 (mem_commonEnvelope childrenD_595_i2 b hb) +def required_595_i1 : Finset Cell := ⟨(([(0, 1), (1, 1), (3, 1), (3, 2), (3, 4), (4, 4), (5, 4), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i1 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (3, 4), (4, 0), (4, 1), (4, 2), (4, 4), (5, 0), (5, 1), (5, 2), (5, 4), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i1 : Fin 2 → Finset Cell := ![(placed21 4 (3, 4) required_5), required_595_i2] +def childrenD_595_i1 : Fin 2 → Finset Cell := ![(placed21 4 (3, 4) envelope_5), envelope_595_i2] +theorem common_sub_595_i1 : commonEnvelope childrenD_595_i1 ⊆ insert (6, 3) required_595_i1 := by decide +kernel +theorem child_required_sub_595_i1 : ∀ j, childrenC_595_i1 j ⊆ insert (6, 3) required_595_i1 := by decide +kernel +theorem child_envelope_sub_595_i1 : ∀ j, childrenD_595_i1 j ⊆ envelope_595_i1 := by decide +kernel +theorem pivot_mem_595_i1 : (6, 3) ∈ envelope_595_i1 := by decide +kernel +theorem children_work_595_i1 : ∀ j, Template HasSnaky 6 (childrenC_595_i1 j) (childrenD_595_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (3, 4)).mono (by decide +kernel) + · exact row_works_595_i2.mono (by decide +kernel) +theorem row_works_595_i1 : Template HasSnaky 7 required_595_i1 envelope_595_i1 := by + refine compose HasSnaky 6 childrenC_595_i1 childrenD_595_i1 children_work_595_i1 (6, 3) + required_595_i1 envelope_595_i1 pivot_mem_595_i1 child_required_sub_595_i1 child_envelope_sub_595_i1 ?_ + intro b hb + exact common_sub_595_i1 (mem_commonEnvelope childrenD_595_i1 b hb) +def required_595_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (3, 1), (3, 2), (3, 4), (4, 4), (5, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (3, 1), (3, 2), (3, 4), (4, 0), (4, 1), (4, 2), (4, 4), (5, 0), (5, 1), (5, 2), (5, 4), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2), (7, 3), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595_i0 : Fin 2 → Finset Cell := ![(placed21 0 (3, 4) required_5), required_595_i1] +def childrenD_595_i0 : Fin 2 → Finset Cell := ![(placed21 0 (3, 4) envelope_5), envelope_595_i1] +theorem common_sub_595_i0 : commonEnvelope childrenD_595_i0 ⊆ insert (6, 4) required_595_i0 := by decide +kernel +theorem child_required_sub_595_i0 : ∀ j, childrenC_595_i0 j ⊆ insert (6, 4) required_595_i0 := by decide +kernel +theorem child_envelope_sub_595_i0 : ∀ j, childrenD_595_i0 j ⊆ envelope_595_i0 := by decide +kernel +theorem pivot_mem_595_i0 : (6, 4) ∈ envelope_595_i0 := by decide +kernel +theorem children_work_595_i0 : ∀ j, Template HasSnaky 7 (childrenC_595_i0 j) (childrenD_595_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (3, 4)).mono (by decide +kernel) + · exact row_works_595_i1.mono (by decide +kernel) +theorem row_works_595_i0 : Template HasSnaky 8 required_595_i0 envelope_595_i0 := by + refine compose HasSnaky 7 childrenC_595_i0 childrenD_595_i0 children_work_595_i0 (6, 4) + required_595_i0 envelope_595_i0 pivot_mem_595_i0 child_required_sub_595_i0 child_envelope_sub_595_i0 ?_ + intro b hb + exact common_sub_595_i0 (mem_commonEnvelope childrenD_595_i0 b hb) +def required_595 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 4), (3, 1), (3, 2), (3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_595 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 1), (3, 2), (3, 4), (4, 0), (4, 1), (4, 2), (4, 4), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2), (7, 3), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_595 : Fin 2 → Finset Cell := ![(placed21 0 (2, 4) required_4), required_595_i0] +def childrenD_595 : Fin 2 → Finset Cell := ![(placed21 0 (2, 4) envelope_4), envelope_595_i0] +theorem common_sub_595 : commonEnvelope childrenD_595 ⊆ insert (6, 5) required_595 := by decide +kernel +theorem child_required_sub_595 : ∀ j, childrenC_595 j ⊆ insert (6, 5) required_595 := by decide +kernel +theorem child_envelope_sub_595 : ∀ j, childrenD_595 j ⊆ envelope_595 := by decide +kernel +theorem pivot_mem_595 : (6, 5) ∈ envelope_595 := by decide +kernel +theorem children_work_595 : ∀ j, Template HasSnaky 8 (childrenC_595 j) (childrenD_595 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 0 (2, 4)).mono (by decide +kernel) + · exact row_works_595_i0.mono (by decide +kernel) +theorem row_works_595 : Template HasSnaky 9 required_595 envelope_595 := by + refine compose HasSnaky 8 childrenC_595 childrenD_595 children_work_595 (6, 5) + required_595 envelope_595 pivot_mem_595 child_required_sub_595 child_envelope_sub_595 ?_ + intro b hb + exact common_sub_595 (mem_commonEnvelope childrenD_595 b hb) +def required_614_i1 : Finset Cell := ⟨(([(0, 4), (3, 3), (3, 4), (3, 5), (4, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_614_i1 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_614_i1 : Fin 2 → Finset Cell := ![(placed21 0 (0, 4) required_1), (placed21 4 (2, 6) required_425)] +def childrenD_614_i1 : Fin 2 → Finset Cell := ![(placed21 0 (0, 4) envelope_1), (placed21 4 (2, 6) envelope_425)] +theorem common_sub_614_i1 : commonEnvelope childrenD_614_i1 ⊆ insert (2, 4) required_614_i1 := by decide +kernel +theorem child_required_sub_614_i1 : ∀ j, childrenC_614_i1 j ⊆ insert (2, 4) required_614_i1 := by decide +kernel +theorem child_envelope_sub_614_i1 : ∀ j, childrenD_614_i1 j ⊆ envelope_614_i1 := by decide +kernel +theorem pivot_mem_614_i1 : (2, 4) ∈ envelope_614_i1 := by decide +kernel +theorem children_work_614_i1 : ∀ j, Template HasSnaky 5 (childrenC_614_i1 j) (childrenD_614_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_425 4 (2, 6)).mono (by decide +kernel) +theorem row_works_614_i1 : Template HasSnaky 6 required_614_i1 envelope_614_i1 := by + refine compose HasSnaky 5 childrenC_614_i1 childrenD_614_i1 children_work_614_i1 (2, 4) + required_614_i1 envelope_614_i1 pivot_mem_614_i1 child_required_sub_614_i1 child_envelope_sub_614_i1 ?_ + intro b hb + exact common_sub_614_i1 (mem_commonEnvelope childrenD_614_i1 b hb) +def required_614_i2 : Finset Cell := ⟨(([(0, 4), (3, 3), (3, 4), (3, 5), (4, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_614_i2 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 3), (6, 6), (6, 7), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_614_i2 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_68), (placed21 4 (3, 8) required_495)] +def childrenD_614_i2 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_68), (placed21 4 (3, 8) envelope_495)] +theorem common_sub_614_i2 : commonEnvelope childrenD_614_i2 ⊆ insert (4, 3) required_614_i2 := by decide +kernel +theorem child_required_sub_614_i2 : ∀ j, childrenC_614_i2 j ⊆ insert (4, 3) required_614_i2 := by decide +kernel +theorem child_envelope_sub_614_i2 : ∀ j, childrenD_614_i2 j ⊆ envelope_614_i2 := by decide +kernel +theorem pivot_mem_614_i2 : (4, 3) ∈ envelope_614_i2 := by decide +kernel +theorem children_work_614_i2 : ∀ j, Template HasSnaky 5 (childrenC_614_i2 j) (childrenD_614_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_68 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_495 4 (3, 8)).mono (by decide +kernel) +theorem row_works_614_i2 : Template HasSnaky 6 required_614_i2 envelope_614_i2 := by + refine compose HasSnaky 5 childrenC_614_i2 childrenD_614_i2 children_work_614_i2 (4, 3) + required_614_i2 envelope_614_i2 pivot_mem_614_i2 child_required_sub_614_i2 child_envelope_sub_614_i2 ?_ + intro b hb + exact common_sub_614_i2 (mem_commonEnvelope childrenD_614_i2 b hb) +def required_614_i4 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 3), (4, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_614_i4 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_614_i4 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) required_66), (placed21 0 (3, 2) required_66)] +def childrenD_614_i4 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) envelope_66), (placed21 0 (3, 2) envelope_66)] +theorem common_sub_614_i4 : commonEnvelope childrenD_614_i4 ⊆ insert (4, 4) required_614_i4 := by decide +kernel +theorem child_required_sub_614_i4 : ∀ j, childrenC_614_i4 j ⊆ insert (4, 4) required_614_i4 := by decide +kernel +theorem child_envelope_sub_614_i4 : ∀ j, childrenD_614_i4 j ⊆ envelope_614_i4 := by decide +kernel +theorem pivot_mem_614_i4 : (4, 4) ∈ envelope_614_i4 := by decide +kernel +theorem children_work_614_i4 : ∀ j, Template HasSnaky 2 (childrenC_614_i4 j) (childrenD_614_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_66 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_66 0 (3, 2)).mono (by decide +kernel) +theorem row_works_614_i4 : Template HasSnaky 3 required_614_i4 envelope_614_i4 := by + refine compose HasSnaky 2 childrenC_614_i4 childrenD_614_i4 children_work_614_i4 (4, 4) + required_614_i4 envelope_614_i4 pivot_mem_614_i4 child_required_sub_614_i4 child_envelope_sub_614_i4 ?_ + intro b hb + exact common_sub_614_i4 (mem_commonEnvelope childrenD_614_i4 b hb) +def required_614_i3 : Finset Cell := ⟨(([(0, 4), (3, 3), (3, 4), (3, 5), (4, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_614_i3 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 5), (5, 6), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_614_i3 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_68), required_614_i4] +def childrenD_614_i3 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_68), envelope_614_i4] +theorem common_sub_614_i3 : commonEnvelope childrenD_614_i3 ⊆ insert (4, 3) required_614_i3 := by decide +kernel +theorem child_required_sub_614_i3 : ∀ j, childrenC_614_i3 j ⊆ insert (4, 3) required_614_i3 := by decide +kernel +theorem child_envelope_sub_614_i3 : ∀ j, childrenD_614_i3 j ⊆ envelope_614_i3 := by decide +kernel +theorem pivot_mem_614_i3 : (4, 3) ∈ envelope_614_i3 := by decide +kernel +theorem children_work_614_i3 : ∀ j, Template HasSnaky 3 (childrenC_614_i3 j) (childrenD_614_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_68 3 (0, 4)).mono (by decide +kernel) + · exact row_works_614_i4.mono (by decide +kernel) +theorem row_works_614_i3 : Template HasSnaky 4 required_614_i3 envelope_614_i3 := by + refine compose HasSnaky 3 childrenC_614_i3 childrenD_614_i3 children_work_614_i3 (4, 3) + required_614_i3 envelope_614_i3 pivot_mem_614_i3 child_required_sub_614_i3 child_envelope_sub_614_i3 ?_ + intro b hb + exact common_sub_614_i3 (mem_commonEnvelope childrenD_614_i3 b hb) +def required_614_i5 : Finset Cell := ⟨(([(0, 4), (3, 3), (3, 4), (4, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_614_i5 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_614_i5 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_68), (placed21 4 (4, 6) required_612)] +def childrenD_614_i5 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_68), (placed21 4 (4, 6) envelope_612)] +theorem common_sub_614_i5 : commonEnvelope childrenD_614_i5 ⊆ insert (4, 3) required_614_i5 := by decide +kernel +theorem child_required_sub_614_i5 : ∀ j, childrenC_614_i5 j ⊆ insert (4, 3) required_614_i5 := by decide +kernel +theorem child_envelope_sub_614_i5 : ∀ j, childrenD_614_i5 j ⊆ envelope_614_i5 := by decide +kernel +theorem pivot_mem_614_i5 : (4, 3) ∈ envelope_614_i5 := by decide +kernel +theorem children_work_614_i5 : ∀ j, Template HasSnaky 5 (childrenC_614_i5 j) (childrenD_614_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_68 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_612 4 (4, 6)).mono (by decide +kernel) +theorem row_works_614_i5 : Template HasSnaky 6 required_614_i5 envelope_614_i5 := by + refine compose HasSnaky 5 childrenC_614_i5 childrenD_614_i5 children_work_614_i5 (4, 3) + required_614_i5 envelope_614_i5 pivot_mem_614_i5 child_required_sub_614_i5 child_envelope_sub_614_i5 ?_ + intro b hb + exact common_sub_614_i5 (mem_commonEnvelope childrenD_614_i5 b hb) +def required_614_i0 : Finset Cell := ⟨(([(0, 4), (3, 3), (3, 4), (3, 5), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_614_i0 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (7, 2), (7, 6), (8, 2), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_614_i0 : Fin 6 → Finset Cell := ![(placed21 4 (3, 8) required_276), required_614_i1, (placed21 4 (3, 9) required_611), required_614_i2, required_614_i3, required_614_i5] +def childrenD_614_i0 : Fin 6 → Finset Cell := ![(placed21 4 (3, 8) envelope_276), envelope_614_i1, (placed21 4 (3, 9) envelope_611), envelope_614_i2, envelope_614_i3, envelope_614_i5] +theorem common_sub_614_i0 : commonEnvelope childrenD_614_i0 ⊆ insert (5, 3) required_614_i0 := by decide +kernel +theorem child_required_sub_614_i0 : ∀ j, childrenC_614_i0 j ⊆ insert (5, 3) required_614_i0 := by decide +kernel +theorem child_envelope_sub_614_i0 : ∀ j, childrenD_614_i0 j ⊆ envelope_614_i0 := by decide +kernel +theorem pivot_mem_614_i0 : (5, 3) ∈ envelope_614_i0 := by decide +kernel +theorem children_work_614_i0 : ∀ j, Template HasSnaky 7 (childrenC_614_i0 j) (childrenD_614_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_276 4 (3, 8)).mono (by decide +kernel) + · exact row_works_614_i1.mono (by decide +kernel) + · exact (placed21_template row_works_611 4 (3, 9)).mono (by decide +kernel) + · exact row_works_614_i2.mono (by decide +kernel) + · exact row_works_614_i3.mono (by decide +kernel) + · exact row_works_614_i5.mono (by decide +kernel) +theorem row_works_614_i0 : Template HasSnaky 8 required_614_i0 envelope_614_i0 := by + refine compose HasSnaky 7 childrenC_614_i0 childrenD_614_i0 children_work_614_i0 (5, 3) + required_614_i0 envelope_614_i0 pivot_mem_614_i0 child_required_sub_614_i0 child_envelope_sub_614_i0 ?_ + intro b hb + exact common_sub_614_i0 (mem_commonEnvelope childrenD_614_i0 b hb) +def required_614 : Finset Cell := ⟨(([(0, 4), (3, 3), (3, 4), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_614 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 4), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 2), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_614 : Fin 3 → Finset Cell := ![(placed21 1 (0, 4) required_68), (placed21 4 (3, 7) required_558), required_614_i0] +def childrenD_614 : Fin 3 → Finset Cell := ![(placed21 1 (0, 4) envelope_68), (placed21 4 (3, 7) envelope_558), envelope_614_i0] +theorem common_sub_614 : commonEnvelope childrenD_614 ⊆ insert (5, 5) required_614 := by decide +kernel +theorem child_required_sub_614 : ∀ j, childrenC_614 j ⊆ insert (5, 5) required_614 := by decide +kernel +theorem child_envelope_sub_614 : ∀ j, childrenD_614 j ⊆ envelope_614 := by decide +kernel +theorem pivot_mem_614 : (5, 5) ∈ envelope_614 := by decide +kernel +theorem children_work_614 : ∀ j, Template HasSnaky 8 (childrenC_614 j) (childrenD_614 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_68 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_558 4 (3, 7)).mono (by decide +kernel) + · exact row_works_614_i0.mono (by decide +kernel) +theorem row_works_614 : Template HasSnaky 9 required_614 envelope_614 := by + refine compose HasSnaky 8 childrenC_614 childrenD_614 children_work_614 (5, 5) + required_614 envelope_614 pivot_mem_614 child_required_sub_614 child_envelope_sub_614 ?_ + intro b hb + exact common_sub_614 (mem_commonEnvelope childrenD_614 b hb) +def height_595_i6 : ℕ := 2 +def childrenH_595_i6 : Fin 2 → ℕ := ![height_4, height_5] +theorem height_exact_595_i6 : height_595_i6 = 1 + Finset.univ.sup childrenH_595_i6 := by decide +kernel +theorem required_origin_595_i6 : ∀ x ∈ required_595_i6, + (∃ j, x ∈ childrenC_595_i6 j) ∨ ∀ j, x ∈ childrenD_595_i6 j := by decide +kernel +theorem required_exact_595_i6 : required_595_i6 = + ((Finset.univ.biUnion childrenC_595_i6) ∪ commonEnvelope childrenD_595_i6).erase (4, 1) := by + exact required_eq_combination childrenC_595_i6 childrenD_595_i6 (4, 1) required_595_i6 + (by decide +kernel) child_required_sub_595_i6 common_sub_595_i6 required_origin_595_i6 +theorem envelope_origin_595_i6 : ∀ x ∈ envelope_595_i6, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_595_i6 j := by decide +kernel +theorem envelope_exact_595_i6 : envelope_595_i6 = + insert (4, 1) (Finset.univ.biUnion childrenD_595_i6) := by + exact envelope_eq_combination childrenD_595_i6 (4, 1) envelope_595_i6 + pivot_mem_595_i6 child_envelope_sub_595_i6 envelope_origin_595_i6 +def checked_595_i6 : CheckedCard where + required := required_595_i6 + envelope := envelope_595_i6 + height := height_595_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i6 +def height_595_i5 : ℕ := 3 +def childrenH_595_i5 : Fin 2 → ℕ := ![height_3, height_595_i6] +theorem height_exact_595_i5 : height_595_i5 = 1 + Finset.univ.sup childrenH_595_i5 := by decide +kernel +theorem required_origin_595_i5 : ∀ x ∈ required_595_i5, + (∃ j, x ∈ childrenC_595_i5 j) ∨ ∀ j, x ∈ childrenD_595_i5 j := by decide +kernel +theorem required_exact_595_i5 : required_595_i5 = + ((Finset.univ.biUnion childrenC_595_i5) ∪ commonEnvelope childrenD_595_i5).erase (5, 0) := by + exact required_eq_combination childrenC_595_i5 childrenD_595_i5 (5, 0) required_595_i5 + (by decide +kernel) child_required_sub_595_i5 common_sub_595_i5 required_origin_595_i5 +theorem envelope_origin_595_i5 : ∀ x ∈ envelope_595_i5, + x = (5, 0) ∨ ∃ j, x ∈ childrenD_595_i5 j := by decide +kernel +theorem envelope_exact_595_i5 : envelope_595_i5 = + insert (5, 0) (Finset.univ.biUnion childrenD_595_i5) := by + exact envelope_eq_combination childrenD_595_i5 (5, 0) envelope_595_i5 + pivot_mem_595_i5 child_envelope_sub_595_i5 envelope_origin_595_i5 +def checked_595_i5 : CheckedCard where + required := required_595_i5 + envelope := envelope_595_i5 + height := height_595_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i5 +def height_595_i4 : ℕ := 4 +def childrenH_595_i4 : Fin 2 → ℕ := ![height_4, height_595_i5] +theorem height_exact_595_i4 : height_595_i4 = 1 + Finset.univ.sup childrenH_595_i4 := by decide +kernel +theorem required_origin_595_i4 : ∀ x ∈ required_595_i4, + (∃ j, x ∈ childrenC_595_i4 j) ∨ ∀ j, x ∈ childrenD_595_i4 j := by decide +kernel +theorem required_exact_595_i4 : required_595_i4 = + ((Finset.univ.biUnion childrenC_595_i4) ∪ commonEnvelope childrenD_595_i4).erase (5, 1) := by + exact required_eq_combination childrenC_595_i4 childrenD_595_i4 (5, 1) required_595_i4 + (by decide +kernel) child_required_sub_595_i4 common_sub_595_i4 required_origin_595_i4 +theorem envelope_origin_595_i4 : ∀ x ∈ envelope_595_i4, + x = (5, 1) ∨ ∃ j, x ∈ childrenD_595_i4 j := by decide +kernel +theorem envelope_exact_595_i4 : envelope_595_i4 = + insert (5, 1) (Finset.univ.biUnion childrenD_595_i4) := by + exact envelope_eq_combination childrenD_595_i4 (5, 1) envelope_595_i4 + pivot_mem_595_i4 child_envelope_sub_595_i4 envelope_origin_595_i4 +def checked_595_i4 : CheckedCard where + required := required_595_i4 + envelope := envelope_595_i4 + height := height_595_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i4 +def height_595_i3 : ℕ := 5 +def childrenH_595_i3 : Fin 2 → ℕ := ![height_5, height_595_i4] +theorem height_exact_595_i3 : height_595_i3 = 1 + Finset.univ.sup childrenH_595_i3 := by decide +kernel +theorem required_origin_595_i3 : ∀ x ∈ required_595_i3, + (∃ j, x ∈ childrenC_595_i3 j) ∨ ∀ j, x ∈ childrenD_595_i3 j := by decide +kernel +theorem required_exact_595_i3 : required_595_i3 = + ((Finset.univ.biUnion childrenC_595_i3) ∪ commonEnvelope childrenD_595_i3).erase (2, 1) := by + exact required_eq_combination childrenC_595_i3 childrenD_595_i3 (2, 1) required_595_i3 + (by decide +kernel) child_required_sub_595_i3 common_sub_595_i3 required_origin_595_i3 +theorem envelope_origin_595_i3 : ∀ x ∈ envelope_595_i3, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_595_i3 j := by decide +kernel +theorem envelope_exact_595_i3 : envelope_595_i3 = + insert (2, 1) (Finset.univ.biUnion childrenD_595_i3) := by + exact envelope_eq_combination childrenD_595_i3 (2, 1) envelope_595_i3 + pivot_mem_595_i3 child_envelope_sub_595_i3 envelope_origin_595_i3 +def checked_595_i3 : CheckedCard where + required := required_595_i3 + envelope := envelope_595_i3 + height := height_595_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i3 +def height_595_i7 : ℕ := 5 +def childrenH_595_i7 : Fin 2 → ℕ := ![height_2, height_208] +theorem height_exact_595_i7 : height_595_i7 = 1 + Finset.univ.sup childrenH_595_i7 := by decide +kernel +theorem required_origin_595_i7 : ∀ x ∈ required_595_i7, + (∃ j, x ∈ childrenC_595_i7 j) ∨ ∀ j, x ∈ childrenD_595_i7 j := by decide +kernel +theorem required_exact_595_i7 : required_595_i7 = + ((Finset.univ.biUnion childrenC_595_i7) ∪ commonEnvelope childrenD_595_i7).erase (4, 2) := by + exact required_eq_combination childrenC_595_i7 childrenD_595_i7 (4, 2) required_595_i7 + (by decide +kernel) child_required_sub_595_i7 common_sub_595_i7 required_origin_595_i7 +theorem envelope_origin_595_i7 : ∀ x ∈ envelope_595_i7, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_595_i7 j := by decide +kernel +theorem envelope_exact_595_i7 : envelope_595_i7 = + insert (4, 2) (Finset.univ.biUnion childrenD_595_i7) := by + exact envelope_eq_combination childrenD_595_i7 (4, 2) envelope_595_i7 + pivot_mem_595_i7 child_envelope_sub_595_i7 envelope_origin_595_i7 +def checked_595_i7 : CheckedCard where + required := required_595_i7 + envelope := envelope_595_i7 + height := height_595_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i7 +def height_595_i9 : ℕ := 3 +def childrenH_595_i9 : Fin 2 → ℕ := ![height_5, height_153] +theorem height_exact_595_i9 : height_595_i9 = 1 + Finset.univ.sup childrenH_595_i9 := by decide +kernel +theorem required_origin_595_i9 : ∀ x ∈ required_595_i9, + (∃ j, x ∈ childrenC_595_i9 j) ∨ ∀ j, x ∈ childrenD_595_i9 j := by decide +kernel +theorem required_exact_595_i9 : required_595_i9 = + ((Finset.univ.biUnion childrenC_595_i9) ∪ commonEnvelope childrenD_595_i9).erase (4, 2) := by + exact required_eq_combination childrenC_595_i9 childrenD_595_i9 (4, 2) required_595_i9 + (by decide +kernel) child_required_sub_595_i9 common_sub_595_i9 required_origin_595_i9 +theorem envelope_origin_595_i9 : ∀ x ∈ envelope_595_i9, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_595_i9 j := by decide +kernel +theorem envelope_exact_595_i9 : envelope_595_i9 = + insert (4, 2) (Finset.univ.biUnion childrenD_595_i9) := by + exact envelope_eq_combination childrenD_595_i9 (4, 2) envelope_595_i9 + pivot_mem_595_i9 child_envelope_sub_595_i9 envelope_origin_595_i9 +def checked_595_i9 : CheckedCard where + required := required_595_i9 + envelope := envelope_595_i9 + height := height_595_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i9 +def height_595_i8 : ℕ := 4 +def childrenH_595_i8 : Fin 2 → ℕ := ![height_5, height_595_i9] +theorem height_exact_595_i8 : height_595_i8 = 1 + Finset.univ.sup childrenH_595_i8 := by decide +kernel +theorem required_origin_595_i8 : ∀ x ∈ required_595_i8, + (∃ j, x ∈ childrenC_595_i8 j) ∨ ∀ j, x ∈ childrenD_595_i8 j := by decide +kernel +theorem required_exact_595_i8 : required_595_i8 = + ((Finset.univ.biUnion childrenC_595_i8) ∪ commonEnvelope childrenD_595_i8).erase (5, 2) := by + exact required_eq_combination childrenC_595_i8 childrenD_595_i8 (5, 2) required_595_i8 + (by decide +kernel) child_required_sub_595_i8 common_sub_595_i8 required_origin_595_i8 +theorem envelope_origin_595_i8 : ∀ x ∈ envelope_595_i8, + x = (5, 2) ∨ ∃ j, x ∈ childrenD_595_i8 j := by decide +kernel +theorem envelope_exact_595_i8 : envelope_595_i8 = + insert (5, 2) (Finset.univ.biUnion childrenD_595_i8) := by + exact envelope_eq_combination childrenD_595_i8 (5, 2) envelope_595_i8 + pivot_mem_595_i8 child_envelope_sub_595_i8 envelope_origin_595_i8 +def checked_595_i8 : CheckedCard where + required := required_595_i8 + envelope := envelope_595_i8 + height := height_595_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i8 +def height_595_i10 : ℕ := 4 +def childrenH_595_i10 : Fin 2 → ℕ := ![height_2, height_157] +theorem height_exact_595_i10 : height_595_i10 = 1 + Finset.univ.sup childrenH_595_i10 := by decide +kernel +theorem required_origin_595_i10 : ∀ x ∈ required_595_i10, + (∃ j, x ∈ childrenC_595_i10 j) ∨ ∀ j, x ∈ childrenD_595_i10 j := by decide +kernel +theorem required_exact_595_i10 : required_595_i10 = + ((Finset.univ.biUnion childrenC_595_i10) ∪ commonEnvelope childrenD_595_i10).erase (4, 2) := by + exact required_eq_combination childrenC_595_i10 childrenD_595_i10 (4, 2) required_595_i10 + (by decide +kernel) child_required_sub_595_i10 common_sub_595_i10 required_origin_595_i10 +theorem envelope_origin_595_i10 : ∀ x ∈ envelope_595_i10, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_595_i10 j := by decide +kernel +theorem envelope_exact_595_i10 : envelope_595_i10 = + insert (4, 2) (Finset.univ.biUnion childrenD_595_i10) := by + exact envelope_eq_combination childrenD_595_i10 (4, 2) envelope_595_i10 + pivot_mem_595_i10 child_envelope_sub_595_i10 envelope_origin_595_i10 +def checked_595_i10 : CheckedCard where + required := required_595_i10 + envelope := envelope_595_i10 + height := height_595_i10 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i10 +def height_595_i2 : ℕ := 6 +def childrenH_595_i2 : Fin 5 → ℕ := ![height_8, height_595_i3, height_595_i7, height_595_i8, height_595_i10] +theorem height_exact_595_i2 : height_595_i2 = 1 + Finset.univ.sup childrenH_595_i2 := by decide +kernel +theorem required_origin_595_i2 : ∀ x ∈ required_595_i2, + (∃ j, x ∈ childrenC_595_i2 j) ∨ ∀ j, x ∈ childrenD_595_i2 j := by decide +kernel +theorem required_exact_595_i2 : required_595_i2 = + ((Finset.univ.biUnion childrenC_595_i2) ∪ commonEnvelope childrenD_595_i2).erase (6, 2) := by + exact required_eq_combination childrenC_595_i2 childrenD_595_i2 (6, 2) required_595_i2 + (by decide +kernel) child_required_sub_595_i2 common_sub_595_i2 required_origin_595_i2 +theorem envelope_origin_595_i2 : ∀ x ∈ envelope_595_i2, + x = (6, 2) ∨ ∃ j, x ∈ childrenD_595_i2 j := by decide +kernel +theorem envelope_exact_595_i2 : envelope_595_i2 = + insert (6, 2) (Finset.univ.biUnion childrenD_595_i2) := by + exact envelope_eq_combination childrenD_595_i2 (6, 2) envelope_595_i2 + pivot_mem_595_i2 child_envelope_sub_595_i2 envelope_origin_595_i2 +def checked_595_i2 : CheckedCard where + required := required_595_i2 + envelope := envelope_595_i2 + height := height_595_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i2 +def height_595_i1 : ℕ := 7 +def childrenH_595_i1 : Fin 2 → ℕ := ![height_5, height_595_i2] +theorem height_exact_595_i1 : height_595_i1 = 1 + Finset.univ.sup childrenH_595_i1 := by decide +kernel +theorem required_origin_595_i1 : ∀ x ∈ required_595_i1, + (∃ j, x ∈ childrenC_595_i1 j) ∨ ∀ j, x ∈ childrenD_595_i1 j := by decide +kernel +theorem required_exact_595_i1 : required_595_i1 = + ((Finset.univ.biUnion childrenC_595_i1) ∪ commonEnvelope childrenD_595_i1).erase (6, 3) := by + exact required_eq_combination childrenC_595_i1 childrenD_595_i1 (6, 3) required_595_i1 + (by decide +kernel) child_required_sub_595_i1 common_sub_595_i1 required_origin_595_i1 +theorem envelope_origin_595_i1 : ∀ x ∈ envelope_595_i1, + x = (6, 3) ∨ ∃ j, x ∈ childrenD_595_i1 j := by decide +kernel +theorem envelope_exact_595_i1 : envelope_595_i1 = + insert (6, 3) (Finset.univ.biUnion childrenD_595_i1) := by + exact envelope_eq_combination childrenD_595_i1 (6, 3) envelope_595_i1 + pivot_mem_595_i1 child_envelope_sub_595_i1 envelope_origin_595_i1 +def checked_595_i1 : CheckedCard where + required := required_595_i1 + envelope := envelope_595_i1 + height := height_595_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i1 +def height_595_i0 : ℕ := 8 +def childrenH_595_i0 : Fin 2 → ℕ := ![height_5, height_595_i1] +theorem height_exact_595_i0 : height_595_i0 = 1 + Finset.univ.sup childrenH_595_i0 := by decide +kernel +theorem required_origin_595_i0 : ∀ x ∈ required_595_i0, + (∃ j, x ∈ childrenC_595_i0 j) ∨ ∀ j, x ∈ childrenD_595_i0 j := by decide +kernel +theorem required_exact_595_i0 : required_595_i0 = + ((Finset.univ.biUnion childrenC_595_i0) ∪ commonEnvelope childrenD_595_i0).erase (6, 4) := by + exact required_eq_combination childrenC_595_i0 childrenD_595_i0 (6, 4) required_595_i0 + (by decide +kernel) child_required_sub_595_i0 common_sub_595_i0 required_origin_595_i0 +theorem envelope_origin_595_i0 : ∀ x ∈ envelope_595_i0, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_595_i0 j := by decide +kernel +theorem envelope_exact_595_i0 : envelope_595_i0 = + insert (6, 4) (Finset.univ.biUnion childrenD_595_i0) := by + exact envelope_eq_combination childrenD_595_i0 (6, 4) envelope_595_i0 + pivot_mem_595_i0 child_envelope_sub_595_i0 envelope_origin_595_i0 +def checked_595_i0 : CheckedCard where + required := required_595_i0 + envelope := envelope_595_i0 + height := height_595_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595_i0 +def height_595 : ℕ := 9 +def childrenH_595 : Fin 2 → ℕ := ![height_4, height_595_i0] +theorem height_exact_595 : height_595 = 1 + Finset.univ.sup childrenH_595 := by decide +kernel +theorem required_origin_595 : ∀ x ∈ required_595, + (∃ j, x ∈ childrenC_595 j) ∨ ∀ j, x ∈ childrenD_595 j := by decide +kernel +theorem required_exact_595 : required_595 = + ((Finset.univ.biUnion childrenC_595) ∪ commonEnvelope childrenD_595).erase (6, 5) := by + exact required_eq_combination childrenC_595 childrenD_595 (6, 5) required_595 + (by decide +kernel) child_required_sub_595 common_sub_595 required_origin_595 +theorem envelope_origin_595 : ∀ x ∈ envelope_595, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_595 j := by decide +kernel +theorem envelope_exact_595 : envelope_595 = + insert (6, 5) (Finset.univ.biUnion childrenD_595) := by + exact envelope_eq_combination childrenD_595 (6, 5) envelope_595 + pivot_mem_595 child_envelope_sub_595 envelope_origin_595 +def checked_595 : CheckedCard where + required := required_595 + envelope := envelope_595 + height := height_595 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_595 +def height_614_i1 : ℕ := 6 +def childrenH_614_i1 : Fin 2 → ℕ := ![height_1, height_425] +theorem height_exact_614_i1 : height_614_i1 = 1 + Finset.univ.sup childrenH_614_i1 := by decide +kernel +theorem required_origin_614_i1 : ∀ x ∈ required_614_i1, + (∃ j, x ∈ childrenC_614_i1 j) ∨ ∀ j, x ∈ childrenD_614_i1 j := by decide +kernel +theorem required_exact_614_i1 : required_614_i1 = + ((Finset.univ.biUnion childrenC_614_i1) ∪ commonEnvelope childrenD_614_i1).erase (2, 4) := by + exact required_eq_combination childrenC_614_i1 childrenD_614_i1 (2, 4) required_614_i1 + (by decide +kernel) child_required_sub_614_i1 common_sub_614_i1 required_origin_614_i1 +theorem envelope_origin_614_i1 : ∀ x ∈ envelope_614_i1, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_614_i1 j := by decide +kernel +theorem envelope_exact_614_i1 : envelope_614_i1 = + insert (2, 4) (Finset.univ.biUnion childrenD_614_i1) := by + exact envelope_eq_combination childrenD_614_i1 (2, 4) envelope_614_i1 + pivot_mem_614_i1 child_envelope_sub_614_i1 envelope_origin_614_i1 +def checked_614_i1 : CheckedCard where + required := required_614_i1 + envelope := envelope_614_i1 + height := height_614_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_614_i1 +def height_614_i2 : ℕ := 6 +def childrenH_614_i2 : Fin 2 → ℕ := ![height_68, height_495] +theorem height_exact_614_i2 : height_614_i2 = 1 + Finset.univ.sup childrenH_614_i2 := by decide +kernel +theorem required_origin_614_i2 : ∀ x ∈ required_614_i2, + (∃ j, x ∈ childrenC_614_i2 j) ∨ ∀ j, x ∈ childrenD_614_i2 j := by decide +kernel +theorem required_exact_614_i2 : required_614_i2 = + ((Finset.univ.biUnion childrenC_614_i2) ∪ commonEnvelope childrenD_614_i2).erase (4, 3) := by + exact required_eq_combination childrenC_614_i2 childrenD_614_i2 (4, 3) required_614_i2 + (by decide +kernel) child_required_sub_614_i2 common_sub_614_i2 required_origin_614_i2 +theorem envelope_origin_614_i2 : ∀ x ∈ envelope_614_i2, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_614_i2 j := by decide +kernel +theorem envelope_exact_614_i2 : envelope_614_i2 = + insert (4, 3) (Finset.univ.biUnion childrenD_614_i2) := by + exact envelope_eq_combination childrenD_614_i2 (4, 3) envelope_614_i2 + pivot_mem_614_i2 child_envelope_sub_614_i2 envelope_origin_614_i2 +def checked_614_i2 : CheckedCard where + required := required_614_i2 + envelope := envelope_614_i2 + height := height_614_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_614_i2 +def height_614_i4 : ℕ := 3 +def childrenH_614_i4 : Fin 2 → ℕ := ![height_66, height_66] +theorem height_exact_614_i4 : height_614_i4 = 1 + Finset.univ.sup childrenH_614_i4 := by decide +kernel +theorem required_origin_614_i4 : ∀ x ∈ required_614_i4, + (∃ j, x ∈ childrenC_614_i4 j) ∨ ∀ j, x ∈ childrenD_614_i4 j := by decide +kernel +theorem required_exact_614_i4 : required_614_i4 = + ((Finset.univ.biUnion childrenC_614_i4) ∪ commonEnvelope childrenD_614_i4).erase (4, 4) := by + exact required_eq_combination childrenC_614_i4 childrenD_614_i4 (4, 4) required_614_i4 + (by decide +kernel) child_required_sub_614_i4 common_sub_614_i4 required_origin_614_i4 +theorem envelope_origin_614_i4 : ∀ x ∈ envelope_614_i4, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_614_i4 j := by decide +kernel +theorem envelope_exact_614_i4 : envelope_614_i4 = + insert (4, 4) (Finset.univ.biUnion childrenD_614_i4) := by + exact envelope_eq_combination childrenD_614_i4 (4, 4) envelope_614_i4 + pivot_mem_614_i4 child_envelope_sub_614_i4 envelope_origin_614_i4 +def checked_614_i4 : CheckedCard where + required := required_614_i4 + envelope := envelope_614_i4 + height := height_614_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_614_i4 +def height_614_i3 : ℕ := 4 +def childrenH_614_i3 : Fin 2 → ℕ := ![height_68, height_614_i4] +theorem height_exact_614_i3 : height_614_i3 = 1 + Finset.univ.sup childrenH_614_i3 := by decide +kernel +theorem required_origin_614_i3 : ∀ x ∈ required_614_i3, + (∃ j, x ∈ childrenC_614_i3 j) ∨ ∀ j, x ∈ childrenD_614_i3 j := by decide +kernel +theorem required_exact_614_i3 : required_614_i3 = + ((Finset.univ.biUnion childrenC_614_i3) ∪ commonEnvelope childrenD_614_i3).erase (4, 3) := by + exact required_eq_combination childrenC_614_i3 childrenD_614_i3 (4, 3) required_614_i3 + (by decide +kernel) child_required_sub_614_i3 common_sub_614_i3 required_origin_614_i3 +theorem envelope_origin_614_i3 : ∀ x ∈ envelope_614_i3, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_614_i3 j := by decide +kernel +theorem envelope_exact_614_i3 : envelope_614_i3 = + insert (4, 3) (Finset.univ.biUnion childrenD_614_i3) := by + exact envelope_eq_combination childrenD_614_i3 (4, 3) envelope_614_i3 + pivot_mem_614_i3 child_envelope_sub_614_i3 envelope_origin_614_i3 +def checked_614_i3 : CheckedCard where + required := required_614_i3 + envelope := envelope_614_i3 + height := height_614_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_614_i3 +def height_614_i5 : ℕ := 6 +def childrenH_614_i5 : Fin 2 → ℕ := ![height_68, height_612] +theorem height_exact_614_i5 : height_614_i5 = 1 + Finset.univ.sup childrenH_614_i5 := by decide +kernel +theorem required_origin_614_i5 : ∀ x ∈ required_614_i5, + (∃ j, x ∈ childrenC_614_i5 j) ∨ ∀ j, x ∈ childrenD_614_i5 j := by decide +kernel +theorem required_exact_614_i5 : required_614_i5 = + ((Finset.univ.biUnion childrenC_614_i5) ∪ commonEnvelope childrenD_614_i5).erase (4, 3) := by + exact required_eq_combination childrenC_614_i5 childrenD_614_i5 (4, 3) required_614_i5 + (by decide +kernel) child_required_sub_614_i5 common_sub_614_i5 required_origin_614_i5 +theorem envelope_origin_614_i5 : ∀ x ∈ envelope_614_i5, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_614_i5 j := by decide +kernel +theorem envelope_exact_614_i5 : envelope_614_i5 = + insert (4, 3) (Finset.univ.biUnion childrenD_614_i5) := by + exact envelope_eq_combination childrenD_614_i5 (4, 3) envelope_614_i5 + pivot_mem_614_i5 child_envelope_sub_614_i5 envelope_origin_614_i5 +def checked_614_i5 : CheckedCard where + required := required_614_i5 + envelope := envelope_614_i5 + height := height_614_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_614_i5 +def height_614_i0 : ℕ := 8 +def childrenH_614_i0 : Fin 6 → ℕ := ![height_276, height_614_i1, height_611, height_614_i2, height_614_i3, height_614_i5] +theorem height_exact_614_i0 : height_614_i0 = 1 + Finset.univ.sup childrenH_614_i0 := by decide +kernel +theorem required_origin_614_i0 : ∀ x ∈ required_614_i0, + (∃ j, x ∈ childrenC_614_i0 j) ∨ ∀ j, x ∈ childrenD_614_i0 j := by decide +kernel +theorem required_exact_614_i0 : required_614_i0 = + ((Finset.univ.biUnion childrenC_614_i0) ∪ commonEnvelope childrenD_614_i0).erase (5, 3) := by + exact required_eq_combination childrenC_614_i0 childrenD_614_i0 (5, 3) required_614_i0 + (by decide +kernel) child_required_sub_614_i0 common_sub_614_i0 required_origin_614_i0 +theorem envelope_origin_614_i0 : ∀ x ∈ envelope_614_i0, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_614_i0 j := by decide +kernel +theorem envelope_exact_614_i0 : envelope_614_i0 = + insert (5, 3) (Finset.univ.biUnion childrenD_614_i0) := by + exact envelope_eq_combination childrenD_614_i0 (5, 3) envelope_614_i0 + pivot_mem_614_i0 child_envelope_sub_614_i0 envelope_origin_614_i0 +def checked_614_i0 : CheckedCard where + required := required_614_i0 + envelope := envelope_614_i0 + height := height_614_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_614_i0 +def height_614 : ℕ := 9 +def childrenH_614 : Fin 3 → ℕ := ![height_68, height_558, height_614_i0] +theorem height_exact_614 : height_614 = 1 + Finset.univ.sup childrenH_614 := by decide +kernel +theorem required_origin_614 : ∀ x ∈ required_614, + (∃ j, x ∈ childrenC_614 j) ∨ ∀ j, x ∈ childrenD_614 j := by decide +kernel +theorem required_exact_614 : required_614 = + ((Finset.univ.biUnion childrenC_614) ∪ commonEnvelope childrenD_614).erase (5, 5) := by + exact required_eq_combination childrenC_614 childrenD_614 (5, 5) required_614 + (by decide +kernel) child_required_sub_614 common_sub_614 required_origin_614 +theorem envelope_origin_614 : ∀ x ∈ envelope_614, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_614 j := by decide +kernel +theorem envelope_exact_614 : envelope_614 = + insert (5, 5) (Finset.univ.biUnion childrenD_614) := by + exact envelope_eq_combination childrenD_614 (5, 5) envelope_614 + pivot_mem_614 child_envelope_sub_614 envelope_origin_614 +def checked_614 : CheckedCard where + required := required_614 + envelope := envelope_614 + height := height_614 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_614 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part07.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part07.lean new file mode 100644 index 0000000..0d95369 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part07.lean @@ -0,0 +1,908 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_622_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_622_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_622_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) required_41), (placed21 7 (6, 6) required_56)] +def childrenD_622_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) envelope_41), (placed21 7 (6, 6) envelope_56)] +theorem common_sub_622_i0 : commonEnvelope childrenD_622_i0 ⊆ insert (3, 6) required_622_i0 := by decide +kernel +theorem child_required_sub_622_i0 : ∀ j, childrenC_622_i0 j ⊆ insert (3, 6) required_622_i0 := by decide +kernel +theorem child_envelope_sub_622_i0 : ∀ j, childrenD_622_i0 j ⊆ envelope_622_i0 := by decide +kernel +theorem pivot_mem_622_i0 : (3, 6) ∈ envelope_622_i0 := by decide +kernel +theorem children_work_622_i0 : ∀ j, Template HasSnaky 4 (childrenC_622_i0 j) (childrenD_622_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_41 2 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_56 7 (6, 6)).mono (by decide +kernel) +theorem row_works_622_i0 : Template HasSnaky 5 required_622_i0 envelope_622_i0 := by + refine compose HasSnaky 4 childrenC_622_i0 childrenD_622_i0 children_work_622_i0 (3, 6) + required_622_i0 envelope_622_i0 pivot_mem_622_i0 child_required_sub_622_i0 child_envelope_sub_622_i0 ?_ + intro b hb + exact common_sub_622_i0 (mem_commonEnvelope childrenD_622_i0 b hb) +def required_622_i2 : Finset Cell := ⟨(([(2, 2), (3, 3), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_622_i2 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_622_i2 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) required_4), (placed21 2 (4, 3) required_41)] +def childrenD_622_i2 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) envelope_4), (placed21 2 (4, 3) envelope_41)] +theorem common_sub_622_i2 : commonEnvelope childrenD_622_i2 ⊆ insert (3, 6) required_622_i2 := by decide +kernel +theorem child_required_sub_622_i2 : ∀ j, childrenC_622_i2 j ⊆ insert (3, 6) required_622_i2 := by decide +kernel +theorem child_envelope_sub_622_i2 : ∀ j, childrenD_622_i2 j ⊆ envelope_622_i2 := by decide +kernel +theorem pivot_mem_622_i2 : (3, 6) ∈ envelope_622_i2 := by decide +kernel +theorem children_work_622_i2 : ∀ j, Template HasSnaky 4 (childrenC_622_i2 j) (childrenD_622_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_41 2 (4, 3)).mono (by decide +kernel) +theorem row_works_622_i2 : Template HasSnaky 5 required_622_i2 envelope_622_i2 := by + refine compose HasSnaky 4 childrenC_622_i2 childrenD_622_i2 children_work_622_i2 (3, 6) + required_622_i2 envelope_622_i2 pivot_mem_622_i2 child_required_sub_622_i2 child_envelope_sub_622_i2 ?_ + intro b hb + exact common_sub_622_i2 (mem_commonEnvelope childrenD_622_i2 b hb) +def required_622_i3 : Finset Cell := ⟨(([(2, 2), (3, 3), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_622_i3 : Finset Cell := ⟨(([(2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_622_i3 : Fin 2 → Finset Cell := ![(placed21 7 (3, 5) required_5), (placed21 4 (3, 6) required_11)] +def childrenD_622_i3 : Fin 2 → Finset Cell := ![(placed21 7 (3, 5) envelope_5), (placed21 4 (3, 6) envelope_11)] +theorem common_sub_622_i3 : commonEnvelope childrenD_622_i3 ⊆ insert (3, 2) required_622_i3 := by decide +kernel +theorem child_required_sub_622_i3 : ∀ j, childrenC_622_i3 j ⊆ insert (3, 2) required_622_i3 := by decide +kernel +theorem child_envelope_sub_622_i3 : ∀ j, childrenD_622_i3 j ⊆ envelope_622_i3 := by decide +kernel +theorem pivot_mem_622_i3 : (3, 2) ∈ envelope_622_i3 := by decide +kernel +theorem children_work_622_i3 : ∀ j, Template HasSnaky 2 (childrenC_622_i3 j) (childrenD_622_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_11 4 (3, 6)).mono (by decide +kernel) +theorem row_works_622_i3 : Template HasSnaky 3 required_622_i3 envelope_622_i3 := by + refine compose HasSnaky 2 childrenC_622_i3 childrenD_622_i3 children_work_622_i3 (3, 2) + required_622_i3 envelope_622_i3 pivot_mem_622_i3 child_required_sub_622_i3 child_envelope_sub_622_i3 ?_ + intro b hb + exact common_sub_622_i3 (mem_commonEnvelope childrenD_622_i3 b hb) +def required_622_i1 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_622_i1 : Finset Cell := ⟨(([(2, 0), (2, 1), (2, 2), (2, 3), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_622_i1 : Fin 3 → Finset Cell := ![(placed21 6 (3, 6) required_61), required_622_i2, required_622_i3] +def childrenD_622_i1 : Fin 3 → Finset Cell := ![(placed21 6 (3, 6) envelope_61), envelope_622_i2, envelope_622_i3] +theorem common_sub_622_i1 : commonEnvelope childrenD_622_i1 ⊆ insert (2, 2) required_622_i1 := by decide +kernel +theorem child_required_sub_622_i1 : ∀ j, childrenC_622_i1 j ⊆ insert (2, 2) required_622_i1 := by decide +kernel +theorem child_envelope_sub_622_i1 : ∀ j, childrenD_622_i1 j ⊆ envelope_622_i1 := by decide +kernel +theorem pivot_mem_622_i1 : (2, 2) ∈ envelope_622_i1 := by decide +kernel +theorem children_work_622_i1 : ∀ j, Template HasSnaky 5 (childrenC_622_i1 j) (childrenD_622_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_61 6 (3, 6)).mono (by decide +kernel) + · exact row_works_622_i2.mono (by decide +kernel) + · exact row_works_622_i3.mono (by decide +kernel) +theorem row_works_622_i1 : Template HasSnaky 6 required_622_i1 envelope_622_i1 := by + refine compose HasSnaky 5 childrenC_622_i1 childrenD_622_i1 children_work_622_i1 (2, 2) + required_622_i1 envelope_622_i1 pivot_mem_622_i1 child_required_sub_622_i1 child_envelope_sub_622_i1 ?_ + intro b hb + exact common_sub_622_i1 (mem_commonEnvelope childrenD_622_i1 b hb) +def required_622_i4 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_622_i4 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_622_i4 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) required_23), (placed21 2 (7, 1) required_621)] +def childrenD_622_i4 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) envelope_23), (placed21 2 (7, 1) envelope_621)] +theorem common_sub_622_i4 : commonEnvelope childrenD_622_i4 ⊆ insert (4, 5) required_622_i4 := by decide +kernel +theorem child_required_sub_622_i4 : ∀ j, childrenC_622_i4 j ⊆ insert (4, 5) required_622_i4 := by decide +kernel +theorem child_envelope_sub_622_i4 : ∀ j, childrenD_622_i4 j ⊆ envelope_622_i4 := by decide +kernel +theorem pivot_mem_622_i4 : (4, 5) ∈ envelope_622_i4 := by decide +kernel +theorem children_work_622_i4 : ∀ j, Template HasSnaky 7 (childrenC_622_i4 j) (childrenD_622_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_23 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_621 2 (7, 1)).mono (by decide +kernel) +theorem row_works_622_i4 : Template HasSnaky 8 required_622_i4 envelope_622_i4 := by + refine compose HasSnaky 7 childrenC_622_i4 childrenD_622_i4 children_work_622_i4 (4, 5) + required_622_i4 envelope_622_i4 pivot_mem_622_i4 child_required_sub_622_i4 child_envelope_sub_622_i4 ?_ + intro b hb + exact common_sub_622_i4 (mem_commonEnvelope childrenD_622_i4 b hb) +def required_622 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_622 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_622 : Fin 4 → Finset Cell := ![(placed21 7 (6, 6) required_57), required_622_i0, required_622_i1, required_622_i4] +def childrenD_622 : Fin 4 → Finset Cell := ![(placed21 7 (6, 6) envelope_57), envelope_622_i0, envelope_622_i1, envelope_622_i4] +theorem common_sub_622 : commonEnvelope childrenD_622 ⊆ insert (4, 4) required_622 := by decide +kernel +theorem child_required_sub_622 : ∀ j, childrenC_622 j ⊆ insert (4, 4) required_622 := by decide +kernel +theorem child_envelope_sub_622 : ∀ j, childrenD_622 j ⊆ envelope_622 := by decide +kernel +theorem pivot_mem_622 : (4, 4) ∈ envelope_622 := by decide +kernel +theorem children_work_622 : ∀ j, Template HasSnaky 8 (childrenC_622 j) (childrenD_622 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_57 7 (6, 6)).mono (by decide +kernel) + · exact row_works_622_i0.mono (by decide +kernel) + · exact row_works_622_i1.mono (by decide +kernel) + · exact row_works_622_i4.mono (by decide +kernel) +theorem row_works_622 : Template HasSnaky 9 required_622 envelope_622 := by + refine compose HasSnaky 8 childrenC_622 childrenD_622 children_work_622 (4, 4) + required_622 envelope_622 pivot_mem_622 child_required_sub_622 child_envelope_sub_622 ?_ + intro b hb + exact common_sub_622 (mem_commonEnvelope childrenD_622 b hb) +def required_629 : Finset Cell := ⟨(([(3, 3), (3, 4), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_629 : Finset Cell := ⟨(([(0, 5), (0, 6), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (7, 4), (7, 5), (8, 3), (8, 4), (8, 5), (9, 3), (9, 4), (9, 5), (10, 3), (10, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_629 : Fin 5 → Finset Cell := ![(placed21 2 (5, 1) required_190), (placed21 2 (7, 2) required_295), (placed21 2 (6, 1) required_364), required_518, (placed21 4 (2, 7) required_628)] +def childrenD_629 : Fin 5 → Finset Cell := ![(placed21 2 (5, 1) envelope_190), (placed21 2 (7, 2) envelope_295), (placed21 2 (6, 1) envelope_364), envelope_518, (placed21 4 (2, 7) envelope_628)] +theorem common_sub_629 : commonEnvelope childrenD_629 ⊆ insert (3, 5) required_629 := by decide +kernel +theorem child_required_sub_629 : ∀ j, childrenC_629 j ⊆ insert (3, 5) required_629 := by decide +kernel +theorem child_envelope_sub_629 : ∀ j, childrenD_629 j ⊆ envelope_629 := by decide +kernel +theorem pivot_mem_629 : (3, 5) ∈ envelope_629 := by decide +kernel +theorem children_work_629 : ∀ j, Template HasSnaky 8 (childrenC_629 j) (childrenD_629 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_190 2 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_295 2 (7, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_364 2 (6, 1)).mono (by decide +kernel) + · exact row_works_518.mono (by decide +kernel) + · exact (placed21_template row_works_628 4 (2, 7)).mono (by decide +kernel) +theorem row_works_629 : Template HasSnaky 9 required_629 envelope_629 := by + refine compose HasSnaky 8 childrenC_629 childrenD_629 children_work_629 (3, 5) + required_629 envelope_629 pivot_mem_629 child_required_sub_629 child_envelope_sub_629 ?_ + intro b hb + exact common_sub_629 (mem_commonEnvelope childrenD_629 b hb) +def required_638_i0 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_638_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_638_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) required_15), (placed21 4 (1, 7) required_85)] +def childrenD_638_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) envelope_15), (placed21 4 (1, 7) envelope_85)] +theorem common_sub_638_i0 : commonEnvelope childrenD_638_i0 ⊆ insert (3, 4) required_638_i0 := by decide +kernel +theorem child_required_sub_638_i0 : ∀ j, childrenC_638_i0 j ⊆ insert (3, 4) required_638_i0 := by decide +kernel +theorem child_envelope_sub_638_i0 : ∀ j, childrenD_638_i0 j ⊆ envelope_638_i0 := by decide +kernel +theorem pivot_mem_638_i0 : (3, 4) ∈ envelope_638_i0 := by decide +kernel +theorem children_work_638_i0 : ∀ j, Template HasSnaky 6 (childrenC_638_i0 j) (childrenD_638_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_85 4 (1, 7)).mono (by decide +kernel) +theorem row_works_638_i0 : Template HasSnaky 7 required_638_i0 envelope_638_i0 := by + refine compose HasSnaky 6 childrenC_638_i0 childrenD_638_i0 children_work_638_i0 (3, 4) + required_638_i0 envelope_638_i0 pivot_mem_638_i0 child_required_sub_638_i0 child_envelope_sub_638_i0 ?_ + intro b hb + exact common_sub_638_i0 (mem_commonEnvelope childrenD_638_i0 b hb) +def required_638 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_638 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (6, 2), (6, 3), (6, 4), (6, 5), (7, 2), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_638 : Fin 6 → Finset Cell := ![(placed21 4 (0, 6) required_57), (placed21 3 (0, 5) required_136), (placed21 3 (0, 5) required_217), (placed21 0 (1, 0) required_530), required_638_i0, (placed21 0 (0, 1) required_637)] +def childrenD_638 : Fin 6 → Finset Cell := ![(placed21 4 (0, 6) envelope_57), (placed21 3 (0, 5) envelope_136), (placed21 3 (0, 5) envelope_217), (placed21 0 (1, 0) envelope_530), envelope_638_i0, (placed21 0 (0, 1) envelope_637)] +theorem common_sub_638 : commonEnvelope childrenD_638 ⊆ insert (3, 3) required_638 := by decide +kernel +theorem child_required_sub_638 : ∀ j, childrenC_638 j ⊆ insert (3, 3) required_638 := by decide +kernel +theorem child_envelope_sub_638 : ∀ j, childrenD_638 j ⊆ envelope_638 := by decide +kernel +theorem pivot_mem_638 : (3, 3) ∈ envelope_638 := by decide +kernel +theorem children_work_638 : ∀ j, Template HasSnaky 8 (childrenC_638 j) (childrenD_638 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_57 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_136 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_217 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_530 0 (1, 0)).mono (by decide +kernel) + · exact row_works_638_i0.mono (by decide +kernel) + · exact (placed21_template row_works_637 0 (0, 1)).mono (by decide +kernel) +theorem row_works_638 : Template HasSnaky 9 required_638 envelope_638 := by + refine compose HasSnaky 8 childrenC_638 childrenD_638 children_work_638 (3, 3) + required_638 envelope_638 pivot_mem_638 child_required_sub_638 child_envelope_sub_638 ?_ + intro b hb + exact common_sub_638 (mem_commonEnvelope childrenD_638 b hb) +def required_640_i3 : Finset Cell := ⟨(([(2, 6), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_640_i3 : Finset Cell := ⟨(([(2, 6), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_640_i3 : Fin 2 → Finset Cell := ![(placed21 1 (4, 3) required_5), (placed21 0 (2, 5) required_90)] +def childrenD_640_i3 : Fin 2 → Finset Cell := ![(placed21 1 (4, 3) envelope_5), (placed21 0 (2, 5) envelope_90)] +theorem common_sub_640_i3 : commonEnvelope childrenD_640_i3 ⊆ insert (5, 6) required_640_i3 := by decide +kernel +theorem child_required_sub_640_i3 : ∀ j, childrenC_640_i3 j ⊆ insert (5, 6) required_640_i3 := by decide +kernel +theorem child_envelope_sub_640_i3 : ∀ j, childrenD_640_i3 j ⊆ envelope_640_i3 := by decide +kernel +theorem pivot_mem_640_i3 : (5, 6) ∈ envelope_640_i3 := by decide +kernel +theorem children_work_640_i3 : ∀ j, Template HasSnaky 4 (childrenC_640_i3 j) (childrenD_640_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_90 0 (2, 5)).mono (by decide +kernel) +theorem row_works_640_i3 : Template HasSnaky 5 required_640_i3 envelope_640_i3 := by + refine compose HasSnaky 4 childrenC_640_i3 childrenD_640_i3 children_work_640_i3 (5, 6) + required_640_i3 envelope_640_i3 pivot_mem_640_i3 child_required_sub_640_i3 child_envelope_sub_640_i3 ?_ + intro b hb + exact common_sub_640_i3 (mem_commonEnvelope childrenD_640_i3 b hb) +def required_640_i2 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_640_i2 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_640_i2 : Fin 3 → Finset Cell := ![(placed21 3 (1, 6) required_44), (placed21 5 (5, 3) required_260), required_640_i3] +def childrenD_640_i2 : Fin 3 → Finset Cell := ![(placed21 3 (1, 6) envelope_44), (placed21 5 (5, 3) envelope_260), envelope_640_i3] +theorem common_sub_640_i2 : commonEnvelope childrenD_640_i2 ⊆ insert (2, 6) required_640_i2 := by decide +kernel +theorem child_required_sub_640_i2 : ∀ j, childrenC_640_i2 j ⊆ insert (2, 6) required_640_i2 := by decide +kernel +theorem child_envelope_sub_640_i2 : ∀ j, childrenD_640_i2 j ⊆ envelope_640_i2 := by decide +kernel +theorem pivot_mem_640_i2 : (2, 6) ∈ envelope_640_i2 := by decide +kernel +theorem children_work_640_i2 : ∀ j, Template HasSnaky 5 (childrenC_640_i2 j) (childrenD_640_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_260 5 (5, 3)).mono (by decide +kernel) + · exact row_works_640_i3.mono (by decide +kernel) +theorem row_works_640_i2 : Template HasSnaky 6 required_640_i2 envelope_640_i2 := by + refine compose HasSnaky 5 childrenC_640_i2 childrenD_640_i2 children_work_640_i2 (2, 6) + required_640_i2 envelope_640_i2 pivot_mem_640_i2 child_required_sub_640_i2 child_envelope_sub_640_i2 ?_ + intro b hb + exact common_sub_640_i2 (mem_commonEnvelope childrenD_640_i2 b hb) +def required_640_i1 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 6), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_640_i1 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_640_i1 : Fin 2 → Finset Cell := ![(placed21 5 (4, 3) required_5), required_640_i2] +def childrenD_640_i1 : Fin 2 → Finset Cell := ![(placed21 5 (4, 3) envelope_5), envelope_640_i2] +theorem common_sub_640_i1 : commonEnvelope childrenD_640_i1 ⊆ insert (4, 6) required_640_i1 := by decide +kernel +theorem child_required_sub_640_i1 : ∀ j, childrenC_640_i1 j ⊆ insert (4, 6) required_640_i1 := by decide +kernel +theorem child_envelope_sub_640_i1 : ∀ j, childrenD_640_i1 j ⊆ envelope_640_i1 := by decide +kernel +theorem pivot_mem_640_i1 : (4, 6) ∈ envelope_640_i1 := by decide +kernel +theorem children_work_640_i1 : ∀ j, Template HasSnaky 6 (childrenC_640_i1 j) (childrenD_640_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (4, 3)).mono (by decide +kernel) + · exact row_works_640_i2.mono (by decide +kernel) +theorem row_works_640_i1 : Template HasSnaky 7 required_640_i1 envelope_640_i1 := by + refine compose HasSnaky 6 childrenC_640_i1 childrenD_640_i1 children_work_640_i1 (4, 6) + required_640_i1 envelope_640_i1 pivot_mem_640_i1 child_required_sub_640_i1 child_envelope_sub_640_i1 ?_ + intro b hb + exact common_sub_640_i1 (mem_commonEnvelope childrenD_640_i1 b hb) +def required_640_i0 : Finset Cell := ⟨(([(2, 3), (2, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_640_i0 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_640_i0 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) required_61), (placed21 4 (3, 6) required_89), (placed21 5 (6, 2) required_183), required_640_i1] +def childrenD_640_i0 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) envelope_61), (placed21 4 (3, 6) envelope_89), (placed21 5 (6, 2) envelope_183), envelope_640_i1] +theorem common_sub_640_i0 : commonEnvelope childrenD_640_i0 ⊆ insert (3, 6) required_640_i0 := by decide +kernel +theorem child_required_sub_640_i0 : ∀ j, childrenC_640_i0 j ⊆ insert (3, 6) required_640_i0 := by decide +kernel +theorem child_envelope_sub_640_i0 : ∀ j, childrenD_640_i0 j ⊆ envelope_640_i0 := by decide +kernel +theorem pivot_mem_640_i0 : (3, 6) ∈ envelope_640_i0 := by decide +kernel +theorem children_work_640_i0 : ∀ j, Template HasSnaky 7 (childrenC_640_i0 j) (childrenD_640_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_61 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_89 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_183 5 (6, 2)).mono (by decide +kernel) + · exact row_works_640_i1.mono (by decide +kernel) +theorem row_works_640_i0 : Template HasSnaky 8 required_640_i0 envelope_640_i0 := by + refine compose HasSnaky 7 childrenC_640_i0 childrenD_640_i0 children_work_640_i0 (3, 6) + required_640_i0 envelope_640_i0 pivot_mem_640_i0 child_required_sub_640_i0 child_envelope_sub_640_i0 ?_ + intro b hb + exact common_sub_640_i0 (mem_commonEnvelope childrenD_640_i0 b hb) +def required_640 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_640 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 5), (6, 6), (6, 7), (7, 2), (7, 5), (7, 6), (7, 7), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_640 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) required_10), (placed21 3 (2, 6) required_47), (placed21 6 (4, 6) required_52), required_640_i0] +def childrenD_640 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) envelope_10), (placed21 3 (2, 6) envelope_47), (placed21 6 (4, 6) envelope_52), envelope_640_i0] +theorem common_sub_640 : commonEnvelope childrenD_640 ⊆ insert (4, 5) required_640 := by decide +kernel +theorem child_required_sub_640 : ∀ j, childrenC_640 j ⊆ insert (4, 5) required_640 := by decide +kernel +theorem child_envelope_sub_640 : ∀ j, childrenD_640 j ⊆ envelope_640 := by decide +kernel +theorem pivot_mem_640 : (4, 5) ∈ envelope_640 := by decide +kernel +theorem children_work_640 : ∀ j, Template HasSnaky 8 (childrenC_640 j) (childrenD_640 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_47 3 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (4, 6)).mono (by decide +kernel) + · exact row_works_640_i0.mono (by decide +kernel) +theorem row_works_640 : Template HasSnaky 9 required_640 envelope_640 := by + refine compose HasSnaky 8 childrenC_640 childrenD_640 children_work_640 (4, 5) + required_640 envelope_640 pivot_mem_640 child_required_sub_640 child_envelope_sub_640 ?_ + intro b hb + exact common_sub_640 (mem_commonEnvelope childrenD_640 b hb) +def required_655_i0 : Finset Cell := ⟨(([(2, 5), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_655_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 7), (4, 8), (4, 9), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_655_i0 : Fin 3 → Finset Cell := ![(placed21 5 (5, 2) required_179), (placed21 1 (2, 3) required_314), (placed21 7 (5, 7) required_344)] +def childrenD_655_i0 : Fin 3 → Finset Cell := ![(placed21 5 (5, 2) envelope_179), (placed21 1 (2, 3) envelope_314), (placed21 7 (5, 7) envelope_344)] +theorem common_sub_655_i0 : commonEnvelope childrenD_655_i0 ⊆ insert (3, 6) required_655_i0 := by decide +kernel +theorem child_required_sub_655_i0 : ∀ j, childrenC_655_i0 j ⊆ insert (3, 6) required_655_i0 := by decide +kernel +theorem child_envelope_sub_655_i0 : ∀ j, childrenD_655_i0 j ⊆ envelope_655_i0 := by decide +kernel +theorem pivot_mem_655_i0 : (3, 6) ∈ envelope_655_i0 := by decide +kernel +theorem children_work_655_i0 : ∀ j, Template HasSnaky 7 (childrenC_655_i0 j) (childrenD_655_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_179 5 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_314 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_344 7 (5, 7)).mono (by decide +kernel) +theorem row_works_655_i0 : Template HasSnaky 8 required_655_i0 envelope_655_i0 := by + refine compose HasSnaky 7 childrenC_655_i0 childrenD_655_i0 children_work_655_i0 (3, 6) + required_655_i0 envelope_655_i0 pivot_mem_655_i0 child_required_sub_655_i0 child_envelope_sub_655_i0 ?_ + intro b hb + exact common_sub_655_i0 (mem_commonEnvelope childrenD_655_i0 b hb) +def required_655 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_655 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 7), (4, 8), (4, 9), (5, 2), (5, 4), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_655 : Fin 4 → Finset Cell := ![(placed21 4 (2, 6) required_10), (placed21 2 (3, 2) required_52), (placed21 7 (6, 6) required_435), required_655_i0] +def childrenD_655 : Fin 4 → Finset Cell := ![(placed21 4 (2, 6) envelope_10), (placed21 2 (3, 2) envelope_52), (placed21 7 (6, 6) envelope_435), envelope_655_i0] +theorem common_sub_655 : commonEnvelope childrenD_655 ⊆ insert (3, 3) required_655 := by decide +kernel +theorem child_required_sub_655 : ∀ j, childrenC_655 j ⊆ insert (3, 3) required_655 := by decide +kernel +theorem child_envelope_sub_655 : ∀ j, childrenD_655 j ⊆ envelope_655 := by decide +kernel +theorem pivot_mem_655 : (3, 3) ∈ envelope_655 := by decide +kernel +theorem children_work_655 : ∀ j, Template HasSnaky 8 (childrenC_655 j) (childrenD_655 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 4 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_435 7 (6, 6)).mono (by decide +kernel) + · exact row_works_655_i0.mono (by decide +kernel) +theorem row_works_655 : Template HasSnaky 9 required_655 envelope_655 := by + refine compose HasSnaky 8 childrenC_655 childrenD_655 children_work_655 (3, 3) + required_655 envelope_655 pivot_mem_655 child_required_sub_655 child_envelope_sub_655 ?_ + intro b hb + exact common_sub_655 (mem_commonEnvelope childrenD_655 b hb) +def required_659 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (2, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_659 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_659 : Fin 2 → Finset Cell := ![(placed21 4 (0, 5) required_5), (placed21 0 (1, 0) required_658)] +def childrenD_659 : Fin 2 → Finset Cell := ![(placed21 4 (0, 5) envelope_5), (placed21 0 (1, 0) envelope_658)] +theorem common_sub_659 : commonEnvelope childrenD_659 ⊆ insert (3, 4) required_659 := by decide +kernel +theorem child_required_sub_659 : ∀ j, childrenC_659 j ⊆ insert (3, 4) required_659 := by decide +kernel +theorem child_envelope_sub_659 : ∀ j, childrenD_659 j ⊆ envelope_659 := by decide +kernel +theorem pivot_mem_659 : (3, 4) ∈ envelope_659 := by decide +kernel +theorem children_work_659 : ∀ j, Template HasSnaky 8 (childrenC_659 j) (childrenD_659 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_658 0 (1, 0)).mono (by decide +kernel) +theorem row_works_659 : Template HasSnaky 9 required_659 envelope_659 := by + refine compose HasSnaky 8 childrenC_659 childrenD_659 children_work_659 (3, 4) + required_659 envelope_659 pivot_mem_659 child_required_sub_659 child_envelope_sub_659 ?_ + intro b hb + exact common_sub_659 (mem_commonEnvelope childrenD_659 b hb) +def required_662_i0 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_662_i0 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 5), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_662_i0 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) required_5), (placed21 2 (4, 2) required_141)] +def childrenD_662_i0 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) envelope_5), (placed21 2 (4, 2) envelope_141)] +theorem common_sub_662_i0 : commonEnvelope childrenD_662_i0 ⊆ insert (1, 5) required_662_i0 := by decide +kernel +theorem child_required_sub_662_i0 : ∀ j, childrenC_662_i0 j ⊆ insert (1, 5) required_662_i0 := by decide +kernel +theorem child_envelope_sub_662_i0 : ∀ j, childrenD_662_i0 j ⊆ envelope_662_i0 := by decide +kernel +theorem pivot_mem_662_i0 : (1, 5) ∈ envelope_662_i0 := by decide +kernel +theorem children_work_662_i0 : ∀ j, Template HasSnaky 4 (childrenC_662_i0 j) (childrenD_662_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_141 2 (4, 2)).mono (by decide +kernel) +theorem row_works_662_i0 : Template HasSnaky 5 required_662_i0 envelope_662_i0 := by + refine compose HasSnaky 4 childrenC_662_i0 childrenD_662_i0 children_work_662_i0 (1, 5) + required_662_i0 envelope_662_i0 pivot_mem_662_i0 child_required_sub_662_i0 child_envelope_sub_662_i0 ?_ + intro b hb + exact common_sub_662_i0 (mem_commonEnvelope childrenD_662_i0 b hb) +def required_662 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_662 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4), (8, 2), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_662 : Fin 3 → Finset Cell := ![(placed21 3 (1, 5) required_52), (placed21 0 (2, 0) required_658), required_662_i0] +def childrenD_662 : Fin 3 → Finset Cell := ![(placed21 3 (1, 5) envelope_52), (placed21 0 (2, 0) envelope_658), envelope_662_i0] +theorem common_sub_662 : commonEnvelope childrenD_662 ⊆ insert (4, 4) required_662 := by decide +kernel +theorem child_required_sub_662 : ∀ j, childrenC_662 j ⊆ insert (4, 4) required_662 := by decide +kernel +theorem child_envelope_sub_662 : ∀ j, childrenD_662 j ⊆ envelope_662 := by decide +kernel +theorem pivot_mem_662 : (4, 4) ∈ envelope_662 := by decide +kernel +theorem children_work_662 : ∀ j, Template HasSnaky 8 (childrenC_662 j) (childrenD_662 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_658 0 (2, 0)).mono (by decide +kernel) + · exact row_works_662_i0.mono (by decide +kernel) +theorem row_works_662 : Template HasSnaky 9 required_662 envelope_662 := by + refine compose HasSnaky 8 childrenC_662 childrenD_662 children_work_662 (4, 4) + required_662 envelope_662 pivot_mem_662 child_required_sub_662 child_envelope_sub_662 ?_ + intro b hb + exact common_sub_662 (mem_commonEnvelope childrenD_662 b hb) +def required_667 : Finset Cell := ⟨(([(0, 3), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_667 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5), (8, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_667 : Fin 3 → Finset Cell := ![(placed21 0 (3, 0) required_7), (placed21 2 (4, 0) required_9), (placed21 0 (0, 1) required_666)] +def childrenD_667 : Fin 3 → Finset Cell := ![(placed21 0 (3, 0) envelope_7), (placed21 2 (4, 0) envelope_9), (placed21 0 (0, 1) envelope_666)] +theorem common_sub_667 : commonEnvelope childrenD_667 ⊆ insert (3, 4) required_667 := by decide +kernel +theorem child_required_sub_667 : ∀ j, childrenC_667 j ⊆ insert (3, 4) required_667 := by decide +kernel +theorem child_envelope_sub_667 : ∀ j, childrenD_667 j ⊆ envelope_667 := by decide +kernel +theorem pivot_mem_667 : (3, 4) ∈ envelope_667 := by decide +kernel +theorem children_work_667 : ∀ j, Template HasSnaky 8 (childrenC_667 j) (childrenD_667 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_666 0 (0, 1)).mono (by decide +kernel) +theorem row_works_667 : Template HasSnaky 9 required_667 envelope_667 := by + refine compose HasSnaky 8 childrenC_667 childrenD_667 children_work_667 (3, 4) + required_667 envelope_667 pivot_mem_667 child_required_sub_667 child_envelope_sub_667 ?_ + intro b hb + exact common_sub_667 (mem_commonEnvelope childrenD_667 b hb) +def required_668 : Finset Cell := ⟨(([(0, 3), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_668 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5), (8, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_668 : Fin 3 → Finset Cell := ![(placed21 2 (3, 0) required_7), (placed21 0 (2, 0) required_9), (placed21 0 (0, 1) required_666)] +def childrenD_668 : Fin 3 → Finset Cell := ![(placed21 2 (3, 0) envelope_7), (placed21 0 (2, 0) envelope_9), (placed21 0 (0, 1) envelope_666)] +theorem common_sub_668 : commonEnvelope childrenD_668 ⊆ insert (3, 4) required_668 := by decide +kernel +theorem child_required_sub_668 : ∀ j, childrenC_668 j ⊆ insert (3, 4) required_668 := by decide +kernel +theorem child_envelope_sub_668 : ∀ j, childrenD_668 j ⊆ envelope_668 := by decide +kernel +theorem pivot_mem_668 : (3, 4) ∈ envelope_668 := by decide +kernel +theorem children_work_668 : ∀ j, Template HasSnaky 8 (childrenC_668 j) (childrenD_668 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_9 0 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_666 0 (0, 1)).mono (by decide +kernel) +theorem row_works_668 : Template HasSnaky 9 required_668 envelope_668 := by + refine compose HasSnaky 8 childrenC_668 childrenD_668 children_work_668 (3, 4) + required_668 envelope_668 pivot_mem_668 child_required_sub_668 child_envelope_sub_668 ?_ + intro b hb + exact common_sub_668 (mem_commonEnvelope childrenD_668 b hb) +def height_622_i0 : ℕ := 5 +def childrenH_622_i0 : Fin 2 → ℕ := ![height_41, height_56] +theorem height_exact_622_i0 : height_622_i0 = 1 + Finset.univ.sup childrenH_622_i0 := by decide +kernel +theorem required_origin_622_i0 : ∀ x ∈ required_622_i0, + (∃ j, x ∈ childrenC_622_i0 j) ∨ ∀ j, x ∈ childrenD_622_i0 j := by decide +kernel +theorem required_exact_622_i0 : required_622_i0 = + ((Finset.univ.biUnion childrenC_622_i0) ∪ commonEnvelope childrenD_622_i0).erase (3, 6) := by + exact required_eq_combination childrenC_622_i0 childrenD_622_i0 (3, 6) required_622_i0 + (by decide +kernel) child_required_sub_622_i0 common_sub_622_i0 required_origin_622_i0 +theorem envelope_origin_622_i0 : ∀ x ∈ envelope_622_i0, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_622_i0 j := by decide +kernel +theorem envelope_exact_622_i0 : envelope_622_i0 = + insert (3, 6) (Finset.univ.biUnion childrenD_622_i0) := by + exact envelope_eq_combination childrenD_622_i0 (3, 6) envelope_622_i0 + pivot_mem_622_i0 child_envelope_sub_622_i0 envelope_origin_622_i0 +def checked_622_i0 : CheckedCard where + required := required_622_i0 + envelope := envelope_622_i0 + height := height_622_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_622_i0 +def height_622_i2 : ℕ := 5 +def childrenH_622_i2 : Fin 2 → ℕ := ![height_4, height_41] +theorem height_exact_622_i2 : height_622_i2 = 1 + Finset.univ.sup childrenH_622_i2 := by decide +kernel +theorem required_origin_622_i2 : ∀ x ∈ required_622_i2, + (∃ j, x ∈ childrenC_622_i2 j) ∨ ∀ j, x ∈ childrenD_622_i2 j := by decide +kernel +theorem required_exact_622_i2 : required_622_i2 = + ((Finset.univ.biUnion childrenC_622_i2) ∪ commonEnvelope childrenD_622_i2).erase (3, 6) := by + exact required_eq_combination childrenC_622_i2 childrenD_622_i2 (3, 6) required_622_i2 + (by decide +kernel) child_required_sub_622_i2 common_sub_622_i2 required_origin_622_i2 +theorem envelope_origin_622_i2 : ∀ x ∈ envelope_622_i2, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_622_i2 j := by decide +kernel +theorem envelope_exact_622_i2 : envelope_622_i2 = + insert (3, 6) (Finset.univ.biUnion childrenD_622_i2) := by + exact envelope_eq_combination childrenD_622_i2 (3, 6) envelope_622_i2 + pivot_mem_622_i2 child_envelope_sub_622_i2 envelope_origin_622_i2 +def checked_622_i2 : CheckedCard where + required := required_622_i2 + envelope := envelope_622_i2 + height := height_622_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_622_i2 +def height_622_i3 : ℕ := 3 +def childrenH_622_i3 : Fin 2 → ℕ := ![height_5, height_11] +theorem height_exact_622_i3 : height_622_i3 = 1 + Finset.univ.sup childrenH_622_i3 := by decide +kernel +theorem required_origin_622_i3 : ∀ x ∈ required_622_i3, + (∃ j, x ∈ childrenC_622_i3 j) ∨ ∀ j, x ∈ childrenD_622_i3 j := by decide +kernel +theorem required_exact_622_i3 : required_622_i3 = + ((Finset.univ.biUnion childrenC_622_i3) ∪ commonEnvelope childrenD_622_i3).erase (3, 2) := by + exact required_eq_combination childrenC_622_i3 childrenD_622_i3 (3, 2) required_622_i3 + (by decide +kernel) child_required_sub_622_i3 common_sub_622_i3 required_origin_622_i3 +theorem envelope_origin_622_i3 : ∀ x ∈ envelope_622_i3, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_622_i3 j := by decide +kernel +theorem envelope_exact_622_i3 : envelope_622_i3 = + insert (3, 2) (Finset.univ.biUnion childrenD_622_i3) := by + exact envelope_eq_combination childrenD_622_i3 (3, 2) envelope_622_i3 + pivot_mem_622_i3 child_envelope_sub_622_i3 envelope_origin_622_i3 +def checked_622_i3 : CheckedCard where + required := required_622_i3 + envelope := envelope_622_i3 + height := height_622_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_622_i3 +def height_622_i1 : ℕ := 6 +def childrenH_622_i1 : Fin 3 → ℕ := ![height_61, height_622_i2, height_622_i3] +theorem height_exact_622_i1 : height_622_i1 = 1 + Finset.univ.sup childrenH_622_i1 := by decide +kernel +theorem required_origin_622_i1 : ∀ x ∈ required_622_i1, + (∃ j, x ∈ childrenC_622_i1 j) ∨ ∀ j, x ∈ childrenD_622_i1 j := by decide +kernel +theorem required_exact_622_i1 : required_622_i1 = + ((Finset.univ.biUnion childrenC_622_i1) ∪ commonEnvelope childrenD_622_i1).erase (2, 2) := by + exact required_eq_combination childrenC_622_i1 childrenD_622_i1 (2, 2) required_622_i1 + (by decide +kernel) child_required_sub_622_i1 common_sub_622_i1 required_origin_622_i1 +theorem envelope_origin_622_i1 : ∀ x ∈ envelope_622_i1, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_622_i1 j := by decide +kernel +theorem envelope_exact_622_i1 : envelope_622_i1 = + insert (2, 2) (Finset.univ.biUnion childrenD_622_i1) := by + exact envelope_eq_combination childrenD_622_i1 (2, 2) envelope_622_i1 + pivot_mem_622_i1 child_envelope_sub_622_i1 envelope_origin_622_i1 +def checked_622_i1 : CheckedCard where + required := required_622_i1 + envelope := envelope_622_i1 + height := height_622_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_622_i1 +def height_622_i4 : ℕ := 8 +def childrenH_622_i4 : Fin 2 → ℕ := ![height_23, height_621] +theorem height_exact_622_i4 : height_622_i4 = 1 + Finset.univ.sup childrenH_622_i4 := by decide +kernel +theorem required_origin_622_i4 : ∀ x ∈ required_622_i4, + (∃ j, x ∈ childrenC_622_i4 j) ∨ ∀ j, x ∈ childrenD_622_i4 j := by decide +kernel +theorem required_exact_622_i4 : required_622_i4 = + ((Finset.univ.biUnion childrenC_622_i4) ∪ commonEnvelope childrenD_622_i4).erase (4, 5) := by + exact required_eq_combination childrenC_622_i4 childrenD_622_i4 (4, 5) required_622_i4 + (by decide +kernel) child_required_sub_622_i4 common_sub_622_i4 required_origin_622_i4 +theorem envelope_origin_622_i4 : ∀ x ∈ envelope_622_i4, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_622_i4 j := by decide +kernel +theorem envelope_exact_622_i4 : envelope_622_i4 = + insert (4, 5) (Finset.univ.biUnion childrenD_622_i4) := by + exact envelope_eq_combination childrenD_622_i4 (4, 5) envelope_622_i4 + pivot_mem_622_i4 child_envelope_sub_622_i4 envelope_origin_622_i4 +def checked_622_i4 : CheckedCard where + required := required_622_i4 + envelope := envelope_622_i4 + height := height_622_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_622_i4 +def height_622 : ℕ := 9 +def childrenH_622 : Fin 4 → ℕ := ![height_57, height_622_i0, height_622_i1, height_622_i4] +theorem height_exact_622 : height_622 = 1 + Finset.univ.sup childrenH_622 := by decide +kernel +theorem required_origin_622 : ∀ x ∈ required_622, + (∃ j, x ∈ childrenC_622 j) ∨ ∀ j, x ∈ childrenD_622 j := by decide +kernel +theorem required_exact_622 : required_622 = + ((Finset.univ.biUnion childrenC_622) ∪ commonEnvelope childrenD_622).erase (4, 4) := by + exact required_eq_combination childrenC_622 childrenD_622 (4, 4) required_622 + (by decide +kernel) child_required_sub_622 common_sub_622 required_origin_622 +theorem envelope_origin_622 : ∀ x ∈ envelope_622, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_622 j := by decide +kernel +theorem envelope_exact_622 : envelope_622 = + insert (4, 4) (Finset.univ.biUnion childrenD_622) := by + exact envelope_eq_combination childrenD_622 (4, 4) envelope_622 + pivot_mem_622 child_envelope_sub_622 envelope_origin_622 +def checked_622 : CheckedCard where + required := required_622 + envelope := envelope_622 + height := height_622 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_622 +def height_629 : ℕ := 9 +def childrenH_629 : Fin 5 → ℕ := ![height_190, height_295, height_364, height_518, height_628] +theorem height_exact_629 : height_629 = 1 + Finset.univ.sup childrenH_629 := by decide +kernel +theorem required_origin_629 : ∀ x ∈ required_629, + (∃ j, x ∈ childrenC_629 j) ∨ ∀ j, x ∈ childrenD_629 j := by decide +kernel +theorem required_exact_629 : required_629 = + ((Finset.univ.biUnion childrenC_629) ∪ commonEnvelope childrenD_629).erase (3, 5) := by + exact required_eq_combination childrenC_629 childrenD_629 (3, 5) required_629 + (by decide +kernel) child_required_sub_629 common_sub_629 required_origin_629 +theorem envelope_origin_629 : ∀ x ∈ envelope_629, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_629 j := by decide +kernel +theorem envelope_exact_629 : envelope_629 = + insert (3, 5) (Finset.univ.biUnion childrenD_629) := by + exact envelope_eq_combination childrenD_629 (3, 5) envelope_629 + pivot_mem_629 child_envelope_sub_629 envelope_origin_629 +def checked_629 : CheckedCard where + required := required_629 + envelope := envelope_629 + height := height_629 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_629 +def height_638_i0 : ℕ := 7 +def childrenH_638_i0 : Fin 2 → ℕ := ![height_15, height_85] +theorem height_exact_638_i0 : height_638_i0 = 1 + Finset.univ.sup childrenH_638_i0 := by decide +kernel +theorem required_origin_638_i0 : ∀ x ∈ required_638_i0, + (∃ j, x ∈ childrenC_638_i0 j) ∨ ∀ j, x ∈ childrenD_638_i0 j := by decide +kernel +theorem required_exact_638_i0 : required_638_i0 = + ((Finset.univ.biUnion childrenC_638_i0) ∪ commonEnvelope childrenD_638_i0).erase (3, 4) := by + exact required_eq_combination childrenC_638_i0 childrenD_638_i0 (3, 4) required_638_i0 + (by decide +kernel) child_required_sub_638_i0 common_sub_638_i0 required_origin_638_i0 +theorem envelope_origin_638_i0 : ∀ x ∈ envelope_638_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_638_i0 j := by decide +kernel +theorem envelope_exact_638_i0 : envelope_638_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_638_i0) := by + exact envelope_eq_combination childrenD_638_i0 (3, 4) envelope_638_i0 + pivot_mem_638_i0 child_envelope_sub_638_i0 envelope_origin_638_i0 +def checked_638_i0 : CheckedCard where + required := required_638_i0 + envelope := envelope_638_i0 + height := height_638_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_638_i0 +def height_638 : ℕ := 9 +def childrenH_638 : Fin 6 → ℕ := ![height_57, height_136, height_217, height_530, height_638_i0, height_637] +theorem height_exact_638 : height_638 = 1 + Finset.univ.sup childrenH_638 := by decide +kernel +theorem required_origin_638 : ∀ x ∈ required_638, + (∃ j, x ∈ childrenC_638 j) ∨ ∀ j, x ∈ childrenD_638 j := by decide +kernel +theorem required_exact_638 : required_638 = + ((Finset.univ.biUnion childrenC_638) ∪ commonEnvelope childrenD_638).erase (3, 3) := by + exact required_eq_combination childrenC_638 childrenD_638 (3, 3) required_638 + (by decide +kernel) child_required_sub_638 common_sub_638 required_origin_638 +theorem envelope_origin_638 : ∀ x ∈ envelope_638, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_638 j := by decide +kernel +theorem envelope_exact_638 : envelope_638 = + insert (3, 3) (Finset.univ.biUnion childrenD_638) := by + exact envelope_eq_combination childrenD_638 (3, 3) envelope_638 + pivot_mem_638 child_envelope_sub_638 envelope_origin_638 +def checked_638 : CheckedCard where + required := required_638 + envelope := envelope_638 + height := height_638 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_638 +def height_640_i3 : ℕ := 5 +def childrenH_640_i3 : Fin 2 → ℕ := ![height_5, height_90] +theorem height_exact_640_i3 : height_640_i3 = 1 + Finset.univ.sup childrenH_640_i3 := by decide +kernel +theorem required_origin_640_i3 : ∀ x ∈ required_640_i3, + (∃ j, x ∈ childrenC_640_i3 j) ∨ ∀ j, x ∈ childrenD_640_i3 j := by decide +kernel +theorem required_exact_640_i3 : required_640_i3 = + ((Finset.univ.biUnion childrenC_640_i3) ∪ commonEnvelope childrenD_640_i3).erase (5, 6) := by + exact required_eq_combination childrenC_640_i3 childrenD_640_i3 (5, 6) required_640_i3 + (by decide +kernel) child_required_sub_640_i3 common_sub_640_i3 required_origin_640_i3 +theorem envelope_origin_640_i3 : ∀ x ∈ envelope_640_i3, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_640_i3 j := by decide +kernel +theorem envelope_exact_640_i3 : envelope_640_i3 = + insert (5, 6) (Finset.univ.biUnion childrenD_640_i3) := by + exact envelope_eq_combination childrenD_640_i3 (5, 6) envelope_640_i3 + pivot_mem_640_i3 child_envelope_sub_640_i3 envelope_origin_640_i3 +def checked_640_i3 : CheckedCard where + required := required_640_i3 + envelope := envelope_640_i3 + height := height_640_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_640_i3 +def height_640_i2 : ℕ := 6 +def childrenH_640_i2 : Fin 3 → ℕ := ![height_44, height_260, height_640_i3] +theorem height_exact_640_i2 : height_640_i2 = 1 + Finset.univ.sup childrenH_640_i2 := by decide +kernel +theorem required_origin_640_i2 : ∀ x ∈ required_640_i2, + (∃ j, x ∈ childrenC_640_i2 j) ∨ ∀ j, x ∈ childrenD_640_i2 j := by decide +kernel +theorem required_exact_640_i2 : required_640_i2 = + ((Finset.univ.biUnion childrenC_640_i2) ∪ commonEnvelope childrenD_640_i2).erase (2, 6) := by + exact required_eq_combination childrenC_640_i2 childrenD_640_i2 (2, 6) required_640_i2 + (by decide +kernel) child_required_sub_640_i2 common_sub_640_i2 required_origin_640_i2 +theorem envelope_origin_640_i2 : ∀ x ∈ envelope_640_i2, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_640_i2 j := by decide +kernel +theorem envelope_exact_640_i2 : envelope_640_i2 = + insert (2, 6) (Finset.univ.biUnion childrenD_640_i2) := by + exact envelope_eq_combination childrenD_640_i2 (2, 6) envelope_640_i2 + pivot_mem_640_i2 child_envelope_sub_640_i2 envelope_origin_640_i2 +def checked_640_i2 : CheckedCard where + required := required_640_i2 + envelope := envelope_640_i2 + height := height_640_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_640_i2 +def height_640_i1 : ℕ := 7 +def childrenH_640_i1 : Fin 2 → ℕ := ![height_5, height_640_i2] +theorem height_exact_640_i1 : height_640_i1 = 1 + Finset.univ.sup childrenH_640_i1 := by decide +kernel +theorem required_origin_640_i1 : ∀ x ∈ required_640_i1, + (∃ j, x ∈ childrenC_640_i1 j) ∨ ∀ j, x ∈ childrenD_640_i1 j := by decide +kernel +theorem required_exact_640_i1 : required_640_i1 = + ((Finset.univ.biUnion childrenC_640_i1) ∪ commonEnvelope childrenD_640_i1).erase (4, 6) := by + exact required_eq_combination childrenC_640_i1 childrenD_640_i1 (4, 6) required_640_i1 + (by decide +kernel) child_required_sub_640_i1 common_sub_640_i1 required_origin_640_i1 +theorem envelope_origin_640_i1 : ∀ x ∈ envelope_640_i1, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_640_i1 j := by decide +kernel +theorem envelope_exact_640_i1 : envelope_640_i1 = + insert (4, 6) (Finset.univ.biUnion childrenD_640_i1) := by + exact envelope_eq_combination childrenD_640_i1 (4, 6) envelope_640_i1 + pivot_mem_640_i1 child_envelope_sub_640_i1 envelope_origin_640_i1 +def checked_640_i1 : CheckedCard where + required := required_640_i1 + envelope := envelope_640_i1 + height := height_640_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_640_i1 +def height_640_i0 : ℕ := 8 +def childrenH_640_i0 : Fin 4 → ℕ := ![height_61, height_89, height_183, height_640_i1] +theorem height_exact_640_i0 : height_640_i0 = 1 + Finset.univ.sup childrenH_640_i0 := by decide +kernel +theorem required_origin_640_i0 : ∀ x ∈ required_640_i0, + (∃ j, x ∈ childrenC_640_i0 j) ∨ ∀ j, x ∈ childrenD_640_i0 j := by decide +kernel +theorem required_exact_640_i0 : required_640_i0 = + ((Finset.univ.biUnion childrenC_640_i0) ∪ commonEnvelope childrenD_640_i0).erase (3, 6) := by + exact required_eq_combination childrenC_640_i0 childrenD_640_i0 (3, 6) required_640_i0 + (by decide +kernel) child_required_sub_640_i0 common_sub_640_i0 required_origin_640_i0 +theorem envelope_origin_640_i0 : ∀ x ∈ envelope_640_i0, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_640_i0 j := by decide +kernel +theorem envelope_exact_640_i0 : envelope_640_i0 = + insert (3, 6) (Finset.univ.biUnion childrenD_640_i0) := by + exact envelope_eq_combination childrenD_640_i0 (3, 6) envelope_640_i0 + pivot_mem_640_i0 child_envelope_sub_640_i0 envelope_origin_640_i0 +def checked_640_i0 : CheckedCard where + required := required_640_i0 + envelope := envelope_640_i0 + height := height_640_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_640_i0 +def height_640 : ℕ := 9 +def childrenH_640 : Fin 4 → ℕ := ![height_10, height_47, height_52, height_640_i0] +theorem height_exact_640 : height_640 = 1 + Finset.univ.sup childrenH_640 := by decide +kernel +theorem required_origin_640 : ∀ x ∈ required_640, + (∃ j, x ∈ childrenC_640 j) ∨ ∀ j, x ∈ childrenD_640 j := by decide +kernel +theorem required_exact_640 : required_640 = + ((Finset.univ.biUnion childrenC_640) ∪ commonEnvelope childrenD_640).erase (4, 5) := by + exact required_eq_combination childrenC_640 childrenD_640 (4, 5) required_640 + (by decide +kernel) child_required_sub_640 common_sub_640 required_origin_640 +theorem envelope_origin_640 : ∀ x ∈ envelope_640, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_640 j := by decide +kernel +theorem envelope_exact_640 : envelope_640 = + insert (4, 5) (Finset.univ.biUnion childrenD_640) := by + exact envelope_eq_combination childrenD_640 (4, 5) envelope_640 + pivot_mem_640 child_envelope_sub_640 envelope_origin_640 +def checked_640 : CheckedCard where + required := required_640 + envelope := envelope_640 + height := height_640 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_640 +def height_655_i0 : ℕ := 8 +def childrenH_655_i0 : Fin 3 → ℕ := ![height_179, height_314, height_344] +theorem height_exact_655_i0 : height_655_i0 = 1 + Finset.univ.sup childrenH_655_i0 := by decide +kernel +theorem required_origin_655_i0 : ∀ x ∈ required_655_i0, + (∃ j, x ∈ childrenC_655_i0 j) ∨ ∀ j, x ∈ childrenD_655_i0 j := by decide +kernel +theorem required_exact_655_i0 : required_655_i0 = + ((Finset.univ.biUnion childrenC_655_i0) ∪ commonEnvelope childrenD_655_i0).erase (3, 6) := by + exact required_eq_combination childrenC_655_i0 childrenD_655_i0 (3, 6) required_655_i0 + (by decide +kernel) child_required_sub_655_i0 common_sub_655_i0 required_origin_655_i0 +theorem envelope_origin_655_i0 : ∀ x ∈ envelope_655_i0, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_655_i0 j := by decide +kernel +theorem envelope_exact_655_i0 : envelope_655_i0 = + insert (3, 6) (Finset.univ.biUnion childrenD_655_i0) := by + exact envelope_eq_combination childrenD_655_i0 (3, 6) envelope_655_i0 + pivot_mem_655_i0 child_envelope_sub_655_i0 envelope_origin_655_i0 +def checked_655_i0 : CheckedCard where + required := required_655_i0 + envelope := envelope_655_i0 + height := height_655_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_655_i0 +def height_655 : ℕ := 9 +def childrenH_655 : Fin 4 → ℕ := ![height_10, height_52, height_435, height_655_i0] +theorem height_exact_655 : height_655 = 1 + Finset.univ.sup childrenH_655 := by decide +kernel +theorem required_origin_655 : ∀ x ∈ required_655, + (∃ j, x ∈ childrenC_655 j) ∨ ∀ j, x ∈ childrenD_655 j := by decide +kernel +theorem required_exact_655 : required_655 = + ((Finset.univ.biUnion childrenC_655) ∪ commonEnvelope childrenD_655).erase (3, 3) := by + exact required_eq_combination childrenC_655 childrenD_655 (3, 3) required_655 + (by decide +kernel) child_required_sub_655 common_sub_655 required_origin_655 +theorem envelope_origin_655 : ∀ x ∈ envelope_655, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_655 j := by decide +kernel +theorem envelope_exact_655 : envelope_655 = + insert (3, 3) (Finset.univ.biUnion childrenD_655) := by + exact envelope_eq_combination childrenD_655 (3, 3) envelope_655 + pivot_mem_655 child_envelope_sub_655 envelope_origin_655 +def checked_655 : CheckedCard where + required := required_655 + envelope := envelope_655 + height := height_655 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_655 +def height_659 : ℕ := 9 +def childrenH_659 : Fin 2 → ℕ := ![height_5, height_658] +theorem height_exact_659 : height_659 = 1 + Finset.univ.sup childrenH_659 := by decide +kernel +theorem required_origin_659 : ∀ x ∈ required_659, + (∃ j, x ∈ childrenC_659 j) ∨ ∀ j, x ∈ childrenD_659 j := by decide +kernel +theorem required_exact_659 : required_659 = + ((Finset.univ.biUnion childrenC_659) ∪ commonEnvelope childrenD_659).erase (3, 4) := by + exact required_eq_combination childrenC_659 childrenD_659 (3, 4) required_659 + (by decide +kernel) child_required_sub_659 common_sub_659 required_origin_659 +theorem envelope_origin_659 : ∀ x ∈ envelope_659, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_659 j := by decide +kernel +theorem envelope_exact_659 : envelope_659 = + insert (3, 4) (Finset.univ.biUnion childrenD_659) := by + exact envelope_eq_combination childrenD_659 (3, 4) envelope_659 + pivot_mem_659 child_envelope_sub_659 envelope_origin_659 +def checked_659 : CheckedCard where + required := required_659 + envelope := envelope_659 + height := height_659 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_659 +def height_662_i0 : ℕ := 5 +def childrenH_662_i0 : Fin 2 → ℕ := ![height_5, height_141] +theorem height_exact_662_i0 : height_662_i0 = 1 + Finset.univ.sup childrenH_662_i0 := by decide +kernel +theorem required_origin_662_i0 : ∀ x ∈ required_662_i0, + (∃ j, x ∈ childrenC_662_i0 j) ∨ ∀ j, x ∈ childrenD_662_i0 j := by decide +kernel +theorem required_exact_662_i0 : required_662_i0 = + ((Finset.univ.biUnion childrenC_662_i0) ∪ commonEnvelope childrenD_662_i0).erase (1, 5) := by + exact required_eq_combination childrenC_662_i0 childrenD_662_i0 (1, 5) required_662_i0 + (by decide +kernel) child_required_sub_662_i0 common_sub_662_i0 required_origin_662_i0 +theorem envelope_origin_662_i0 : ∀ x ∈ envelope_662_i0, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_662_i0 j := by decide +kernel +theorem envelope_exact_662_i0 : envelope_662_i0 = + insert (1, 5) (Finset.univ.biUnion childrenD_662_i0) := by + exact envelope_eq_combination childrenD_662_i0 (1, 5) envelope_662_i0 + pivot_mem_662_i0 child_envelope_sub_662_i0 envelope_origin_662_i0 +def checked_662_i0 : CheckedCard where + required := required_662_i0 + envelope := envelope_662_i0 + height := height_662_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_662_i0 +def height_662 : ℕ := 9 +def childrenH_662 : Fin 3 → ℕ := ![height_52, height_658, height_662_i0] +theorem height_exact_662 : height_662 = 1 + Finset.univ.sup childrenH_662 := by decide +kernel +theorem required_origin_662 : ∀ x ∈ required_662, + (∃ j, x ∈ childrenC_662 j) ∨ ∀ j, x ∈ childrenD_662 j := by decide +kernel +theorem required_exact_662 : required_662 = + ((Finset.univ.biUnion childrenC_662) ∪ commonEnvelope childrenD_662).erase (4, 4) := by + exact required_eq_combination childrenC_662 childrenD_662 (4, 4) required_662 + (by decide +kernel) child_required_sub_662 common_sub_662 required_origin_662 +theorem envelope_origin_662 : ∀ x ∈ envelope_662, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_662 j := by decide +kernel +theorem envelope_exact_662 : envelope_662 = + insert (4, 4) (Finset.univ.biUnion childrenD_662) := by + exact envelope_eq_combination childrenD_662 (4, 4) envelope_662 + pivot_mem_662 child_envelope_sub_662 envelope_origin_662 +def checked_662 : CheckedCard where + required := required_662 + envelope := envelope_662 + height := height_662 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_662 +def height_667 : ℕ := 9 +def childrenH_667 : Fin 3 → ℕ := ![height_7, height_9, height_666] +theorem height_exact_667 : height_667 = 1 + Finset.univ.sup childrenH_667 := by decide +kernel +theorem required_origin_667 : ∀ x ∈ required_667, + (∃ j, x ∈ childrenC_667 j) ∨ ∀ j, x ∈ childrenD_667 j := by decide +kernel +theorem required_exact_667 : required_667 = + ((Finset.univ.biUnion childrenC_667) ∪ commonEnvelope childrenD_667).erase (3, 4) := by + exact required_eq_combination childrenC_667 childrenD_667 (3, 4) required_667 + (by decide +kernel) child_required_sub_667 common_sub_667 required_origin_667 +theorem envelope_origin_667 : ∀ x ∈ envelope_667, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_667 j := by decide +kernel +theorem envelope_exact_667 : envelope_667 = + insert (3, 4) (Finset.univ.biUnion childrenD_667) := by + exact envelope_eq_combination childrenD_667 (3, 4) envelope_667 + pivot_mem_667 child_envelope_sub_667 envelope_origin_667 +def checked_667 : CheckedCard where + required := required_667 + envelope := envelope_667 + height := height_667 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_667 +def height_668 : ℕ := 9 +def childrenH_668 : Fin 3 → ℕ := ![height_7, height_9, height_666] +theorem height_exact_668 : height_668 = 1 + Finset.univ.sup childrenH_668 := by decide +kernel +theorem required_origin_668 : ∀ x ∈ required_668, + (∃ j, x ∈ childrenC_668 j) ∨ ∀ j, x ∈ childrenD_668 j := by decide +kernel +theorem required_exact_668 : required_668 = + ((Finset.univ.biUnion childrenC_668) ∪ commonEnvelope childrenD_668).erase (3, 4) := by + exact required_eq_combination childrenC_668 childrenD_668 (3, 4) required_668 + (by decide +kernel) child_required_sub_668 common_sub_668 required_origin_668 +theorem envelope_origin_668 : ∀ x ∈ envelope_668, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_668 j := by decide +kernel +theorem envelope_exact_668 : envelope_668 = + insert (3, 4) (Finset.univ.biUnion childrenD_668) := by + exact envelope_eq_combination childrenD_668 (3, 4) envelope_668 + pivot_mem_668 child_envelope_sub_668 envelope_origin_668 +def checked_668 : CheckedCard where + required := required_668 + envelope := envelope_668 + height := height_668 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_668 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part08.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part08.lean new file mode 100644 index 0000000..53a20b6 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part08.lean @@ -0,0 +1,743 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_673_i0 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 4), (2, 6), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 3), (3, 4), (4, 3), (4, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 3) required_30), (placed21 3 (1, 4) required_74)] +def childrenD_673_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 3) envelope_30), (placed21 3 (1, 4) envelope_74)] +theorem common_sub_673_i0 : commonEnvelope childrenD_673_i0 ⊆ insert (1, 4) required_673_i0 := by decide +kernel +theorem child_required_sub_673_i0 : ∀ j, childrenC_673_i0 j ⊆ insert (1, 4) required_673_i0 := by decide +kernel +theorem child_envelope_sub_673_i0 : ∀ j, childrenD_673_i0 j ⊆ envelope_673_i0 := by decide +kernel +theorem pivot_mem_673_i0 : (1, 4) ∈ envelope_673_i0 := by decide +kernel +theorem children_work_673_i0 : ∀ j, Template HasSnaky 3 (childrenC_673_i0 j) (childrenD_673_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_30 0 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_74 3 (1, 4)).mono (by decide +kernel) +theorem row_works_673_i0 : Template HasSnaky 4 required_673_i0 envelope_673_i0 := by + refine compose HasSnaky 3 childrenC_673_i0 childrenD_673_i0 children_work_673_i0 (1, 4) + required_673_i0 envelope_673_i0 pivot_mem_673_i0 child_required_sub_673_i0 child_envelope_sub_673_i0 ?_ + intro b hb + exact common_sub_673_i0 (mem_commonEnvelope childrenD_673_i0 b hb) +def required_673_i3 : Finset Cell := ⟨(([(1, 4), (1, 6), (2, 4), (2, 6), (3, 4), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i3 : Finset Cell := ⟨(([(1, 4), (1, 6), (2, 4), (2, 6), (2, 7), (3, 4), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i3 : Fin 2 → Finset Cell := ![(placed21 0 (1, 4) required_5), (placed21 0 (1, 3) required_260)] +def childrenD_673_i3 : Fin 2 → Finset Cell := ![(placed21 0 (1, 4) envelope_5), (placed21 0 (1, 3) envelope_260)] +theorem common_sub_673_i3 : commonEnvelope childrenD_673_i3 ⊆ insert (4, 5) required_673_i3 := by decide +kernel +theorem child_required_sub_673_i3 : ∀ j, childrenC_673_i3 j ⊆ insert (4, 5) required_673_i3 := by decide +kernel +theorem child_envelope_sub_673_i3 : ∀ j, childrenD_673_i3 j ⊆ envelope_673_i3 := by decide +kernel +theorem pivot_mem_673_i3 : (4, 5) ∈ envelope_673_i3 := by decide +kernel +theorem children_work_673_i3 : ∀ j, Template HasSnaky 5 (childrenC_673_i3 j) (childrenD_673_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_260 0 (1, 3)).mono (by decide +kernel) +theorem row_works_673_i3 : Template HasSnaky 6 required_673_i3 envelope_673_i3 := by + refine compose HasSnaky 5 childrenC_673_i3 childrenD_673_i3 children_work_673_i3 (4, 5) + required_673_i3 envelope_673_i3 pivot_mem_673_i3 child_required_sub_673_i3 child_envelope_sub_673_i3 ?_ + intro b hb + exact common_sub_673_i3 (mem_commonEnvelope childrenD_673_i3 b hb) +def required_673_i2 : Finset Cell := ⟨(([(1, 6), (2, 3), (2, 4), (2, 6), (3, 4), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i2 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 4), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i2 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) required_38), required_673_i3] +def childrenD_673_i2 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) envelope_38), envelope_673_i3] +theorem common_sub_673_i2 : commonEnvelope childrenD_673_i2 ⊆ insert (1, 4) required_673_i2 := by decide +kernel +theorem child_required_sub_673_i2 : ∀ j, childrenC_673_i2 j ⊆ insert (1, 4) required_673_i2 := by decide +kernel +theorem child_envelope_sub_673_i2 : ∀ j, childrenD_673_i2 j ⊆ envelope_673_i2 := by decide +kernel +theorem pivot_mem_673_i2 : (1, 4) ∈ envelope_673_i2 := by decide +kernel +theorem children_work_673_i2 : ∀ j, Template HasSnaky 6 (childrenC_673_i2 j) (childrenD_673_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_38 2 (4, 3)).mono (by decide +kernel) + · exact row_works_673_i3.mono (by decide +kernel) +theorem row_works_673_i2 : Template HasSnaky 7 required_673_i2 envelope_673_i2 := by + refine compose HasSnaky 6 childrenC_673_i2 childrenD_673_i2 children_work_673_i2 (1, 4) + required_673_i2 envelope_673_i2 pivot_mem_673_i2 child_required_sub_673_i2 child_envelope_sub_673_i2 ?_ + intro b hb + exact common_sub_673_i2 (mem_commonEnvelope childrenD_673_i2 b hb) +def required_673_i1 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 4), (2, 6), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i1 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 4), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i1 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) required_0), required_673_i2] +def childrenD_673_i1 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) envelope_0), envelope_673_i2] +theorem common_sub_673_i1 : commonEnvelope childrenD_673_i1 ⊆ insert (3, 4) required_673_i1 := by decide +kernel +theorem child_required_sub_673_i1 : ∀ j, childrenC_673_i1 j ⊆ insert (3, 4) required_673_i1 := by decide +kernel +theorem child_envelope_sub_673_i1 : ∀ j, childrenD_673_i1 j ⊆ envelope_673_i1 := by decide +kernel +theorem pivot_mem_673_i1 : (3, 4) ∈ envelope_673_i1 := by decide +kernel +theorem children_work_673_i1 : ∀ j, Template HasSnaky 7 (childrenC_673_i1 j) (childrenD_673_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact row_works_673_i2.mono (by decide +kernel) +theorem row_works_673_i1 : Template HasSnaky 8 required_673_i1 envelope_673_i1 := by + refine compose HasSnaky 7 childrenC_673_i1 childrenD_673_i1 children_work_673_i1 (3, 4) + required_673_i1 envelope_673_i1 pivot_mem_673_i1 child_required_sub_673_i1 child_envelope_sub_673_i1 ?_ + intro b hb + exact common_sub_673_i1 (mem_commonEnvelope childrenD_673_i1 b hb) +def required_673_i4 : Finset Cell := ⟨(([(1, 6), (2, 3), (2, 6), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i4 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 4), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i4 : Fin 5 → Finset Cell := ![(placed21 0 (2, 2) required_188), (placed21 6 (6, 8) required_190), (placed21 7 (6, 7) required_230), (placed21 0 (1, 3) required_263), (placed21 4 (1, 8) required_306)] +def childrenD_673_i4 : Fin 5 → Finset Cell := ![(placed21 0 (2, 2) envelope_188), (placed21 6 (6, 8) envelope_190), (placed21 7 (6, 7) envelope_230), (placed21 0 (1, 3) envelope_263), (placed21 4 (1, 8) envelope_306)] +theorem common_sub_673_i4 : commonEnvelope childrenD_673_i4 ⊆ insert (4, 5) required_673_i4 := by decide +kernel +theorem child_required_sub_673_i4 : ∀ j, childrenC_673_i4 j ⊆ insert (4, 5) required_673_i4 := by decide +kernel +theorem child_envelope_sub_673_i4 : ∀ j, childrenD_673_i4 j ⊆ envelope_673_i4 := by decide +kernel +theorem pivot_mem_673_i4 : (4, 5) ∈ envelope_673_i4 := by decide +kernel +theorem children_work_673_i4 : ∀ j, Template HasSnaky 6 (childrenC_673_i4 j) (childrenD_673_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_188 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_190 6 (6, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_230 7 (6, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_263 0 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_306 4 (1, 8)).mono (by decide +kernel) +theorem row_works_673_i4 : Template HasSnaky 7 required_673_i4 envelope_673_i4 := by + refine compose HasSnaky 6 childrenC_673_i4 childrenD_673_i4 children_work_673_i4 (4, 5) + required_673_i4 envelope_673_i4 pivot_mem_673_i4 child_required_sub_673_i4 child_envelope_sub_673_i4 ?_ + intro b hb + exact common_sub_673_i4 (mem_commonEnvelope childrenD_673_i4 b hb) +def required_673_i6 : Finset Cell := ⟨(([(1, 6), (2, 3), (2, 4), (3, 4), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i6 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (3, 3), (3, 4), (3, 7), (3, 8), (3, 9), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i6 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) required_38), (placed21 0 (1, 3) required_145)] +def childrenD_673_i6 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) envelope_38), (placed21 0 (1, 3) envelope_145)] +theorem common_sub_673_i6 : commonEnvelope childrenD_673_i6 ⊆ insert (1, 4) required_673_i6 := by decide +kernel +theorem child_required_sub_673_i6 : ∀ j, childrenC_673_i6 j ⊆ insert (1, 4) required_673_i6 := by decide +kernel +theorem child_envelope_sub_673_i6 : ∀ j, childrenD_673_i6 j ⊆ envelope_673_i6 := by decide +kernel +theorem pivot_mem_673_i6 : (1, 4) ∈ envelope_673_i6 := by decide +kernel +theorem children_work_673_i6 : ∀ j, Template HasSnaky 5 (childrenC_673_i6 j) (childrenD_673_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_38 2 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_145 0 (1, 3)).mono (by decide +kernel) +theorem row_works_673_i6 : Template HasSnaky 6 required_673_i6 envelope_673_i6 := by + refine compose HasSnaky 5 childrenC_673_i6 childrenD_673_i6 children_work_673_i6 (1, 4) + required_673_i6 envelope_673_i6 pivot_mem_673_i6 child_required_sub_673_i6 child_envelope_sub_673_i6 ?_ + intro b hb + exact common_sub_673_i6 (mem_commonEnvelope childrenD_673_i6 b hb) +def required_673_i5 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 4), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i5 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (3, 3), (3, 4), (3, 7), (3, 8), (3, 9), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i5 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) required_0), required_673_i6] +def childrenD_673_i5 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) envelope_0), envelope_673_i6] +theorem common_sub_673_i5 : commonEnvelope childrenD_673_i5 ⊆ insert (3, 4) required_673_i5 := by decide +kernel +theorem child_required_sub_673_i5 : ∀ j, childrenC_673_i5 j ⊆ insert (3, 4) required_673_i5 := by decide +kernel +theorem child_envelope_sub_673_i5 : ∀ j, childrenD_673_i5 j ⊆ envelope_673_i5 := by decide +kernel +theorem pivot_mem_673_i5 : (3, 4) ∈ envelope_673_i5 := by decide +kernel +theorem children_work_673_i5 : ∀ j, Template HasSnaky 6 (childrenC_673_i5 j) (childrenD_673_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact row_works_673_i6.mono (by decide +kernel) +theorem row_works_673_i5 : Template HasSnaky 7 required_673_i5 envelope_673_i5 := by + refine compose HasSnaky 6 childrenC_673_i5 childrenD_673_i5 children_work_673_i5 (3, 4) + required_673_i5 envelope_673_i5 pivot_mem_673_i5 child_required_sub_673_i5 child_envelope_sub_673_i5 ?_ + intro b hb + exact common_sub_673_i5 (mem_commonEnvelope childrenD_673_i5 b hb) +def required_673_i9 : Finset Cell := ⟨(([(1, 4), (2, 4), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i9 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i9 : Fin 3 → Finset Cell := ![(placed21 3 (3, 6) required_8), (placed21 0 (3, 2) required_19), (placed21 7 (5, 6) required_25)] +def childrenD_673_i9 : Fin 3 → Finset Cell := ![(placed21 3 (3, 6) envelope_8), (placed21 0 (3, 2) envelope_19), (placed21 7 (5, 6) envelope_25)] +theorem common_sub_673_i9 : commonEnvelope childrenD_673_i9 ⊆ insert (4, 3) required_673_i9 := by decide +kernel +theorem child_required_sub_673_i9 : ∀ j, childrenC_673_i9 j ⊆ insert (4, 3) required_673_i9 := by decide +kernel +theorem child_envelope_sub_673_i9 : ∀ j, childrenD_673_i9 j ⊆ envelope_673_i9 := by decide +kernel +theorem pivot_mem_673_i9 : (4, 3) ∈ envelope_673_i9 := by decide +kernel +theorem children_work_673_i9 : ∀ j, Template HasSnaky 5 (childrenC_673_i9 j) (childrenD_673_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 3 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_19 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_25 7 (5, 6)).mono (by decide +kernel) +theorem row_works_673_i9 : Template HasSnaky 6 required_673_i9 envelope_673_i9 := by + refine compose HasSnaky 5 childrenC_673_i9 childrenD_673_i9 children_work_673_i9 (4, 3) + required_673_i9 envelope_673_i9 pivot_mem_673_i9 child_required_sub_673_i9 child_envelope_sub_673_i9 ?_ + intro b hb + exact common_sub_673_i9 (mem_commonEnvelope childrenD_673_i9 b hb) +def required_673_i10 : Finset Cell := ⟨(([(1, 4), (2, 4), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i10 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 3), (3, 4), (3, 7), (3, 8), (3, 9), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i10 : Fin 2 → Finset Cell := ![(placed21 0 (1, 4) required_5), (placed21 0 (3, 3) required_10)] +def childrenD_673_i10 : Fin 2 → Finset Cell := ![(placed21 0 (1, 4) envelope_5), (placed21 0 (3, 3) envelope_10)] +theorem common_sub_673_i10 : commonEnvelope childrenD_673_i10 ⊆ insert (3, 4) required_673_i10 := by decide +kernel +theorem child_required_sub_673_i10 : ∀ j, childrenC_673_i10 j ⊆ insert (3, 4) required_673_i10 := by decide +kernel +theorem child_envelope_sub_673_i10 : ∀ j, childrenD_673_i10 j ⊆ envelope_673_i10 := by decide +kernel +theorem pivot_mem_673_i10 : (3, 4) ∈ envelope_673_i10 := by decide +kernel +theorem children_work_673_i10 : ∀ j, Template HasSnaky 4 (childrenC_673_i10 j) (childrenD_673_i10 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_10 0 (3, 3)).mono (by decide +kernel) +theorem row_works_673_i10 : Template HasSnaky 5 required_673_i10 envelope_673_i10 := by + refine compose HasSnaky 4 childrenC_673_i10 childrenD_673_i10 children_work_673_i10 (3, 4) + required_673_i10 envelope_673_i10 pivot_mem_673_i10 child_required_sub_673_i10 child_envelope_sub_673_i10 ?_ + intro b hb + exact common_sub_673_i10 (mem_commonEnvelope childrenD_673_i10 b hb) +def required_673_i8 : Finset Cell := ⟨(([(1, 4), (2, 4), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i8 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i8 : Fin 5 → Finset Cell := ![(placed21 4 (1, 7) required_263), (placed21 4 (1, 7) required_271), (placed21 4 (1, 7) required_424), required_673_i9, required_673_i10] +def childrenD_673_i8 : Fin 5 → Finset Cell := ![(placed21 4 (1, 7) envelope_263), (placed21 4 (1, 7) envelope_271), (placed21 4 (1, 7) envelope_424), envelope_673_i9, envelope_673_i10] +theorem common_sub_673_i8 : commonEnvelope childrenD_673_i8 ⊆ insert (4, 5) required_673_i8 := by decide +kernel +theorem child_required_sub_673_i8 : ∀ j, childrenC_673_i8 j ⊆ insert (4, 5) required_673_i8 := by decide +kernel +theorem child_envelope_sub_673_i8 : ∀ j, childrenD_673_i8 j ⊆ envelope_673_i8 := by decide +kernel +theorem pivot_mem_673_i8 : (4, 5) ∈ envelope_673_i8 := by decide +kernel +theorem children_work_673_i8 : ∀ j, Template HasSnaky 6 (childrenC_673_i8 j) (childrenD_673_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_263 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_271 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_424 4 (1, 7)).mono (by decide +kernel) + · exact row_works_673_i9.mono (by decide +kernel) + · exact row_works_673_i10.mono (by decide +kernel) +theorem row_works_673_i8 : Template HasSnaky 7 required_673_i8 envelope_673_i8 := by + refine compose HasSnaky 6 childrenC_673_i8 childrenD_673_i8 children_work_673_i8 (4, 5) + required_673_i8 envelope_673_i8 pivot_mem_673_i8 child_required_sub_673_i8 child_envelope_sub_673_i8 ?_ + intro b hb + exact common_sub_673_i8 (mem_commonEnvelope childrenD_673_i8 b hb) +def required_673_i7 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 4), (2, 6), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673_i7 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673_i7 : Fin 2 → Finset Cell := ![(placed21 0 (1, 3) required_30), required_673_i8] +def childrenD_673_i7 : Fin 2 → Finset Cell := ![(placed21 0 (1, 3) envelope_30), envelope_673_i8] +theorem common_sub_673_i7 : commonEnvelope childrenD_673_i7 ⊆ insert (1, 4) required_673_i7 := by decide +kernel +theorem child_required_sub_673_i7 : ∀ j, childrenC_673_i7 j ⊆ insert (1, 4) required_673_i7 := by decide +kernel +theorem child_envelope_sub_673_i7 : ∀ j, childrenD_673_i7 j ⊆ envelope_673_i7 := by decide +kernel +theorem pivot_mem_673_i7 : (1, 4) ∈ envelope_673_i7 := by decide +kernel +theorem children_work_673_i7 : ∀ j, Template HasSnaky 7 (childrenC_673_i7 j) (childrenD_673_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_30 0 (1, 3)).mono (by decide +kernel) + · exact row_works_673_i8.mono (by decide +kernel) +theorem row_works_673_i7 : Template HasSnaky 8 required_673_i7 envelope_673_i7 := by + refine compose HasSnaky 7 childrenC_673_i7 childrenD_673_i7 children_work_673_i7 (1, 4) + required_673_i7 envelope_673_i7 pivot_mem_673_i7 child_required_sub_673_i7 child_envelope_sub_673_i7 ?_ + intro b hb + exact common_sub_673_i7 (mem_commonEnvelope childrenD_673_i7 b hb) +def required_673 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 4), (2, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_673 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 4), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_673 : Fin 5 → Finset Cell := ![required_673_i0, required_673_i1, required_673_i4, required_673_i5, required_673_i7] +def childrenD_673 : Fin 5 → Finset Cell := ![envelope_673_i0, envelope_673_i1, envelope_673_i4, envelope_673_i5, envelope_673_i7] +theorem common_sub_673 : commonEnvelope childrenD_673 ⊆ insert (4, 4) required_673 := by decide +kernel +theorem child_required_sub_673 : ∀ j, childrenC_673 j ⊆ insert (4, 4) required_673 := by decide +kernel +theorem child_envelope_sub_673 : ∀ j, childrenD_673 j ⊆ envelope_673 := by decide +kernel +theorem pivot_mem_673 : (4, 4) ∈ envelope_673 := by decide +kernel +theorem children_work_673 : ∀ j, Template HasSnaky 8 (childrenC_673 j) (childrenD_673 j) := by + intro j + fin_cases j + · exact row_works_673_i0.mono (by decide +kernel) + · exact row_works_673_i1.mono (by decide +kernel) + · exact row_works_673_i4.mono (by decide +kernel) + · exact row_works_673_i5.mono (by decide +kernel) + · exact row_works_673_i7.mono (by decide +kernel) +theorem row_works_673 : Template HasSnaky 9 required_673 envelope_673 := by + refine compose HasSnaky 8 childrenC_673 childrenD_673 children_work_673 (4, 4) + required_673 envelope_673 pivot_mem_673 child_required_sub_673 child_envelope_sub_673 ?_ + intro b hb + exact common_sub_673 (mem_commonEnvelope childrenD_673 b hb) +def required_686_i0 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_686_i0 : Finset Cell := ⟨(([(1, 5), (2, 3), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_686_i0 : Fin 3 → Finset Cell := ![(placed21 1 (2, 3) required_43), (placed21 5 (7, 2) required_57), (placed21 0 (3, 0) required_340)] +def childrenD_686_i0 : Fin 3 → Finset Cell := ![(placed21 1 (2, 3) envelope_43), (placed21 5 (7, 2) envelope_57), (placed21 0 (3, 0) envelope_340)] +theorem common_sub_686_i0 : commonEnvelope childrenD_686_i0 ⊆ insert (5, 4) required_686_i0 := by decide +kernel +theorem child_required_sub_686_i0 : ∀ j, childrenC_686_i0 j ⊆ insert (5, 4) required_686_i0 := by decide +kernel +theorem child_envelope_sub_686_i0 : ∀ j, childrenD_686_i0 j ⊆ envelope_686_i0 := by decide +kernel +theorem pivot_mem_686_i0 : (5, 4) ∈ envelope_686_i0 := by decide +kernel +theorem children_work_686_i0 : ∀ j, Template HasSnaky 6 (childrenC_686_i0 j) (childrenD_686_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_43 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_57 5 (7, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_340 0 (3, 0)).mono (by decide +kernel) +theorem row_works_686_i0 : Template HasSnaky 7 required_686_i0 envelope_686_i0 := by + refine compose HasSnaky 6 childrenC_686_i0 childrenD_686_i0 children_work_686_i0 (5, 4) + required_686_i0 envelope_686_i0 pivot_mem_686_i0 child_required_sub_686_i0 child_envelope_sub_686_i0 ?_ + intro b hb + exact common_sub_686_i0 (mem_commonEnvelope childrenD_686_i0 b hb) +def required_686_i1 : Finset Cell := ⟨(([(4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_686_i1 : Finset Cell := ⟨(([(0, 5), (0, 6), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (6, 4), (6, 5), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_686_i1 : Fin 3 → Finset Cell := ![(placed21 4 (4, 6) required_7), (placed21 4 (3, 6) required_9), (placed21 5 (7, 2) required_256)] +def childrenD_686_i1 : Fin 3 → Finset Cell := ![(placed21 4 (4, 6) envelope_7), (placed21 4 (3, 6) envelope_9), (placed21 5 (7, 2) envelope_256)] +theorem common_sub_686_i1 : commonEnvelope childrenD_686_i1 ⊆ insert (4, 2) required_686_i1 := by decide +kernel +theorem child_required_sub_686_i1 : ∀ j, childrenC_686_i1 j ⊆ insert (4, 2) required_686_i1 := by decide +kernel +theorem child_envelope_sub_686_i1 : ∀ j, childrenD_686_i1 j ⊆ envelope_686_i1 := by decide +kernel +theorem pivot_mem_686_i1 : (4, 2) ∈ envelope_686_i1 := by decide +kernel +theorem children_work_686_i1 : ∀ j, Template HasSnaky 7 (childrenC_686_i1 j) (childrenD_686_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_9 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_256 5 (7, 2)).mono (by decide +kernel) +theorem row_works_686_i1 : Template HasSnaky 8 required_686_i1 envelope_686_i1 := by + refine compose HasSnaky 7 childrenC_686_i1 childrenD_686_i1 children_work_686_i1 (4, 2) + required_686_i1 envelope_686_i1 pivot_mem_686_i1 child_required_sub_686_i1 child_envelope_sub_686_i1 ?_ + intro b hb + exact common_sub_686_i1 (mem_commonEnvelope childrenD_686_i1 b hb) +def required_686 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_686 : Finset Cell := ⟨(([(0, 5), (0, 6), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_686 : Fin 7 → Finset Cell := ![(placed21 5 (6, 2) required_134), (placed21 5 (6, 2) required_180), (placed21 0 (3, 0) required_337), (placed21 5 (7, 2) required_435), (placed21 5 (6, 3) required_558), required_686_i0, required_686_i1] +def childrenD_686 : Fin 7 → Finset Cell := ![(placed21 5 (6, 2) envelope_134), (placed21 5 (6, 2) envelope_180), (placed21 0 (3, 0) envelope_337), (placed21 5 (7, 2) envelope_435), (placed21 5 (6, 3) envelope_558), envelope_686_i0, envelope_686_i1] +theorem common_sub_686 : commonEnvelope childrenD_686 ⊆ insert (4, 5) required_686 := by decide +kernel +theorem child_required_sub_686 : ∀ j, childrenC_686 j ⊆ insert (4, 5) required_686 := by decide +kernel +theorem child_envelope_sub_686 : ∀ j, childrenD_686 j ⊆ envelope_686 := by decide +kernel +theorem pivot_mem_686 : (4, 5) ∈ envelope_686 := by decide +kernel +theorem children_work_686 : ∀ j, Template HasSnaky 8 (childrenC_686 j) (childrenD_686 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_134 5 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_180 5 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_337 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (7, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_558 5 (6, 3)).mono (by decide +kernel) + · exact row_works_686_i0.mono (by decide +kernel) + · exact row_works_686_i1.mono (by decide +kernel) +theorem row_works_686 : Template HasSnaky 9 required_686 envelope_686 := by + refine compose HasSnaky 8 childrenC_686 childrenD_686 children_work_686 (4, 5) + required_686 envelope_686 pivot_mem_686 child_required_sub_686 child_envelope_sub_686 ?_ + intro b hb + exact common_sub_686 (mem_commonEnvelope childrenD_686 b hb) +def required_688_i0 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 5), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_688_i0 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (7, 3), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_688_i0 : Fin 5 → Finset Cell := ![(placed21 4 (0, 5) required_8), (placed21 3 (0, 5) required_41), (placed21 4 (0, 7) required_253), (placed21 4 (0, 7) required_256), (placed21 3 (0, 5) required_336)] +def childrenD_688_i0 : Fin 5 → Finset Cell := ![(placed21 4 (0, 5) envelope_8), (placed21 3 (0, 5) envelope_41), (placed21 4 (0, 7) envelope_253), (placed21 4 (0, 7) envelope_256), (placed21 3 (0, 5) envelope_336)] +theorem common_sub_688_i0 : commonEnvelope childrenD_688_i0 ⊆ insert (3, 4) required_688_i0 := by decide +kernel +theorem child_required_sub_688_i0 : ∀ j, childrenC_688_i0 j ⊆ insert (3, 4) required_688_i0 := by decide +kernel +theorem child_envelope_sub_688_i0 : ∀ j, childrenD_688_i0 j ⊆ envelope_688_i0 := by decide +kernel +theorem pivot_mem_688_i0 : (3, 4) ∈ envelope_688_i0 := by decide +kernel +theorem children_work_688_i0 : ∀ j, Template HasSnaky 7 (childrenC_688_i0 j) (childrenD_688_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 4 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_41 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_253 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_256 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_336 3 (0, 5)).mono (by decide +kernel) +theorem row_works_688_i0 : Template HasSnaky 8 required_688_i0 envelope_688_i0 := by + refine compose HasSnaky 7 childrenC_688_i0 childrenD_688_i0 children_work_688_i0 (3, 4) + required_688_i0 envelope_688_i0 pivot_mem_688_i0 child_required_sub_688_i0 child_envelope_sub_688_i0 ?_ + intro b hb + exact common_sub_688_i0 (mem_commonEnvelope childrenD_688_i0 b hb) +def required_688 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 4), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_688 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (7, 3), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_688 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) required_0), required_688_i0] +def childrenD_688 : Fin 2 → Finset Cell := ![(placed21 1 (0, 1) envelope_0), envelope_688_i0] +theorem common_sub_688 : commonEnvelope childrenD_688 ⊆ insert (1, 5) required_688 := by decide +kernel +theorem child_required_sub_688 : ∀ j, childrenC_688 j ⊆ insert (1, 5) required_688 := by decide +kernel +theorem child_envelope_sub_688 : ∀ j, childrenD_688 j ⊆ envelope_688 := by decide +kernel +theorem pivot_mem_688 : (1, 5) ∈ envelope_688 := by decide +kernel +theorem children_work_688 : ∀ j, Template HasSnaky 8 (childrenC_688 j) (childrenD_688 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (0, 1)).mono (by decide +kernel) + · exact row_works_688_i0.mono (by decide +kernel) +theorem row_works_688 : Template HasSnaky 9 required_688 envelope_688 := by + refine compose HasSnaky 8 childrenC_688 childrenD_688 children_work_688 (1, 5) + required_688 envelope_688 pivot_mem_688 child_required_sub_688 child_envelope_sub_688 ?_ + intro b hb + exact common_sub_688 (mem_commonEnvelope childrenD_688 b hb) +def height_673_i0 : ℕ := 4 +def childrenH_673_i0 : Fin 2 → ℕ := ![height_30, height_74] +theorem height_exact_673_i0 : height_673_i0 = 1 + Finset.univ.sup childrenH_673_i0 := by decide +kernel +theorem required_origin_673_i0 : ∀ x ∈ required_673_i0, + (∃ j, x ∈ childrenC_673_i0 j) ∨ ∀ j, x ∈ childrenD_673_i0 j := by decide +kernel +theorem required_exact_673_i0 : required_673_i0 = + ((Finset.univ.biUnion childrenC_673_i0) ∪ commonEnvelope childrenD_673_i0).erase (1, 4) := by + exact required_eq_combination childrenC_673_i0 childrenD_673_i0 (1, 4) required_673_i0 + (by decide +kernel) child_required_sub_673_i0 common_sub_673_i0 required_origin_673_i0 +theorem envelope_origin_673_i0 : ∀ x ∈ envelope_673_i0, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_673_i0 j := by decide +kernel +theorem envelope_exact_673_i0 : envelope_673_i0 = + insert (1, 4) (Finset.univ.biUnion childrenD_673_i0) := by + exact envelope_eq_combination childrenD_673_i0 (1, 4) envelope_673_i0 + pivot_mem_673_i0 child_envelope_sub_673_i0 envelope_origin_673_i0 +def checked_673_i0 : CheckedCard where + required := required_673_i0 + envelope := envelope_673_i0 + height := height_673_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i0 +def height_673_i3 : ℕ := 6 +def childrenH_673_i3 : Fin 2 → ℕ := ![height_5, height_260] +theorem height_exact_673_i3 : height_673_i3 = 1 + Finset.univ.sup childrenH_673_i3 := by decide +kernel +theorem required_origin_673_i3 : ∀ x ∈ required_673_i3, + (∃ j, x ∈ childrenC_673_i3 j) ∨ ∀ j, x ∈ childrenD_673_i3 j := by decide +kernel +theorem required_exact_673_i3 : required_673_i3 = + ((Finset.univ.biUnion childrenC_673_i3) ∪ commonEnvelope childrenD_673_i3).erase (4, 5) := by + exact required_eq_combination childrenC_673_i3 childrenD_673_i3 (4, 5) required_673_i3 + (by decide +kernel) child_required_sub_673_i3 common_sub_673_i3 required_origin_673_i3 +theorem envelope_origin_673_i3 : ∀ x ∈ envelope_673_i3, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_673_i3 j := by decide +kernel +theorem envelope_exact_673_i3 : envelope_673_i3 = + insert (4, 5) (Finset.univ.biUnion childrenD_673_i3) := by + exact envelope_eq_combination childrenD_673_i3 (4, 5) envelope_673_i3 + pivot_mem_673_i3 child_envelope_sub_673_i3 envelope_origin_673_i3 +def checked_673_i3 : CheckedCard where + required := required_673_i3 + envelope := envelope_673_i3 + height := height_673_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i3 +def height_673_i2 : ℕ := 7 +def childrenH_673_i2 : Fin 2 → ℕ := ![height_38, height_673_i3] +theorem height_exact_673_i2 : height_673_i2 = 1 + Finset.univ.sup childrenH_673_i2 := by decide +kernel +theorem required_origin_673_i2 : ∀ x ∈ required_673_i2, + (∃ j, x ∈ childrenC_673_i2 j) ∨ ∀ j, x ∈ childrenD_673_i2 j := by decide +kernel +theorem required_exact_673_i2 : required_673_i2 = + ((Finset.univ.biUnion childrenC_673_i2) ∪ commonEnvelope childrenD_673_i2).erase (1, 4) := by + exact required_eq_combination childrenC_673_i2 childrenD_673_i2 (1, 4) required_673_i2 + (by decide +kernel) child_required_sub_673_i2 common_sub_673_i2 required_origin_673_i2 +theorem envelope_origin_673_i2 : ∀ x ∈ envelope_673_i2, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_673_i2 j := by decide +kernel +theorem envelope_exact_673_i2 : envelope_673_i2 = + insert (1, 4) (Finset.univ.biUnion childrenD_673_i2) := by + exact envelope_eq_combination childrenD_673_i2 (1, 4) envelope_673_i2 + pivot_mem_673_i2 child_envelope_sub_673_i2 envelope_origin_673_i2 +def checked_673_i2 : CheckedCard where + required := required_673_i2 + envelope := envelope_673_i2 + height := height_673_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i2 +def height_673_i1 : ℕ := 8 +def childrenH_673_i1 : Fin 2 → ℕ := ![height_0, height_673_i2] +theorem height_exact_673_i1 : height_673_i1 = 1 + Finset.univ.sup childrenH_673_i1 := by decide +kernel +theorem required_origin_673_i1 : ∀ x ∈ required_673_i1, + (∃ j, x ∈ childrenC_673_i1 j) ∨ ∀ j, x ∈ childrenD_673_i1 j := by decide +kernel +theorem required_exact_673_i1 : required_673_i1 = + ((Finset.univ.biUnion childrenC_673_i1) ∪ commonEnvelope childrenD_673_i1).erase (3, 4) := by + exact required_eq_combination childrenC_673_i1 childrenD_673_i1 (3, 4) required_673_i1 + (by decide +kernel) child_required_sub_673_i1 common_sub_673_i1 required_origin_673_i1 +theorem envelope_origin_673_i1 : ∀ x ∈ envelope_673_i1, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_673_i1 j := by decide +kernel +theorem envelope_exact_673_i1 : envelope_673_i1 = + insert (3, 4) (Finset.univ.biUnion childrenD_673_i1) := by + exact envelope_eq_combination childrenD_673_i1 (3, 4) envelope_673_i1 + pivot_mem_673_i1 child_envelope_sub_673_i1 envelope_origin_673_i1 +def checked_673_i1 : CheckedCard where + required := required_673_i1 + envelope := envelope_673_i1 + height := height_673_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i1 +def height_673_i4 : ℕ := 7 +def childrenH_673_i4 : Fin 5 → ℕ := ![height_188, height_190, height_230, height_263, height_306] +theorem height_exact_673_i4 : height_673_i4 = 1 + Finset.univ.sup childrenH_673_i4 := by decide +kernel +theorem required_origin_673_i4 : ∀ x ∈ required_673_i4, + (∃ j, x ∈ childrenC_673_i4 j) ∨ ∀ j, x ∈ childrenD_673_i4 j := by decide +kernel +theorem required_exact_673_i4 : required_673_i4 = + ((Finset.univ.biUnion childrenC_673_i4) ∪ commonEnvelope childrenD_673_i4).erase (4, 5) := by + exact required_eq_combination childrenC_673_i4 childrenD_673_i4 (4, 5) required_673_i4 + (by decide +kernel) child_required_sub_673_i4 common_sub_673_i4 required_origin_673_i4 +theorem envelope_origin_673_i4 : ∀ x ∈ envelope_673_i4, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_673_i4 j := by decide +kernel +theorem envelope_exact_673_i4 : envelope_673_i4 = + insert (4, 5) (Finset.univ.biUnion childrenD_673_i4) := by + exact envelope_eq_combination childrenD_673_i4 (4, 5) envelope_673_i4 + pivot_mem_673_i4 child_envelope_sub_673_i4 envelope_origin_673_i4 +def checked_673_i4 : CheckedCard where + required := required_673_i4 + envelope := envelope_673_i4 + height := height_673_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i4 +def height_673_i6 : ℕ := 6 +def childrenH_673_i6 : Fin 2 → ℕ := ![height_38, height_145] +theorem height_exact_673_i6 : height_673_i6 = 1 + Finset.univ.sup childrenH_673_i6 := by decide +kernel +theorem required_origin_673_i6 : ∀ x ∈ required_673_i6, + (∃ j, x ∈ childrenC_673_i6 j) ∨ ∀ j, x ∈ childrenD_673_i6 j := by decide +kernel +theorem required_exact_673_i6 : required_673_i6 = + ((Finset.univ.biUnion childrenC_673_i6) ∪ commonEnvelope childrenD_673_i6).erase (1, 4) := by + exact required_eq_combination childrenC_673_i6 childrenD_673_i6 (1, 4) required_673_i6 + (by decide +kernel) child_required_sub_673_i6 common_sub_673_i6 required_origin_673_i6 +theorem envelope_origin_673_i6 : ∀ x ∈ envelope_673_i6, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_673_i6 j := by decide +kernel +theorem envelope_exact_673_i6 : envelope_673_i6 = + insert (1, 4) (Finset.univ.biUnion childrenD_673_i6) := by + exact envelope_eq_combination childrenD_673_i6 (1, 4) envelope_673_i6 + pivot_mem_673_i6 child_envelope_sub_673_i6 envelope_origin_673_i6 +def checked_673_i6 : CheckedCard where + required := required_673_i6 + envelope := envelope_673_i6 + height := height_673_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i6 +def height_673_i5 : ℕ := 7 +def childrenH_673_i5 : Fin 2 → ℕ := ![height_0, height_673_i6] +theorem height_exact_673_i5 : height_673_i5 = 1 + Finset.univ.sup childrenH_673_i5 := by decide +kernel +theorem required_origin_673_i5 : ∀ x ∈ required_673_i5, + (∃ j, x ∈ childrenC_673_i5 j) ∨ ∀ j, x ∈ childrenD_673_i5 j := by decide +kernel +theorem required_exact_673_i5 : required_673_i5 = + ((Finset.univ.biUnion childrenC_673_i5) ∪ commonEnvelope childrenD_673_i5).erase (3, 4) := by + exact required_eq_combination childrenC_673_i5 childrenD_673_i5 (3, 4) required_673_i5 + (by decide +kernel) child_required_sub_673_i5 common_sub_673_i5 required_origin_673_i5 +theorem envelope_origin_673_i5 : ∀ x ∈ envelope_673_i5, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_673_i5 j := by decide +kernel +theorem envelope_exact_673_i5 : envelope_673_i5 = + insert (3, 4) (Finset.univ.biUnion childrenD_673_i5) := by + exact envelope_eq_combination childrenD_673_i5 (3, 4) envelope_673_i5 + pivot_mem_673_i5 child_envelope_sub_673_i5 envelope_origin_673_i5 +def checked_673_i5 : CheckedCard where + required := required_673_i5 + envelope := envelope_673_i5 + height := height_673_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i5 +def height_673_i9 : ℕ := 6 +def childrenH_673_i9 : Fin 3 → ℕ := ![height_8, height_19, height_25] +theorem height_exact_673_i9 : height_673_i9 = 1 + Finset.univ.sup childrenH_673_i9 := by decide +kernel +theorem required_origin_673_i9 : ∀ x ∈ required_673_i9, + (∃ j, x ∈ childrenC_673_i9 j) ∨ ∀ j, x ∈ childrenD_673_i9 j := by decide +kernel +theorem required_exact_673_i9 : required_673_i9 = + ((Finset.univ.biUnion childrenC_673_i9) ∪ commonEnvelope childrenD_673_i9).erase (4, 3) := by + exact required_eq_combination childrenC_673_i9 childrenD_673_i9 (4, 3) required_673_i9 + (by decide +kernel) child_required_sub_673_i9 common_sub_673_i9 required_origin_673_i9 +theorem envelope_origin_673_i9 : ∀ x ∈ envelope_673_i9, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_673_i9 j := by decide +kernel +theorem envelope_exact_673_i9 : envelope_673_i9 = + insert (4, 3) (Finset.univ.biUnion childrenD_673_i9) := by + exact envelope_eq_combination childrenD_673_i9 (4, 3) envelope_673_i9 + pivot_mem_673_i9 child_envelope_sub_673_i9 envelope_origin_673_i9 +def checked_673_i9 : CheckedCard where + required := required_673_i9 + envelope := envelope_673_i9 + height := height_673_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i9 +def height_673_i10 : ℕ := 5 +def childrenH_673_i10 : Fin 2 → ℕ := ![height_5, height_10] +theorem height_exact_673_i10 : height_673_i10 = 1 + Finset.univ.sup childrenH_673_i10 := by decide +kernel +theorem required_origin_673_i10 : ∀ x ∈ required_673_i10, + (∃ j, x ∈ childrenC_673_i10 j) ∨ ∀ j, x ∈ childrenD_673_i10 j := by decide +kernel +theorem required_exact_673_i10 : required_673_i10 = + ((Finset.univ.biUnion childrenC_673_i10) ∪ commonEnvelope childrenD_673_i10).erase (3, 4) := by + exact required_eq_combination childrenC_673_i10 childrenD_673_i10 (3, 4) required_673_i10 + (by decide +kernel) child_required_sub_673_i10 common_sub_673_i10 required_origin_673_i10 +theorem envelope_origin_673_i10 : ∀ x ∈ envelope_673_i10, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_673_i10 j := by decide +kernel +theorem envelope_exact_673_i10 : envelope_673_i10 = + insert (3, 4) (Finset.univ.biUnion childrenD_673_i10) := by + exact envelope_eq_combination childrenD_673_i10 (3, 4) envelope_673_i10 + pivot_mem_673_i10 child_envelope_sub_673_i10 envelope_origin_673_i10 +def checked_673_i10 : CheckedCard where + required := required_673_i10 + envelope := envelope_673_i10 + height := height_673_i10 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i10 +def height_673_i8 : ℕ := 7 +def childrenH_673_i8 : Fin 5 → ℕ := ![height_263, height_271, height_424, height_673_i9, height_673_i10] +theorem height_exact_673_i8 : height_673_i8 = 1 + Finset.univ.sup childrenH_673_i8 := by decide +kernel +theorem required_origin_673_i8 : ∀ x ∈ required_673_i8, + (∃ j, x ∈ childrenC_673_i8 j) ∨ ∀ j, x ∈ childrenD_673_i8 j := by decide +kernel +theorem required_exact_673_i8 : required_673_i8 = + ((Finset.univ.biUnion childrenC_673_i8) ∪ commonEnvelope childrenD_673_i8).erase (4, 5) := by + exact required_eq_combination childrenC_673_i8 childrenD_673_i8 (4, 5) required_673_i8 + (by decide +kernel) child_required_sub_673_i8 common_sub_673_i8 required_origin_673_i8 +theorem envelope_origin_673_i8 : ∀ x ∈ envelope_673_i8, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_673_i8 j := by decide +kernel +theorem envelope_exact_673_i8 : envelope_673_i8 = + insert (4, 5) (Finset.univ.biUnion childrenD_673_i8) := by + exact envelope_eq_combination childrenD_673_i8 (4, 5) envelope_673_i8 + pivot_mem_673_i8 child_envelope_sub_673_i8 envelope_origin_673_i8 +def checked_673_i8 : CheckedCard where + required := required_673_i8 + envelope := envelope_673_i8 + height := height_673_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i8 +def height_673_i7 : ℕ := 8 +def childrenH_673_i7 : Fin 2 → ℕ := ![height_30, height_673_i8] +theorem height_exact_673_i7 : height_673_i7 = 1 + Finset.univ.sup childrenH_673_i7 := by decide +kernel +theorem required_origin_673_i7 : ∀ x ∈ required_673_i7, + (∃ j, x ∈ childrenC_673_i7 j) ∨ ∀ j, x ∈ childrenD_673_i7 j := by decide +kernel +theorem required_exact_673_i7 : required_673_i7 = + ((Finset.univ.biUnion childrenC_673_i7) ∪ commonEnvelope childrenD_673_i7).erase (1, 4) := by + exact required_eq_combination childrenC_673_i7 childrenD_673_i7 (1, 4) required_673_i7 + (by decide +kernel) child_required_sub_673_i7 common_sub_673_i7 required_origin_673_i7 +theorem envelope_origin_673_i7 : ∀ x ∈ envelope_673_i7, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_673_i7 j := by decide +kernel +theorem envelope_exact_673_i7 : envelope_673_i7 = + insert (1, 4) (Finset.univ.biUnion childrenD_673_i7) := by + exact envelope_eq_combination childrenD_673_i7 (1, 4) envelope_673_i7 + pivot_mem_673_i7 child_envelope_sub_673_i7 envelope_origin_673_i7 +def checked_673_i7 : CheckedCard where + required := required_673_i7 + envelope := envelope_673_i7 + height := height_673_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673_i7 +def height_673 : ℕ := 9 +def childrenH_673 : Fin 5 → ℕ := ![height_673_i0, height_673_i1, height_673_i4, height_673_i5, height_673_i7] +theorem height_exact_673 : height_673 = 1 + Finset.univ.sup childrenH_673 := by decide +kernel +theorem required_origin_673 : ∀ x ∈ required_673, + (∃ j, x ∈ childrenC_673 j) ∨ ∀ j, x ∈ childrenD_673 j := by decide +kernel +theorem required_exact_673 : required_673 = + ((Finset.univ.biUnion childrenC_673) ∪ commonEnvelope childrenD_673).erase (4, 4) := by + exact required_eq_combination childrenC_673 childrenD_673 (4, 4) required_673 + (by decide +kernel) child_required_sub_673 common_sub_673 required_origin_673 +theorem envelope_origin_673 : ∀ x ∈ envelope_673, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_673 j := by decide +kernel +theorem envelope_exact_673 : envelope_673 = + insert (4, 4) (Finset.univ.biUnion childrenD_673) := by + exact envelope_eq_combination childrenD_673 (4, 4) envelope_673 + pivot_mem_673 child_envelope_sub_673 envelope_origin_673 +def checked_673 : CheckedCard where + required := required_673 + envelope := envelope_673 + height := height_673 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_673 +def height_686_i0 : ℕ := 7 +def childrenH_686_i0 : Fin 3 → ℕ := ![height_43, height_57, height_340] +theorem height_exact_686_i0 : height_686_i0 = 1 + Finset.univ.sup childrenH_686_i0 := by decide +kernel +theorem required_origin_686_i0 : ∀ x ∈ required_686_i0, + (∃ j, x ∈ childrenC_686_i0 j) ∨ ∀ j, x ∈ childrenD_686_i0 j := by decide +kernel +theorem required_exact_686_i0 : required_686_i0 = + ((Finset.univ.biUnion childrenC_686_i0) ∪ commonEnvelope childrenD_686_i0).erase (5, 4) := by + exact required_eq_combination childrenC_686_i0 childrenD_686_i0 (5, 4) required_686_i0 + (by decide +kernel) child_required_sub_686_i0 common_sub_686_i0 required_origin_686_i0 +theorem envelope_origin_686_i0 : ∀ x ∈ envelope_686_i0, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_686_i0 j := by decide +kernel +theorem envelope_exact_686_i0 : envelope_686_i0 = + insert (5, 4) (Finset.univ.biUnion childrenD_686_i0) := by + exact envelope_eq_combination childrenD_686_i0 (5, 4) envelope_686_i0 + pivot_mem_686_i0 child_envelope_sub_686_i0 envelope_origin_686_i0 +def checked_686_i0 : CheckedCard where + required := required_686_i0 + envelope := envelope_686_i0 + height := height_686_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_686_i0 +def height_686_i1 : ℕ := 8 +def childrenH_686_i1 : Fin 3 → ℕ := ![height_7, height_9, height_256] +theorem height_exact_686_i1 : height_686_i1 = 1 + Finset.univ.sup childrenH_686_i1 := by decide +kernel +theorem required_origin_686_i1 : ∀ x ∈ required_686_i1, + (∃ j, x ∈ childrenC_686_i1 j) ∨ ∀ j, x ∈ childrenD_686_i1 j := by decide +kernel +theorem required_exact_686_i1 : required_686_i1 = + ((Finset.univ.biUnion childrenC_686_i1) ∪ commonEnvelope childrenD_686_i1).erase (4, 2) := by + exact required_eq_combination childrenC_686_i1 childrenD_686_i1 (4, 2) required_686_i1 + (by decide +kernel) child_required_sub_686_i1 common_sub_686_i1 required_origin_686_i1 +theorem envelope_origin_686_i1 : ∀ x ∈ envelope_686_i1, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_686_i1 j := by decide +kernel +theorem envelope_exact_686_i1 : envelope_686_i1 = + insert (4, 2) (Finset.univ.biUnion childrenD_686_i1) := by + exact envelope_eq_combination childrenD_686_i1 (4, 2) envelope_686_i1 + pivot_mem_686_i1 child_envelope_sub_686_i1 envelope_origin_686_i1 +def checked_686_i1 : CheckedCard where + required := required_686_i1 + envelope := envelope_686_i1 + height := height_686_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_686_i1 +def height_686 : ℕ := 9 +def childrenH_686 : Fin 7 → ℕ := ![height_134, height_180, height_337, height_435, height_558, height_686_i0, height_686_i1] +theorem height_exact_686 : height_686 = 1 + Finset.univ.sup childrenH_686 := by decide +kernel +theorem required_origin_686 : ∀ x ∈ required_686, + (∃ j, x ∈ childrenC_686 j) ∨ ∀ j, x ∈ childrenD_686 j := by decide +kernel +theorem required_exact_686 : required_686 = + ((Finset.univ.biUnion childrenC_686) ∪ commonEnvelope childrenD_686).erase (4, 5) := by + exact required_eq_combination childrenC_686 childrenD_686 (4, 5) required_686 + (by decide +kernel) child_required_sub_686 common_sub_686 required_origin_686 +theorem envelope_origin_686 : ∀ x ∈ envelope_686, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_686 j := by decide +kernel +theorem envelope_exact_686 : envelope_686 = + insert (4, 5) (Finset.univ.biUnion childrenD_686) := by + exact envelope_eq_combination childrenD_686 (4, 5) envelope_686 + pivot_mem_686 child_envelope_sub_686 envelope_origin_686 +def checked_686 : CheckedCard where + required := required_686 + envelope := envelope_686 + height := height_686 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_686 +def height_688_i0 : ℕ := 8 +def childrenH_688_i0 : Fin 5 → ℕ := ![height_8, height_41, height_253, height_256, height_336] +theorem height_exact_688_i0 : height_688_i0 = 1 + Finset.univ.sup childrenH_688_i0 := by decide +kernel +theorem required_origin_688_i0 : ∀ x ∈ required_688_i0, + (∃ j, x ∈ childrenC_688_i0 j) ∨ ∀ j, x ∈ childrenD_688_i0 j := by decide +kernel +theorem required_exact_688_i0 : required_688_i0 = + ((Finset.univ.biUnion childrenC_688_i0) ∪ commonEnvelope childrenD_688_i0).erase (3, 4) := by + exact required_eq_combination childrenC_688_i0 childrenD_688_i0 (3, 4) required_688_i0 + (by decide +kernel) child_required_sub_688_i0 common_sub_688_i0 required_origin_688_i0 +theorem envelope_origin_688_i0 : ∀ x ∈ envelope_688_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_688_i0 j := by decide +kernel +theorem envelope_exact_688_i0 : envelope_688_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_688_i0) := by + exact envelope_eq_combination childrenD_688_i0 (3, 4) envelope_688_i0 + pivot_mem_688_i0 child_envelope_sub_688_i0 envelope_origin_688_i0 +def checked_688_i0 : CheckedCard where + required := required_688_i0 + envelope := envelope_688_i0 + height := height_688_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_688_i0 +def height_688 : ℕ := 9 +def childrenH_688 : Fin 2 → ℕ := ![height_0, height_688_i0] +theorem height_exact_688 : height_688 = 1 + Finset.univ.sup childrenH_688 := by decide +kernel +theorem required_origin_688 : ∀ x ∈ required_688, + (∃ j, x ∈ childrenC_688 j) ∨ ∀ j, x ∈ childrenD_688 j := by decide +kernel +theorem required_exact_688 : required_688 = + ((Finset.univ.biUnion childrenC_688) ∪ commonEnvelope childrenD_688).erase (1, 5) := by + exact required_eq_combination childrenC_688 childrenD_688 (1, 5) required_688 + (by decide +kernel) child_required_sub_688 common_sub_688 required_origin_688 +theorem envelope_origin_688 : ∀ x ∈ envelope_688, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_688 j := by decide +kernel +theorem envelope_exact_688 : envelope_688 = + insert (1, 5) (Finset.univ.biUnion childrenD_688) := by + exact envelope_eq_combination childrenD_688 (1, 5) envelope_688 + pivot_mem_688 child_envelope_sub_688 envelope_origin_688 +def checked_688 : CheckedCard where + required := required_688 + envelope := envelope_688 + height := height_688 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_688 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part01.lean new file mode 100644 index 0000000..d1fb2fb --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part01.lean @@ -0,0 +1,1028 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_399 : Finset Cell := ⟨(([(2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_399 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 4), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_399 : Fin 5 → Finset Cell := ![(placed21 0 (1, 1) required_12), (placed21 0 (0, 1) required_135), (placed21 1 (0, 2) required_181), required_396, (placed21 4 (0, 8) required_396)] +def childrenD_399 : Fin 5 → Finset Cell := ![(placed21 0 (1, 1) envelope_12), (placed21 0 (0, 1) envelope_135), (placed21 1 (0, 2) envelope_181), envelope_396, (placed21 4 (0, 8) envelope_396)] +theorem common_sub_399 : commonEnvelope childrenD_399 ⊆ insert (2, 5) required_399 := by decide +kernel +theorem child_required_sub_399 : ∀ j, childrenC_399 j ⊆ insert (2, 5) required_399 := by decide +kernel +theorem child_envelope_sub_399 : ∀ j, childrenD_399 j ⊆ envelope_399 := by decide +kernel +theorem pivot_mem_399 : (2, 5) ∈ envelope_399 := by decide +kernel +theorem children_work_399 : ∀ j, Template HasSnaky 9 (childrenC_399 j) (childrenD_399 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_135 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_181 1 (0, 2)).mono (by decide +kernel) + · exact row_works_396.mono (by decide +kernel) + · exact (placed21_template row_works_396 4 (0, 8)).mono (by decide +kernel) +theorem row_works_399 : Template HasSnaky 10 required_399 envelope_399 := by + refine compose HasSnaky 9 childrenC_399 childrenD_399 children_work_399 (2, 5) + required_399 envelope_399 pivot_mem_399 child_required_sub_399 child_envelope_sub_399 ?_ + intro b hb + exact common_sub_399 (mem_commonEnvelope childrenD_399 b hb) +def required_401 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_401 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 2), (7, 3), (7, 4), (7, 5), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_401 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) required_3), (placed21 4 (2, 7) required_397)] +def childrenD_401 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) envelope_3), (placed21 4 (2, 7) envelope_397)] +theorem common_sub_401 : commonEnvelope childrenD_401 ⊆ insert (2, 4) required_401 := by decide +kernel +theorem child_required_sub_401 : ∀ j, childrenC_401 j ⊆ insert (2, 4) required_401 := by decide +kernel +theorem child_envelope_sub_401 : ∀ j, childrenD_401 j ⊆ envelope_401 := by decide +kernel +theorem pivot_mem_401 : (2, 4) ∈ envelope_401 := by decide +kernel +theorem children_work_401 : ∀ j, Template HasSnaky 9 (childrenC_401 j) (childrenD_401 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 6 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_397 4 (2, 7)).mono (by decide +kernel) +theorem row_works_401 : Template HasSnaky 10 required_401 envelope_401 := by + refine compose HasSnaky 9 childrenC_401 childrenD_401 children_work_401 (2, 4) + required_401 envelope_401 pivot_mem_401 child_required_sub_401 child_envelope_sub_401 ?_ + intro b hb + exact common_sub_401 (mem_commonEnvelope childrenD_401 b hb) +def required_408 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_408 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_408 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) required_44), (placed21 0 (0, 1) required_127), (placed21 4 (0, 6) required_407)] +def childrenD_408 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) envelope_44), (placed21 0 (0, 1) envelope_127), (placed21 4 (0, 6) envelope_407)] +theorem common_sub_408 : commonEnvelope childrenD_408 ⊆ insert (1, 5) required_408 := by decide +kernel +theorem child_required_sub_408 : ∀ j, childrenC_408 j ⊆ insert (1, 5) required_408 := by decide +kernel +theorem child_envelope_sub_408 : ∀ j, childrenD_408 j ⊆ envelope_408 := by decide +kernel +theorem pivot_mem_408 : (1, 5) ∈ envelope_408 := by decide +kernel +theorem children_work_408 : ∀ j, Template HasSnaky 9 (childrenC_408 j) (childrenD_408 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_127 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_407 4 (0, 6)).mono (by decide +kernel) +theorem row_works_408 : Template HasSnaky 10 required_408 envelope_408 := by + refine compose HasSnaky 9 childrenC_408 childrenD_408 children_work_408 (1, 5) + required_408 envelope_408 pivot_mem_408 child_required_sub_408 child_envelope_sub_408 ?_ + intro b hb + exact common_sub_408 (mem_commonEnvelope childrenD_408 b hb) +def required_409 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_409 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_409 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) required_44), (placed21 0 (0, 1) required_127), (placed21 4 (0, 6) required_407)] +def childrenD_409 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) envelope_44), (placed21 0 (0, 1) envelope_127), (placed21 4 (0, 6) envelope_407)] +theorem common_sub_409 : commonEnvelope childrenD_409 ⊆ insert (1, 4) required_409 := by decide +kernel +theorem child_required_sub_409 : ∀ j, childrenC_409 j ⊆ insert (1, 4) required_409 := by decide +kernel +theorem child_envelope_sub_409 : ∀ j, childrenD_409 j ⊆ envelope_409 := by decide +kernel +theorem pivot_mem_409 : (1, 4) ∈ envelope_409 := by decide +kernel +theorem children_work_409 : ∀ j, Template HasSnaky 9 (childrenC_409 j) (childrenD_409 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_127 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_407 4 (0, 6)).mono (by decide +kernel) +theorem row_works_409 : Template HasSnaky 10 required_409 envelope_409 := by + refine compose HasSnaky 9 childrenC_409 childrenD_409 children_work_409 (1, 4) + required_409 envelope_409 pivot_mem_409 child_required_sub_409 child_envelope_sub_409 ?_ + intro b hb + exact common_sub_409 (mem_commonEnvelope childrenD_409 b hb) +def required_410 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_410 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 5), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_410 : Fin 4 → Finset Cell := ![(placed21 0 (0, 2) required_10), (placed21 2 (2, 1) required_12), (placed21 4 (0, 7) required_12), (placed21 4 (0, 6) required_407)] +def childrenD_410 : Fin 4 → Finset Cell := ![(placed21 0 (0, 2) envelope_10), (placed21 2 (2, 1) envelope_12), (placed21 4 (0, 7) envelope_12), (placed21 4 (0, 6) envelope_407)] +theorem common_sub_410 : commonEnvelope childrenD_410 ⊆ insert (1, 5) required_410 := by decide +kernel +theorem child_required_sub_410 : ∀ j, childrenC_410 j ⊆ insert (1, 5) required_410 := by decide +kernel +theorem child_envelope_sub_410 : ∀ j, childrenD_410 j ⊆ envelope_410 := by decide +kernel +theorem pivot_mem_410 : (1, 5) ∈ envelope_410 := by decide +kernel +theorem children_work_410 : ∀ j, Template HasSnaky 9 (childrenC_410 j) (childrenD_410 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_12 2 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_12 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_407 4 (0, 6)).mono (by decide +kernel) +theorem row_works_410 : Template HasSnaky 10 required_410 envelope_410 := by + refine compose HasSnaky 9 childrenC_410 childrenD_410 children_work_410 (1, 5) + required_410 envelope_410 pivot_mem_410 child_required_sub_410 child_envelope_sub_410 ?_ + intro b hb + exact common_sub_410 (mem_commonEnvelope childrenD_410 b hb) +def required_411 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_411 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_411 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) required_15), (placed21 4 (0, 7) required_65), (placed21 4 (0, 6) required_407)] +def childrenD_411 : Fin 3 → Finset Cell := ![(placed21 6 (1, 6) envelope_15), (placed21 4 (0, 7) envelope_65), (placed21 4 (0, 6) envelope_407)] +theorem common_sub_411 : commonEnvelope childrenD_411 ⊆ insert (1, 5) required_411 := by decide +kernel +theorem child_required_sub_411 : ∀ j, childrenC_411 j ⊆ insert (1, 5) required_411 := by decide +kernel +theorem child_envelope_sub_411 : ∀ j, childrenD_411 j ⊆ envelope_411 := by decide +kernel +theorem pivot_mem_411 : (1, 5) ∈ envelope_411 := by decide +kernel +theorem children_work_411 : ∀ j, Template HasSnaky 9 (childrenC_411 j) (childrenD_411 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 6 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_65 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_407 4 (0, 6)).mono (by decide +kernel) +theorem row_works_411 : Template HasSnaky 10 required_411 envelope_411 := by + refine compose HasSnaky 9 childrenC_411 childrenD_411 children_work_411 (1, 5) + required_411 envelope_411 pivot_mem_411 child_required_sub_411 child_envelope_sub_411 ?_ + intro b hb + exact common_sub_411 (mem_commonEnvelope childrenD_411 b hb) +def required_444 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_444 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_444 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) required_7), (placed21 1 (0, 1) required_8), (placed21 2 (2, 0) required_9), (placed21 4 (0, 5) required_443)] +def childrenD_444 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) envelope_7), (placed21 1 (0, 1) envelope_8), (placed21 2 (2, 0) envelope_9), (placed21 4 (0, 5) envelope_443)] +theorem common_sub_444 : commonEnvelope childrenD_444 ⊆ insert (1, 4) required_444 := by decide +kernel +theorem child_required_sub_444 : ∀ j, childrenC_444 j ⊆ insert (1, 4) required_444 := by decide +kernel +theorem child_envelope_sub_444 : ∀ j, childrenD_444 j ⊆ envelope_444 := by decide +kernel +theorem pivot_mem_444 : (1, 4) ∈ envelope_444 := by decide +kernel +theorem children_work_444 : ∀ j, Template HasSnaky 9 (childrenC_444 j) (childrenD_444 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_443 4 (0, 5)).mono (by decide +kernel) +theorem row_works_444 : Template HasSnaky 10 required_444 envelope_444 := by + refine compose HasSnaky 9 childrenC_444 childrenD_444 children_work_444 (1, 4) + required_444 envelope_444 pivot_mem_444 child_required_sub_444 child_envelope_sub_444 ?_ + intro b hb + exact common_sub_444 (mem_commonEnvelope childrenD_444 b hb) +def required_459 : Finset Cell := ⟨(([(1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_459 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_459 : Fin 8 → Finset Cell := ![(placed21 2 (2, 2) required_12), (placed21 2 (2, 2) required_13), (placed21 6 (2, 8) required_33), (placed21 2 (2, 2) required_189), (placed21 4 (0, 8) required_192), (placed21 2 (2, 1) required_369), (placed21 0 (0, 3) required_457), (placed21 4 (0, 7) required_458)] +def childrenD_459 : Fin 8 → Finset Cell := ![(placed21 2 (2, 2) envelope_12), (placed21 2 (2, 2) envelope_13), (placed21 6 (2, 8) envelope_33), (placed21 2 (2, 2) envelope_189), (placed21 4 (0, 8) envelope_192), (placed21 2 (2, 1) envelope_369), (placed21 0 (0, 3) envelope_457), (placed21 4 (0, 7) envelope_458)] +theorem common_sub_459 : commonEnvelope childrenD_459 ⊆ insert (1, 6) required_459 := by decide +kernel +theorem child_required_sub_459 : ∀ j, childrenC_459 j ⊆ insert (1, 6) required_459 := by decide +kernel +theorem child_envelope_sub_459 : ∀ j, childrenD_459 j ⊆ envelope_459 := by decide +kernel +theorem pivot_mem_459 : (1, 6) ∈ envelope_459 := by decide +kernel +theorem children_work_459 : ∀ j, Template HasSnaky 9 (childrenC_459 j) (childrenD_459 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_13 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_33 6 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_189 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_192 4 (0, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_369 2 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_457 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_458 4 (0, 7)).mono (by decide +kernel) +theorem row_works_459 : Template HasSnaky 10 required_459 envelope_459 := by + refine compose HasSnaky 9 childrenC_459 childrenD_459 children_work_459 (1, 6) + required_459 envelope_459 pivot_mem_459 child_required_sub_459 child_envelope_sub_459 ?_ + intro b hb + exact common_sub_459 (mem_commonEnvelope childrenD_459 b hb) +def required_460 : Finset Cell := ⟨(([(1, 3), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_460 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 6), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (5, 1), (5, 2), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_460 : Fin 5 → Finset Cell := ![(placed21 0 (0, 1) required_13), (placed21 2 (2, 1) required_14), (placed21 0 (0, 1) required_33), (placed21 4 (0, 6) required_457), (placed21 0 (0, 2) required_458)] +def childrenD_460 : Fin 5 → Finset Cell := ![(placed21 0 (0, 1) envelope_13), (placed21 2 (2, 1) envelope_14), (placed21 0 (0, 1) envelope_33), (placed21 4 (0, 6) envelope_457), (placed21 0 (0, 2) envelope_458)] +theorem common_sub_460 : commonEnvelope childrenD_460 ⊆ insert (1, 4) required_460 := by decide +kernel +theorem child_required_sub_460 : ∀ j, childrenC_460 j ⊆ insert (1, 4) required_460 := by decide +kernel +theorem child_envelope_sub_460 : ∀ j, childrenD_460 j ⊆ envelope_460 := by decide +kernel +theorem pivot_mem_460 : (1, 4) ∈ envelope_460 := by decide +kernel +theorem children_work_460 : ∀ j, Template HasSnaky 9 (childrenC_460 j) (childrenD_460 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_14 2 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_33 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_457 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_458 0 (0, 2)).mono (by decide +kernel) +theorem row_works_460 : Template HasSnaky 10 required_460 envelope_460 := by + refine compose HasSnaky 9 childrenC_460 childrenD_460 children_work_460 (1, 4) + required_460 envelope_460 pivot_mem_460 child_required_sub_460 child_envelope_sub_460 ?_ + intro b hb + exact common_sub_460 (mem_commonEnvelope childrenD_460 b hb) +def required_461 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 1), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_461 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (7, 3), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_461 : Fin 4 → Finset Cell := ![(placed21 5 (4, 1) required_28), required_100, required_429, (placed21 0 (2, 0) required_457)] +def childrenD_461 : Fin 4 → Finset Cell := ![(placed21 5 (4, 1) envelope_28), envelope_100, envelope_429, (placed21 0 (2, 0) envelope_457)] +theorem common_sub_461 : commonEnvelope childrenD_461 ⊆ insert (3, 3) required_461 := by decide +kernel +theorem child_required_sub_461 : ∀ j, childrenC_461 j ⊆ insert (3, 3) required_461 := by decide +kernel +theorem child_envelope_sub_461 : ∀ j, childrenD_461 j ⊆ envelope_461 := by decide +kernel +theorem pivot_mem_461 : (3, 3) ∈ envelope_461 := by decide +kernel +theorem children_work_461 : ∀ j, Template HasSnaky 9 (childrenC_461 j) (childrenD_461 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_28 5 (4, 1)).mono (by decide +kernel) + · exact row_works_100.mono (by decide +kernel) + · exact row_works_429.mono (by decide +kernel) + · exact (placed21_template row_works_457 0 (2, 0)).mono (by decide +kernel) +theorem row_works_461 : Template HasSnaky 10 required_461 envelope_461 := by + refine compose HasSnaky 9 childrenC_461 childrenD_461 children_work_461 (3, 3) + required_461 envelope_461 pivot_mem_461 child_required_sub_461 child_envelope_sub_461 ?_ + intro b hb + exact common_sub_461 (mem_commonEnvelope childrenD_461 b hb) +def required_475 : Finset Cell := ⟨(([(2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_475 : Finset Cell := ⟨(([(0, 5), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_475 : Fin 5 → Finset Cell := ![(placed21 4 (1, 7) required_13), (placed21 6 (3, 7) required_14), (placed21 4 (1, 7) required_31), (placed21 4 (0, 8) required_396), (placed21 1 (0, 2) required_474)] +def childrenD_475 : Fin 5 → Finset Cell := ![(placed21 4 (1, 7) envelope_13), (placed21 6 (3, 7) envelope_14), (placed21 4 (1, 7) envelope_31), (placed21 4 (0, 8) envelope_396), (placed21 1 (0, 2) envelope_474)] +theorem common_sub_475 : commonEnvelope childrenD_475 ⊆ insert (2, 5) required_475 := by decide +kernel +theorem child_required_sub_475 : ∀ j, childrenC_475 j ⊆ insert (2, 5) required_475 := by decide +kernel +theorem child_envelope_sub_475 : ∀ j, childrenD_475 j ⊆ envelope_475 := by decide +kernel +theorem pivot_mem_475 : (2, 5) ∈ envelope_475 := by decide +kernel +theorem children_work_475 : ∀ j, Template HasSnaky 9 (childrenC_475 j) (childrenD_475 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_14 6 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_31 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_396 4 (0, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_474 1 (0, 2)).mono (by decide +kernel) +theorem row_works_475 : Template HasSnaky 10 required_475 envelope_475 := by + refine compose HasSnaky 9 childrenC_475 childrenD_475 children_work_475 (2, 5) + required_475 envelope_475 pivot_mem_475 child_required_sub_475 child_envelope_sub_475 ?_ + intro b hb + exact common_sub_475 (mem_commonEnvelope childrenD_475 b hb) +def required_476 : Finset Cell := ⟨(([(1, 3), (1, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_476 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (6, 1), (6, 2), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_476 : Fin 5 → Finset Cell := ![(placed21 0 (2, 1) required_12), (placed21 2 (4, 1) required_12), (placed21 4 (2, 7) required_12), (placed21 2 (4, 2) required_264), (placed21 3 (1, 6) required_474)] +def childrenD_476 : Fin 5 → Finset Cell := ![(placed21 0 (2, 1) envelope_12), (placed21 2 (4, 1) envelope_12), (placed21 4 (2, 7) envelope_12), (placed21 2 (4, 2) envelope_264), (placed21 3 (1, 6) envelope_474)] +theorem common_sub_476 : commonEnvelope childrenD_476 ⊆ insert (3, 5) required_476 := by decide +kernel +theorem child_required_sub_476 : ∀ j, childrenC_476 j ⊆ insert (3, 5) required_476 := by decide +kernel +theorem child_envelope_sub_476 : ∀ j, childrenD_476 j ⊆ envelope_476 := by decide +kernel +theorem pivot_mem_476 : (3, 5) ∈ envelope_476 := by decide +kernel +theorem children_work_476 : ∀ j, Template HasSnaky 9 (childrenC_476 j) (childrenD_476 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_12 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_12 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_264 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_474 3 (1, 6)).mono (by decide +kernel) +theorem row_works_476 : Template HasSnaky 10 required_476 envelope_476 := by + refine compose HasSnaky 9 childrenC_476 childrenD_476 children_work_476 (3, 5) + required_476 envelope_476 pivot_mem_476 child_required_sub_476 child_envelope_sub_476 ?_ + intro b hb + exact common_sub_476 (mem_commonEnvelope childrenD_476 b hb) +def required_479_i0 : Finset Cell := ⟨(([(1, 4), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_479_i0 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_479_i0 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) required_8), (placed21 5 (5, 2) required_386)] +def childrenD_479_i0 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) envelope_8), (placed21 5 (5, 2) envelope_386)] +theorem common_sub_479_i0 : commonEnvelope childrenD_479_i0 ⊆ insert (3, 2) required_479_i0 := by decide +kernel +theorem child_required_sub_479_i0 : ∀ j, childrenC_479_i0 j ⊆ insert (3, 2) required_479_i0 := by decide +kernel +theorem child_envelope_sub_479_i0 : ∀ j, childrenD_479_i0 j ⊆ envelope_479_i0 := by decide +kernel +theorem pivot_mem_479_i0 : (3, 2) ∈ envelope_479_i0 := by decide +kernel +theorem children_work_479_i0 : ∀ j, Template HasSnaky 5 (childrenC_479_i0 j) (childrenD_479_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 7 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_386 5 (5, 2)).mono (by decide +kernel) +theorem row_works_479_i0 : Template HasSnaky 6 required_479_i0 envelope_479_i0 := by + refine compose HasSnaky 5 childrenC_479_i0 childrenD_479_i0 children_work_479_i0 (3, 2) + required_479_i0 envelope_479_i0 pivot_mem_479_i0 child_required_sub_479_i0 child_envelope_sub_479_i0 ?_ + intro b hb + exact common_sub_479_i0 (mem_commonEnvelope childrenD_479_i0 b hb) +def required_479 : Finset Cell := ⟨(([(1, 4), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_479 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_479 : Fin 7 → Finset Cell := ![(placed21 6 (4, 7) required_14), (placed21 4 (2, 7) required_31), (placed21 1 (1, 2) required_181), (placed21 4 (2, 7) required_367), required_479_i0, (placed21 5 (6, 2) required_435), (placed21 1 (1, 2) required_474)] +def childrenD_479 : Fin 7 → Finset Cell := ![(placed21 6 (4, 7) envelope_14), (placed21 4 (2, 7) envelope_31), (placed21 1 (1, 2) envelope_181), (placed21 4 (2, 7) envelope_367), envelope_479_i0, (placed21 5 (6, 2) envelope_435), (placed21 1 (1, 2) envelope_474)] +theorem common_sub_479 : commonEnvelope childrenD_479 ⊆ insert (3, 5) required_479 := by decide +kernel +theorem child_required_sub_479 : ∀ j, childrenC_479 j ⊆ insert (3, 5) required_479 := by decide +kernel +theorem child_envelope_sub_479 : ∀ j, childrenD_479 j ⊆ envelope_479 := by decide +kernel +theorem pivot_mem_479 : (3, 5) ∈ envelope_479 := by decide +kernel +theorem children_work_479 : ∀ j, Template HasSnaky 9 (childrenC_479 j) (childrenD_479 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_31 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_181 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_367 4 (2, 7)).mono (by decide +kernel) + · exact row_works_479_i0.mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_474 1 (1, 2)).mono (by decide +kernel) +theorem row_works_479 : Template HasSnaky 10 required_479 envelope_479 := by + refine compose HasSnaky 9 childrenC_479 childrenD_479 children_work_479 (3, 5) + required_479 envelope_479 pivot_mem_479 child_required_sub_479 child_envelope_sub_479 ?_ + intro b hb + exact common_sub_479 (mem_commonEnvelope childrenD_479 b hb) +def required_480 : Finset Cell := ⟨(([(3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_480 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 2), (5, 3), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_480 : Fin 7 → Finset Cell := ![(placed21 4 (2, 7) required_13), (placed21 4 (2, 7) required_14), (placed21 2 (4, 1) required_192), (placed21 1 (0, 1) required_298), (placed21 7 (6, 6) required_435), (placed21 7 (5, 6) required_474), (placed21 5 (5, 2) required_477)] +def childrenD_480 : Fin 7 → Finset Cell := ![(placed21 4 (2, 7) envelope_13), (placed21 4 (2, 7) envelope_14), (placed21 2 (4, 1) envelope_192), (placed21 1 (0, 1) envelope_298), (placed21 7 (6, 6) envelope_435), (placed21 7 (5, 6) envelope_474), (placed21 5 (5, 2) envelope_477)] +theorem common_sub_480 : commonEnvelope childrenD_480 ⊆ insert (3, 3) required_480 := by decide +kernel +theorem child_required_sub_480 : ∀ j, childrenC_480 j ⊆ insert (3, 3) required_480 := by decide +kernel +theorem child_envelope_sub_480 : ∀ j, childrenD_480 j ⊆ envelope_480 := by decide +kernel +theorem pivot_mem_480 : (3, 3) ∈ envelope_480 := by decide +kernel +theorem children_work_480 : ∀ j, Template HasSnaky 9 (childrenC_480 j) (childrenD_480 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_14 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_192 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_298 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_435 7 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_474 7 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_477 5 (5, 2)).mono (by decide +kernel) +theorem row_works_480 : Template HasSnaky 10 required_480 envelope_480 := by + refine compose HasSnaky 9 childrenC_480 childrenD_480 children_work_480 (3, 3) + required_480 envelope_480 pivot_mem_480 child_required_sub_480 child_envelope_sub_480 ?_ + intro b hb + exact common_sub_480 (mem_commonEnvelope childrenD_480 b hb) +def required_481 : Finset Cell := ⟨(([(2, 3), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_481 : Finset Cell := ⟨(([(0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_481 : Fin 5 → Finset Cell := ![(placed21 0 (1, 1) required_13), (placed21 2 (3, 1) required_14), (placed21 0 (1, 1) required_33), (placed21 4 (1, 6) required_457), (placed21 1 (0, 2) required_477)] +def childrenD_481 : Fin 5 → Finset Cell := ![(placed21 0 (1, 1) envelope_13), (placed21 2 (3, 1) envelope_14), (placed21 0 (1, 1) envelope_33), (placed21 4 (1, 6) envelope_457), (placed21 1 (0, 2) envelope_477)] +theorem common_sub_481 : commonEnvelope childrenD_481 ⊆ insert (2, 4) required_481 := by decide +kernel +theorem child_required_sub_481 : ∀ j, childrenC_481 j ⊆ insert (2, 4) required_481 := by decide +kernel +theorem child_envelope_sub_481 : ∀ j, childrenD_481 j ⊆ envelope_481 := by decide +kernel +theorem pivot_mem_481 : (2, 4) ∈ envelope_481 := by decide +kernel +theorem children_work_481 : ∀ j, Template HasSnaky 9 (childrenC_481 j) (childrenD_481 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_14 2 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_33 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_457 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_477 1 (0, 2)).mono (by decide +kernel) +theorem row_works_481 : Template HasSnaky 10 required_481 envelope_481 := by + refine compose HasSnaky 9 childrenC_481 childrenD_481 children_work_481 (2, 4) + required_481 envelope_481 pivot_mem_481 child_required_sub_481 child_envelope_sub_481 ?_ + intro b hb + exact common_sub_481 (mem_commonEnvelope childrenD_481 b hb) +def required_483 : Finset Cell := ⟨(([(2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_483 : Finset Cell := ⟨(([(0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_483 : Fin 5 → Finset Cell := ![(placed21 0 (1, 1) required_13), (placed21 2 (3, 1) required_14), (placed21 0 (1, 1) required_33), (placed21 0 (1, 2) required_458), (placed21 3 (0, 6) required_474)] +def childrenD_483 : Fin 5 → Finset Cell := ![(placed21 0 (1, 1) envelope_13), (placed21 2 (3, 1) envelope_14), (placed21 0 (1, 1) envelope_33), (placed21 0 (1, 2) envelope_458), (placed21 3 (0, 6) envelope_474)] +theorem common_sub_483 : commonEnvelope childrenD_483 ⊆ insert (2, 5) required_483 := by decide +kernel +theorem child_required_sub_483 : ∀ j, childrenC_483 j ⊆ insert (2, 5) required_483 := by decide +kernel +theorem child_envelope_sub_483 : ∀ j, childrenD_483 j ⊆ envelope_483 := by decide +kernel +theorem pivot_mem_483 : (2, 5) ∈ envelope_483 := by decide +kernel +theorem children_work_483 : ∀ j, Template HasSnaky 9 (childrenC_483 j) (childrenD_483 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_14 2 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_33 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_458 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_474 3 (0, 6)).mono (by decide +kernel) +theorem row_works_483 : Template HasSnaky 10 required_483 envelope_483 := by + refine compose HasSnaky 9 childrenC_483 childrenD_483 children_work_483 (2, 5) + required_483 envelope_483 pivot_mem_483 child_required_sub_483 child_envelope_sub_483 ?_ + intro b hb + exact common_sub_483 (mem_commonEnvelope childrenD_483 b hb) +def required_491_i0 : Finset Cell := ⟨(([(1, 2), (3, 3), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_491_i0 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (5, 3), (5, 4), (6, 3), (6, 4), (7, 4), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_491_i0 : Fin 4 → Finset Cell := ![(placed21 3 (2, 4) required_60), (placed21 7 (6, 4) required_60), (placed21 4 (3, 4) required_83), (placed21 1 (1, 2) required_106)] +def childrenD_491_i0 : Fin 4 → Finset Cell := ![(placed21 3 (2, 4) envelope_60), (placed21 7 (6, 4) envelope_60), (placed21 4 (3, 4) envelope_83), (placed21 1 (1, 2) envelope_106)] +theorem common_sub_491_i0 : commonEnvelope childrenD_491_i0 ⊆ insert (5, 3) required_491_i0 := by decide +kernel +theorem child_required_sub_491_i0 : ∀ j, childrenC_491_i0 j ⊆ insert (5, 3) required_491_i0 := by decide +kernel +theorem child_envelope_sub_491_i0 : ∀ j, childrenD_491_i0 j ⊆ envelope_491_i0 := by decide +kernel +theorem pivot_mem_491_i0 : (5, 3) ∈ envelope_491_i0 := by decide +kernel +theorem children_work_491_i0 : ∀ j, Template HasSnaky 4 (childrenC_491_i0 j) (childrenD_491_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_60 3 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_60 7 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_83 4 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_106 1 (1, 2)).mono (by decide +kernel) +theorem row_works_491_i0 : Template HasSnaky 5 required_491_i0 envelope_491_i0 := by + refine compose HasSnaky 4 childrenC_491_i0 childrenD_491_i0 children_work_491_i0 (5, 3) + required_491_i0 envelope_491_i0 pivot_mem_491_i0 child_required_sub_491_i0 child_envelope_sub_491_i0 ?_ + intro b hb + exact common_sub_491_i0 (mem_commonEnvelope childrenD_491_i0 b hb) +def required_491_i1 : Finset Cell := ⟨(([(1, 2), (3, 3), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_491_i1 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 1), (5, 3), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (8, 2), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_491_i1 : Fin 3 → Finset Cell := ![(placed21 3 (2, 4) required_60), (placed21 7 (5, 3) required_70), (placed21 4 (2, 5) required_345)] +def childrenD_491_i1 : Fin 3 → Finset Cell := ![(placed21 3 (2, 4) envelope_60), (placed21 7 (5, 3) envelope_70), (placed21 4 (2, 5) envelope_345)] +theorem common_sub_491_i1 : commonEnvelope childrenD_491_i1 ⊆ insert (5, 3) required_491_i1 := by decide +kernel +theorem child_required_sub_491_i1 : ∀ j, childrenC_491_i1 j ⊆ insert (5, 3) required_491_i1 := by decide +kernel +theorem child_envelope_sub_491_i1 : ∀ j, childrenD_491_i1 j ⊆ envelope_491_i1 := by decide +kernel +theorem pivot_mem_491_i1 : (5, 3) ∈ envelope_491_i1 := by decide +kernel +theorem children_work_491_i1 : ∀ j, Template HasSnaky 8 (childrenC_491_i1 j) (childrenD_491_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_60 3 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_70 7 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_345 4 (2, 5)).mono (by decide +kernel) +theorem row_works_491_i1 : Template HasSnaky 9 required_491_i1 envelope_491_i1 := by + refine compose HasSnaky 8 childrenC_491_i1 childrenD_491_i1 children_work_491_i1 (5, 3) + required_491_i1 envelope_491_i1 pivot_mem_491_i1 child_required_sub_491_i1 child_envelope_sub_491_i1 ?_ + intro b hb + exact common_sub_491_i1 (mem_commonEnvelope childrenD_491_i1 b hb) +def required_491 : Finset Cell := ⟨(([(1, 2), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_491 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 4), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (5, 0), (5, 1), (5, 3), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (8, 2), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_491 : Fin 4 → Finset Cell := ![(placed21 2 (4, 0) required_44), (placed21 0 (1, 1) required_270), required_491_i0, required_491_i1] +def childrenD_491 : Fin 4 → Finset Cell := ![(placed21 2 (4, 0) envelope_44), (placed21 0 (1, 1) envelope_270), envelope_491_i0, envelope_491_i1] +theorem common_sub_491 : commonEnvelope childrenD_491 ⊆ insert (3, 3) required_491 := by decide +kernel +theorem child_required_sub_491 : ∀ j, childrenC_491 j ⊆ insert (3, 3) required_491 := by decide +kernel +theorem child_envelope_sub_491 : ∀ j, childrenD_491 j ⊆ envelope_491 := by decide +kernel +theorem pivot_mem_491 : (3, 3) ∈ envelope_491 := by decide +kernel +theorem children_work_491 : ∀ j, Template HasSnaky 9 (childrenC_491 j) (childrenD_491 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_270 0 (1, 1)).mono (by decide +kernel) + · exact row_works_491_i0.mono (by decide +kernel) + · exact row_works_491_i1.mono (by decide +kernel) +theorem row_works_491 : Template HasSnaky 10 required_491 envelope_491 := by + refine compose HasSnaky 9 childrenC_491 childrenD_491 children_work_491 (3, 3) + required_491 envelope_491 pivot_mem_491 child_required_sub_491 child_envelope_sub_491 ?_ + intro b hb + exact common_sub_491 (mem_commonEnvelope childrenD_491 b hb) +def required_508 : Finset Cell := ⟨(([(2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_508 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_508 : Fin 7 → Finset Cell := ![(placed21 1 (0, 2) required_12), (placed21 1 (0, 2) required_13), (placed21 1 (0, 2) required_14), required_297, required_298, (placed21 4 (1, 5) required_474), (placed21 0 (1, 0) required_507)] +def childrenD_508 : Fin 7 → Finset Cell := ![(placed21 1 (0, 2) envelope_12), (placed21 1 (0, 2) envelope_13), (placed21 1 (0, 2) envelope_14), envelope_297, envelope_298, (placed21 4 (1, 5) envelope_474), (placed21 0 (1, 0) envelope_507)] +theorem common_sub_508 : commonEnvelope childrenD_508 ⊆ insert (4, 3) required_508 := by decide +kernel +theorem child_required_sub_508 : ∀ j, childrenC_508 j ⊆ insert (4, 3) required_508 := by decide +kernel +theorem child_envelope_sub_508 : ∀ j, childrenD_508 j ⊆ envelope_508 := by decide +kernel +theorem pivot_mem_508 : (4, 3) ∈ envelope_508 := by decide +kernel +theorem children_work_508 : ∀ j, Template HasSnaky 9 (childrenC_508 j) (childrenD_508 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_13 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_14 1 (0, 2)).mono (by decide +kernel) + · exact row_works_297.mono (by decide +kernel) + · exact row_works_298.mono (by decide +kernel) + · exact (placed21_template row_works_474 4 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_507 0 (1, 0)).mono (by decide +kernel) +theorem row_works_508 : Template HasSnaky 10 required_508 envelope_508 := by + refine compose HasSnaky 9 childrenC_508 childrenD_508 children_work_508 (4, 3) + required_508 envelope_508 pivot_mem_508 child_required_sub_508 child_envelope_sub_508 ?_ + intro b hb + exact common_sub_508 (mem_commonEnvelope childrenD_508 b hb) +def required_509 : Finset Cell := ⟨(([(2, 2), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_509 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_509 : Fin 5 → Finset Cell := ![(placed21 3 (0, 4) required_12), (placed21 1 (0, 2) required_127), (placed21 1 (0, 2) required_128), (placed21 0 (1, 1) required_474), (placed21 0 (1, 0) required_507)] +def childrenD_509 : Fin 5 → Finset Cell := ![(placed21 3 (0, 4) envelope_12), (placed21 1 (0, 2) envelope_127), (placed21 1 (0, 2) envelope_128), (placed21 0 (1, 1) envelope_474), (placed21 0 (1, 0) envelope_507)] +theorem common_sub_509 : commonEnvelope childrenD_509 ⊆ insert (4, 3) required_509 := by decide +kernel +theorem child_required_sub_509 : ∀ j, childrenC_509 j ⊆ insert (4, 3) required_509 := by decide +kernel +theorem child_envelope_sub_509 : ∀ j, childrenD_509 j ⊆ envelope_509 := by decide +kernel +theorem pivot_mem_509 : (4, 3) ∈ envelope_509 := by decide +kernel +theorem children_work_509 : ∀ j, Template HasSnaky 9 (childrenC_509 j) (childrenD_509 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_127 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_128 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_474 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_507 0 (1, 0)).mono (by decide +kernel) +theorem row_works_509 : Template HasSnaky 10 required_509 envelope_509 := by + refine compose HasSnaky 9 childrenC_509 childrenD_509 children_work_509 (4, 3) + required_509 envelope_509 pivot_mem_509 child_required_sub_509 child_envelope_sub_509 ?_ + intro b hb + exact common_sub_509 (mem_commonEnvelope childrenD_509 b hb) +def required_520 : Finset Cell := ⟨(([(3, 5), (3, 6), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_520 : Finset Cell := ⟨(([(0, 4), (0, 7), (1, 4), (1, 7), (2, 1), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (4, 10), (5, 5), (5, 8), (6, 4), (6, 5), (6, 6), (6, 8), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_520 : Fin 3 → Finset Cell := ![(placed21 3 (2, 6) required_10), (placed21 6 (6, 9) required_317), (placed21 2 (6, 2) required_519)] +def childrenD_520 : Fin 3 → Finset Cell := ![(placed21 3 (2, 6) envelope_10), (placed21 6 (6, 9) envelope_317), (placed21 2 (6, 2) envelope_519)] +theorem common_sub_520 : commonEnvelope childrenD_520 ⊆ insert (4, 5) required_520 := by decide +kernel +theorem child_required_sub_520 : ∀ j, childrenC_520 j ⊆ insert (4, 5) required_520 := by decide +kernel +theorem child_envelope_sub_520 : ∀ j, childrenD_520 j ⊆ envelope_520 := by decide +kernel +theorem pivot_mem_520 : (4, 5) ∈ envelope_520 := by decide +kernel +theorem children_work_520 : ∀ j, Template HasSnaky 9 (childrenC_520 j) (childrenD_520 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 3 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_317 6 (6, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_519 2 (6, 2)).mono (by decide +kernel) +theorem row_works_520 : Template HasSnaky 10 required_520 envelope_520 := by + refine compose HasSnaky 9 childrenC_520 childrenD_520 children_work_520 (4, 5) + required_520 envelope_520 pivot_mem_520 child_required_sub_520 child_envelope_sub_520 ?_ + intro b hb + exact common_sub_520 (mem_commonEnvelope childrenD_520 b hb) +def height_399 : ℕ := 10 +def childrenH_399 : Fin 5 → ℕ := ![height_12, height_135, height_181, height_396, height_396] +theorem height_exact_399 : height_399 = 1 + Finset.univ.sup childrenH_399 := by decide +kernel +theorem required_origin_399 : ∀ x ∈ required_399, + (∃ j, x ∈ childrenC_399 j) ∨ ∀ j, x ∈ childrenD_399 j := by decide +kernel +theorem required_exact_399 : required_399 = + ((Finset.univ.biUnion childrenC_399) ∪ commonEnvelope childrenD_399).erase (2, 5) := by + exact required_eq_combination childrenC_399 childrenD_399 (2, 5) required_399 + (by decide +kernel) child_required_sub_399 common_sub_399 required_origin_399 +theorem envelope_origin_399 : ∀ x ∈ envelope_399, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_399 j := by decide +kernel +theorem envelope_exact_399 : envelope_399 = + insert (2, 5) (Finset.univ.biUnion childrenD_399) := by + exact envelope_eq_combination childrenD_399 (2, 5) envelope_399 + pivot_mem_399 child_envelope_sub_399 envelope_origin_399 +def checked_399 : CheckedCard where + required := required_399 + envelope := envelope_399 + height := height_399 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_399 +def height_401 : ℕ := 10 +def childrenH_401 : Fin 2 → ℕ := ![height_3, height_397] +theorem height_exact_401 : height_401 = 1 + Finset.univ.sup childrenH_401 := by decide +kernel +theorem required_origin_401 : ∀ x ∈ required_401, + (∃ j, x ∈ childrenC_401 j) ∨ ∀ j, x ∈ childrenD_401 j := by decide +kernel +theorem required_exact_401 : required_401 = + ((Finset.univ.biUnion childrenC_401) ∪ commonEnvelope childrenD_401).erase (2, 4) := by + exact required_eq_combination childrenC_401 childrenD_401 (2, 4) required_401 + (by decide +kernel) child_required_sub_401 common_sub_401 required_origin_401 +theorem envelope_origin_401 : ∀ x ∈ envelope_401, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_401 j := by decide +kernel +theorem envelope_exact_401 : envelope_401 = + insert (2, 4) (Finset.univ.biUnion childrenD_401) := by + exact envelope_eq_combination childrenD_401 (2, 4) envelope_401 + pivot_mem_401 child_envelope_sub_401 envelope_origin_401 +def checked_401 : CheckedCard where + required := required_401 + envelope := envelope_401 + height := height_401 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_401 +def height_408 : ℕ := 10 +def childrenH_408 : Fin 3 → ℕ := ![height_44, height_127, height_407] +theorem height_exact_408 : height_408 = 1 + Finset.univ.sup childrenH_408 := by decide +kernel +theorem required_origin_408 : ∀ x ∈ required_408, + (∃ j, x ∈ childrenC_408 j) ∨ ∀ j, x ∈ childrenD_408 j := by decide +kernel +theorem required_exact_408 : required_408 = + ((Finset.univ.biUnion childrenC_408) ∪ commonEnvelope childrenD_408).erase (1, 5) := by + exact required_eq_combination childrenC_408 childrenD_408 (1, 5) required_408 + (by decide +kernel) child_required_sub_408 common_sub_408 required_origin_408 +theorem envelope_origin_408 : ∀ x ∈ envelope_408, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_408 j := by decide +kernel +theorem envelope_exact_408 : envelope_408 = + insert (1, 5) (Finset.univ.biUnion childrenD_408) := by + exact envelope_eq_combination childrenD_408 (1, 5) envelope_408 + pivot_mem_408 child_envelope_sub_408 envelope_origin_408 +def checked_408 : CheckedCard where + required := required_408 + envelope := envelope_408 + height := height_408 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_408 +def height_409 : ℕ := 10 +def childrenH_409 : Fin 3 → ℕ := ![height_44, height_127, height_407] +theorem height_exact_409 : height_409 = 1 + Finset.univ.sup childrenH_409 := by decide +kernel +theorem required_origin_409 : ∀ x ∈ required_409, + (∃ j, x ∈ childrenC_409 j) ∨ ∀ j, x ∈ childrenD_409 j := by decide +kernel +theorem required_exact_409 : required_409 = + ((Finset.univ.biUnion childrenC_409) ∪ commonEnvelope childrenD_409).erase (1, 4) := by + exact required_eq_combination childrenC_409 childrenD_409 (1, 4) required_409 + (by decide +kernel) child_required_sub_409 common_sub_409 required_origin_409 +theorem envelope_origin_409 : ∀ x ∈ envelope_409, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_409 j := by decide +kernel +theorem envelope_exact_409 : envelope_409 = + insert (1, 4) (Finset.univ.biUnion childrenD_409) := by + exact envelope_eq_combination childrenD_409 (1, 4) envelope_409 + pivot_mem_409 child_envelope_sub_409 envelope_origin_409 +def checked_409 : CheckedCard where + required := required_409 + envelope := envelope_409 + height := height_409 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_409 +def height_410 : ℕ := 10 +def childrenH_410 : Fin 4 → ℕ := ![height_10, height_12, height_12, height_407] +theorem height_exact_410 : height_410 = 1 + Finset.univ.sup childrenH_410 := by decide +kernel +theorem required_origin_410 : ∀ x ∈ required_410, + (∃ j, x ∈ childrenC_410 j) ∨ ∀ j, x ∈ childrenD_410 j := by decide +kernel +theorem required_exact_410 : required_410 = + ((Finset.univ.biUnion childrenC_410) ∪ commonEnvelope childrenD_410).erase (1, 5) := by + exact required_eq_combination childrenC_410 childrenD_410 (1, 5) required_410 + (by decide +kernel) child_required_sub_410 common_sub_410 required_origin_410 +theorem envelope_origin_410 : ∀ x ∈ envelope_410, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_410 j := by decide +kernel +theorem envelope_exact_410 : envelope_410 = + insert (1, 5) (Finset.univ.biUnion childrenD_410) := by + exact envelope_eq_combination childrenD_410 (1, 5) envelope_410 + pivot_mem_410 child_envelope_sub_410 envelope_origin_410 +def checked_410 : CheckedCard where + required := required_410 + envelope := envelope_410 + height := height_410 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_410 +def height_411 : ℕ := 10 +def childrenH_411 : Fin 3 → ℕ := ![height_15, height_65, height_407] +theorem height_exact_411 : height_411 = 1 + Finset.univ.sup childrenH_411 := by decide +kernel +theorem required_origin_411 : ∀ x ∈ required_411, + (∃ j, x ∈ childrenC_411 j) ∨ ∀ j, x ∈ childrenD_411 j := by decide +kernel +theorem required_exact_411 : required_411 = + ((Finset.univ.biUnion childrenC_411) ∪ commonEnvelope childrenD_411).erase (1, 5) := by + exact required_eq_combination childrenC_411 childrenD_411 (1, 5) required_411 + (by decide +kernel) child_required_sub_411 common_sub_411 required_origin_411 +theorem envelope_origin_411 : ∀ x ∈ envelope_411, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_411 j := by decide +kernel +theorem envelope_exact_411 : envelope_411 = + insert (1, 5) (Finset.univ.biUnion childrenD_411) := by + exact envelope_eq_combination childrenD_411 (1, 5) envelope_411 + pivot_mem_411 child_envelope_sub_411 envelope_origin_411 +def checked_411 : CheckedCard where + required := required_411 + envelope := envelope_411 + height := height_411 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_411 +def height_444 : ℕ := 10 +def childrenH_444 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_443] +theorem height_exact_444 : height_444 = 1 + Finset.univ.sup childrenH_444 := by decide +kernel +theorem required_origin_444 : ∀ x ∈ required_444, + (∃ j, x ∈ childrenC_444 j) ∨ ∀ j, x ∈ childrenD_444 j := by decide +kernel +theorem required_exact_444 : required_444 = + ((Finset.univ.biUnion childrenC_444) ∪ commonEnvelope childrenD_444).erase (1, 4) := by + exact required_eq_combination childrenC_444 childrenD_444 (1, 4) required_444 + (by decide +kernel) child_required_sub_444 common_sub_444 required_origin_444 +theorem envelope_origin_444 : ∀ x ∈ envelope_444, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_444 j := by decide +kernel +theorem envelope_exact_444 : envelope_444 = + insert (1, 4) (Finset.univ.biUnion childrenD_444) := by + exact envelope_eq_combination childrenD_444 (1, 4) envelope_444 + pivot_mem_444 child_envelope_sub_444 envelope_origin_444 +def checked_444 : CheckedCard where + required := required_444 + envelope := envelope_444 + height := height_444 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_444 +def height_459 : ℕ := 10 +def childrenH_459 : Fin 8 → ℕ := ![height_12, height_13, height_33, height_189, height_192, height_369, height_457, height_458] +theorem height_exact_459 : height_459 = 1 + Finset.univ.sup childrenH_459 := by decide +kernel +theorem required_origin_459 : ∀ x ∈ required_459, + (∃ j, x ∈ childrenC_459 j) ∨ ∀ j, x ∈ childrenD_459 j := by decide +kernel +theorem required_exact_459 : required_459 = + ((Finset.univ.biUnion childrenC_459) ∪ commonEnvelope childrenD_459).erase (1, 6) := by + exact required_eq_combination childrenC_459 childrenD_459 (1, 6) required_459 + (by decide +kernel) child_required_sub_459 common_sub_459 required_origin_459 +theorem envelope_origin_459 : ∀ x ∈ envelope_459, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_459 j := by decide +kernel +theorem envelope_exact_459 : envelope_459 = + insert (1, 6) (Finset.univ.biUnion childrenD_459) := by + exact envelope_eq_combination childrenD_459 (1, 6) envelope_459 + pivot_mem_459 child_envelope_sub_459 envelope_origin_459 +def checked_459 : CheckedCard where + required := required_459 + envelope := envelope_459 + height := height_459 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_459 +def height_460 : ℕ := 10 +def childrenH_460 : Fin 5 → ℕ := ![height_13, height_14, height_33, height_457, height_458] +theorem height_exact_460 : height_460 = 1 + Finset.univ.sup childrenH_460 := by decide +kernel +theorem required_origin_460 : ∀ x ∈ required_460, + (∃ j, x ∈ childrenC_460 j) ∨ ∀ j, x ∈ childrenD_460 j := by decide +kernel +theorem required_exact_460 : required_460 = + ((Finset.univ.biUnion childrenC_460) ∪ commonEnvelope childrenD_460).erase (1, 4) := by + exact required_eq_combination childrenC_460 childrenD_460 (1, 4) required_460 + (by decide +kernel) child_required_sub_460 common_sub_460 required_origin_460 +theorem envelope_origin_460 : ∀ x ∈ envelope_460, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_460 j := by decide +kernel +theorem envelope_exact_460 : envelope_460 = + insert (1, 4) (Finset.univ.biUnion childrenD_460) := by + exact envelope_eq_combination childrenD_460 (1, 4) envelope_460 + pivot_mem_460 child_envelope_sub_460 envelope_origin_460 +def checked_460 : CheckedCard where + required := required_460 + envelope := envelope_460 + height := height_460 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_460 +def height_461 : ℕ := 10 +def childrenH_461 : Fin 4 → ℕ := ![height_28, height_100, height_429, height_457] +theorem height_exact_461 : height_461 = 1 + Finset.univ.sup childrenH_461 := by decide +kernel +theorem required_origin_461 : ∀ x ∈ required_461, + (∃ j, x ∈ childrenC_461 j) ∨ ∀ j, x ∈ childrenD_461 j := by decide +kernel +theorem required_exact_461 : required_461 = + ((Finset.univ.biUnion childrenC_461) ∪ commonEnvelope childrenD_461).erase (3, 3) := by + exact required_eq_combination childrenC_461 childrenD_461 (3, 3) required_461 + (by decide +kernel) child_required_sub_461 common_sub_461 required_origin_461 +theorem envelope_origin_461 : ∀ x ∈ envelope_461, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_461 j := by decide +kernel +theorem envelope_exact_461 : envelope_461 = + insert (3, 3) (Finset.univ.biUnion childrenD_461) := by + exact envelope_eq_combination childrenD_461 (3, 3) envelope_461 + pivot_mem_461 child_envelope_sub_461 envelope_origin_461 +def checked_461 : CheckedCard where + required := required_461 + envelope := envelope_461 + height := height_461 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_461 +def height_475 : ℕ := 10 +def childrenH_475 : Fin 5 → ℕ := ![height_13, height_14, height_31, height_396, height_474] +theorem height_exact_475 : height_475 = 1 + Finset.univ.sup childrenH_475 := by decide +kernel +theorem required_origin_475 : ∀ x ∈ required_475, + (∃ j, x ∈ childrenC_475 j) ∨ ∀ j, x ∈ childrenD_475 j := by decide +kernel +theorem required_exact_475 : required_475 = + ((Finset.univ.biUnion childrenC_475) ∪ commonEnvelope childrenD_475).erase (2, 5) := by + exact required_eq_combination childrenC_475 childrenD_475 (2, 5) required_475 + (by decide +kernel) child_required_sub_475 common_sub_475 required_origin_475 +theorem envelope_origin_475 : ∀ x ∈ envelope_475, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_475 j := by decide +kernel +theorem envelope_exact_475 : envelope_475 = + insert (2, 5) (Finset.univ.biUnion childrenD_475) := by + exact envelope_eq_combination childrenD_475 (2, 5) envelope_475 + pivot_mem_475 child_envelope_sub_475 envelope_origin_475 +def checked_475 : CheckedCard where + required := required_475 + envelope := envelope_475 + height := height_475 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_475 +def height_476 : ℕ := 10 +def childrenH_476 : Fin 5 → ℕ := ![height_12, height_12, height_12, height_264, height_474] +theorem height_exact_476 : height_476 = 1 + Finset.univ.sup childrenH_476 := by decide +kernel +theorem required_origin_476 : ∀ x ∈ required_476, + (∃ j, x ∈ childrenC_476 j) ∨ ∀ j, x ∈ childrenD_476 j := by decide +kernel +theorem required_exact_476 : required_476 = + ((Finset.univ.biUnion childrenC_476) ∪ commonEnvelope childrenD_476).erase (3, 5) := by + exact required_eq_combination childrenC_476 childrenD_476 (3, 5) required_476 + (by decide +kernel) child_required_sub_476 common_sub_476 required_origin_476 +theorem envelope_origin_476 : ∀ x ∈ envelope_476, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_476 j := by decide +kernel +theorem envelope_exact_476 : envelope_476 = + insert (3, 5) (Finset.univ.biUnion childrenD_476) := by + exact envelope_eq_combination childrenD_476 (3, 5) envelope_476 + pivot_mem_476 child_envelope_sub_476 envelope_origin_476 +def checked_476 : CheckedCard where + required := required_476 + envelope := envelope_476 + height := height_476 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_476 +def height_479_i0 : ℕ := 6 +def childrenH_479_i0 : Fin 2 → ℕ := ![height_8, height_386] +theorem height_exact_479_i0 : height_479_i0 = 1 + Finset.univ.sup childrenH_479_i0 := by decide +kernel +theorem required_origin_479_i0 : ∀ x ∈ required_479_i0, + (∃ j, x ∈ childrenC_479_i0 j) ∨ ∀ j, x ∈ childrenD_479_i0 j := by decide +kernel +theorem required_exact_479_i0 : required_479_i0 = + ((Finset.univ.biUnion childrenC_479_i0) ∪ commonEnvelope childrenD_479_i0).erase (3, 2) := by + exact required_eq_combination childrenC_479_i0 childrenD_479_i0 (3, 2) required_479_i0 + (by decide +kernel) child_required_sub_479_i0 common_sub_479_i0 required_origin_479_i0 +theorem envelope_origin_479_i0 : ∀ x ∈ envelope_479_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_479_i0 j := by decide +kernel +theorem envelope_exact_479_i0 : envelope_479_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_479_i0) := by + exact envelope_eq_combination childrenD_479_i0 (3, 2) envelope_479_i0 + pivot_mem_479_i0 child_envelope_sub_479_i0 envelope_origin_479_i0 +def checked_479_i0 : CheckedCard where + required := required_479_i0 + envelope := envelope_479_i0 + height := height_479_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_479_i0 +def height_479 : ℕ := 10 +def childrenH_479 : Fin 7 → ℕ := ![height_14, height_31, height_181, height_367, height_479_i0, height_435, height_474] +theorem height_exact_479 : height_479 = 1 + Finset.univ.sup childrenH_479 := by decide +kernel +theorem required_origin_479 : ∀ x ∈ required_479, + (∃ j, x ∈ childrenC_479 j) ∨ ∀ j, x ∈ childrenD_479 j := by decide +kernel +theorem required_exact_479 : required_479 = + ((Finset.univ.biUnion childrenC_479) ∪ commonEnvelope childrenD_479).erase (3, 5) := by + exact required_eq_combination childrenC_479 childrenD_479 (3, 5) required_479 + (by decide +kernel) child_required_sub_479 common_sub_479 required_origin_479 +theorem envelope_origin_479 : ∀ x ∈ envelope_479, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_479 j := by decide +kernel +theorem envelope_exact_479 : envelope_479 = + insert (3, 5) (Finset.univ.biUnion childrenD_479) := by + exact envelope_eq_combination childrenD_479 (3, 5) envelope_479 + pivot_mem_479 child_envelope_sub_479 envelope_origin_479 +def checked_479 : CheckedCard where + required := required_479 + envelope := envelope_479 + height := height_479 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_479 +def height_480 : ℕ := 10 +def childrenH_480 : Fin 7 → ℕ := ![height_13, height_14, height_192, height_298, height_435, height_474, height_477] +theorem height_exact_480 : height_480 = 1 + Finset.univ.sup childrenH_480 := by decide +kernel +theorem required_origin_480 : ∀ x ∈ required_480, + (∃ j, x ∈ childrenC_480 j) ∨ ∀ j, x ∈ childrenD_480 j := by decide +kernel +theorem required_exact_480 : required_480 = + ((Finset.univ.biUnion childrenC_480) ∪ commonEnvelope childrenD_480).erase (3, 3) := by + exact required_eq_combination childrenC_480 childrenD_480 (3, 3) required_480 + (by decide +kernel) child_required_sub_480 common_sub_480 required_origin_480 +theorem envelope_origin_480 : ∀ x ∈ envelope_480, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_480 j := by decide +kernel +theorem envelope_exact_480 : envelope_480 = + insert (3, 3) (Finset.univ.biUnion childrenD_480) := by + exact envelope_eq_combination childrenD_480 (3, 3) envelope_480 + pivot_mem_480 child_envelope_sub_480 envelope_origin_480 +def checked_480 : CheckedCard where + required := required_480 + envelope := envelope_480 + height := height_480 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_480 +def height_481 : ℕ := 10 +def childrenH_481 : Fin 5 → ℕ := ![height_13, height_14, height_33, height_457, height_477] +theorem height_exact_481 : height_481 = 1 + Finset.univ.sup childrenH_481 := by decide +kernel +theorem required_origin_481 : ∀ x ∈ required_481, + (∃ j, x ∈ childrenC_481 j) ∨ ∀ j, x ∈ childrenD_481 j := by decide +kernel +theorem required_exact_481 : required_481 = + ((Finset.univ.biUnion childrenC_481) ∪ commonEnvelope childrenD_481).erase (2, 4) := by + exact required_eq_combination childrenC_481 childrenD_481 (2, 4) required_481 + (by decide +kernel) child_required_sub_481 common_sub_481 required_origin_481 +theorem envelope_origin_481 : ∀ x ∈ envelope_481, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_481 j := by decide +kernel +theorem envelope_exact_481 : envelope_481 = + insert (2, 4) (Finset.univ.biUnion childrenD_481) := by + exact envelope_eq_combination childrenD_481 (2, 4) envelope_481 + pivot_mem_481 child_envelope_sub_481 envelope_origin_481 +def checked_481 : CheckedCard where + required := required_481 + envelope := envelope_481 + height := height_481 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_481 +def height_483 : ℕ := 10 +def childrenH_483 : Fin 5 → ℕ := ![height_13, height_14, height_33, height_458, height_474] +theorem height_exact_483 : height_483 = 1 + Finset.univ.sup childrenH_483 := by decide +kernel +theorem required_origin_483 : ∀ x ∈ required_483, + (∃ j, x ∈ childrenC_483 j) ∨ ∀ j, x ∈ childrenD_483 j := by decide +kernel +theorem required_exact_483 : required_483 = + ((Finset.univ.biUnion childrenC_483) ∪ commonEnvelope childrenD_483).erase (2, 5) := by + exact required_eq_combination childrenC_483 childrenD_483 (2, 5) required_483 + (by decide +kernel) child_required_sub_483 common_sub_483 required_origin_483 +theorem envelope_origin_483 : ∀ x ∈ envelope_483, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_483 j := by decide +kernel +theorem envelope_exact_483 : envelope_483 = + insert (2, 5) (Finset.univ.biUnion childrenD_483) := by + exact envelope_eq_combination childrenD_483 (2, 5) envelope_483 + pivot_mem_483 child_envelope_sub_483 envelope_origin_483 +def checked_483 : CheckedCard where + required := required_483 + envelope := envelope_483 + height := height_483 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_483 +def height_491_i0 : ℕ := 5 +def childrenH_491_i0 : Fin 4 → ℕ := ![height_60, height_60, height_83, height_106] +theorem height_exact_491_i0 : height_491_i0 = 1 + Finset.univ.sup childrenH_491_i0 := by decide +kernel +theorem required_origin_491_i0 : ∀ x ∈ required_491_i0, + (∃ j, x ∈ childrenC_491_i0 j) ∨ ∀ j, x ∈ childrenD_491_i0 j := by decide +kernel +theorem required_exact_491_i0 : required_491_i0 = + ((Finset.univ.biUnion childrenC_491_i0) ∪ commonEnvelope childrenD_491_i0).erase (5, 3) := by + exact required_eq_combination childrenC_491_i0 childrenD_491_i0 (5, 3) required_491_i0 + (by decide +kernel) child_required_sub_491_i0 common_sub_491_i0 required_origin_491_i0 +theorem envelope_origin_491_i0 : ∀ x ∈ envelope_491_i0, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_491_i0 j := by decide +kernel +theorem envelope_exact_491_i0 : envelope_491_i0 = + insert (5, 3) (Finset.univ.biUnion childrenD_491_i0) := by + exact envelope_eq_combination childrenD_491_i0 (5, 3) envelope_491_i0 + pivot_mem_491_i0 child_envelope_sub_491_i0 envelope_origin_491_i0 +def checked_491_i0 : CheckedCard where + required := required_491_i0 + envelope := envelope_491_i0 + height := height_491_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_491_i0 +def height_491_i1 : ℕ := 9 +def childrenH_491_i1 : Fin 3 → ℕ := ![height_60, height_70, height_345] +theorem height_exact_491_i1 : height_491_i1 = 1 + Finset.univ.sup childrenH_491_i1 := by decide +kernel +theorem required_origin_491_i1 : ∀ x ∈ required_491_i1, + (∃ j, x ∈ childrenC_491_i1 j) ∨ ∀ j, x ∈ childrenD_491_i1 j := by decide +kernel +theorem required_exact_491_i1 : required_491_i1 = + ((Finset.univ.biUnion childrenC_491_i1) ∪ commonEnvelope childrenD_491_i1).erase (5, 3) := by + exact required_eq_combination childrenC_491_i1 childrenD_491_i1 (5, 3) required_491_i1 + (by decide +kernel) child_required_sub_491_i1 common_sub_491_i1 required_origin_491_i1 +theorem envelope_origin_491_i1 : ∀ x ∈ envelope_491_i1, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_491_i1 j := by decide +kernel +theorem envelope_exact_491_i1 : envelope_491_i1 = + insert (5, 3) (Finset.univ.biUnion childrenD_491_i1) := by + exact envelope_eq_combination childrenD_491_i1 (5, 3) envelope_491_i1 + pivot_mem_491_i1 child_envelope_sub_491_i1 envelope_origin_491_i1 +def checked_491_i1 : CheckedCard where + required := required_491_i1 + envelope := envelope_491_i1 + height := height_491_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_491_i1 +def height_491 : ℕ := 10 +def childrenH_491 : Fin 4 → ℕ := ![height_44, height_270, height_491_i0, height_491_i1] +theorem height_exact_491 : height_491 = 1 + Finset.univ.sup childrenH_491 := by decide +kernel +theorem required_origin_491 : ∀ x ∈ required_491, + (∃ j, x ∈ childrenC_491 j) ∨ ∀ j, x ∈ childrenD_491 j := by decide +kernel +theorem required_exact_491 : required_491 = + ((Finset.univ.biUnion childrenC_491) ∪ commonEnvelope childrenD_491).erase (3, 3) := by + exact required_eq_combination childrenC_491 childrenD_491 (3, 3) required_491 + (by decide +kernel) child_required_sub_491 common_sub_491 required_origin_491 +theorem envelope_origin_491 : ∀ x ∈ envelope_491, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_491 j := by decide +kernel +theorem envelope_exact_491 : envelope_491 = + insert (3, 3) (Finset.univ.biUnion childrenD_491) := by + exact envelope_eq_combination childrenD_491 (3, 3) envelope_491 + pivot_mem_491 child_envelope_sub_491 envelope_origin_491 +def checked_491 : CheckedCard where + required := required_491 + envelope := envelope_491 + height := height_491 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_491 +def height_508 : ℕ := 10 +def childrenH_508 : Fin 7 → ℕ := ![height_12, height_13, height_14, height_297, height_298, height_474, height_507] +theorem height_exact_508 : height_508 = 1 + Finset.univ.sup childrenH_508 := by decide +kernel +theorem required_origin_508 : ∀ x ∈ required_508, + (∃ j, x ∈ childrenC_508 j) ∨ ∀ j, x ∈ childrenD_508 j := by decide +kernel +theorem required_exact_508 : required_508 = + ((Finset.univ.biUnion childrenC_508) ∪ commonEnvelope childrenD_508).erase (4, 3) := by + exact required_eq_combination childrenC_508 childrenD_508 (4, 3) required_508 + (by decide +kernel) child_required_sub_508 common_sub_508 required_origin_508 +theorem envelope_origin_508 : ∀ x ∈ envelope_508, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_508 j := by decide +kernel +theorem envelope_exact_508 : envelope_508 = + insert (4, 3) (Finset.univ.biUnion childrenD_508) := by + exact envelope_eq_combination childrenD_508 (4, 3) envelope_508 + pivot_mem_508 child_envelope_sub_508 envelope_origin_508 +def checked_508 : CheckedCard where + required := required_508 + envelope := envelope_508 + height := height_508 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_508 +def height_509 : ℕ := 10 +def childrenH_509 : Fin 5 → ℕ := ![height_12, height_127, height_128, height_474, height_507] +theorem height_exact_509 : height_509 = 1 + Finset.univ.sup childrenH_509 := by decide +kernel +theorem required_origin_509 : ∀ x ∈ required_509, + (∃ j, x ∈ childrenC_509 j) ∨ ∀ j, x ∈ childrenD_509 j := by decide +kernel +theorem required_exact_509 : required_509 = + ((Finset.univ.biUnion childrenC_509) ∪ commonEnvelope childrenD_509).erase (4, 3) := by + exact required_eq_combination childrenC_509 childrenD_509 (4, 3) required_509 + (by decide +kernel) child_required_sub_509 common_sub_509 required_origin_509 +theorem envelope_origin_509 : ∀ x ∈ envelope_509, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_509 j := by decide +kernel +theorem envelope_exact_509 : envelope_509 = + insert (4, 3) (Finset.univ.biUnion childrenD_509) := by + exact envelope_eq_combination childrenD_509 (4, 3) envelope_509 + pivot_mem_509 child_envelope_sub_509 envelope_origin_509 +def checked_509 : CheckedCard where + required := required_509 + envelope := envelope_509 + height := height_509 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_509 +def height_520 : ℕ := 10 +def childrenH_520 : Fin 3 → ℕ := ![height_10, height_317, height_519] +theorem height_exact_520 : height_520 = 1 + Finset.univ.sup childrenH_520 := by decide +kernel +theorem required_origin_520 : ∀ x ∈ required_520, + (∃ j, x ∈ childrenC_520 j) ∨ ∀ j, x ∈ childrenD_520 j := by decide +kernel +theorem required_exact_520 : required_520 = + ((Finset.univ.biUnion childrenC_520) ∪ commonEnvelope childrenD_520).erase (4, 5) := by + exact required_eq_combination childrenC_520 childrenD_520 (4, 5) required_520 + (by decide +kernel) child_required_sub_520 common_sub_520 required_origin_520 +theorem envelope_origin_520 : ∀ x ∈ envelope_520, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_520 j := by decide +kernel +theorem envelope_exact_520 : envelope_520 = + insert (4, 5) (Finset.univ.biUnion childrenD_520) := by + exact envelope_eq_combination childrenD_520 (4, 5) envelope_520 + pivot_mem_520 child_envelope_sub_520 envelope_origin_520 +def checked_520 : CheckedCard where + required := required_520 + envelope := envelope_520 + height := height_520 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_520 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part02.lean new file mode 100644 index 0000000..4219dd4 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part02.lean @@ -0,0 +1,992 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_529_i4 : Finset Cell := ⟨(([(2, 5), (4, 6), (5, 6), (6, 6), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_529_i4 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (4, 6), (5, 6), (6, 5), (6, 6), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_529_i4 : Fin 2 → Finset Cell := ![(placed21 6 (6, 6) required_4), (placed21 4 (3, 6) required_4)] +def childrenD_529_i4 : Fin 2 → Finset Cell := ![(placed21 6 (6, 6) envelope_4), (placed21 4 (3, 6) envelope_4)] +theorem common_sub_529_i4 : commonEnvelope childrenD_529_i4 ⊆ insert (3, 6) required_529_i4 := by decide +kernel +theorem child_required_sub_529_i4 : ∀ j, childrenC_529_i4 j ⊆ insert (3, 6) required_529_i4 := by decide +kernel +theorem child_envelope_sub_529_i4 : ∀ j, childrenD_529_i4 j ⊆ envelope_529_i4 := by decide +kernel +theorem pivot_mem_529_i4 : (3, 6) ∈ envelope_529_i4 := by decide +kernel +theorem children_work_529_i4 : ∀ j, Template HasSnaky 1 (childrenC_529_i4 j) (childrenD_529_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 6 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_4 4 (3, 6)).mono (by decide +kernel) +theorem row_works_529_i4 : Template HasSnaky 2 required_529_i4 envelope_529_i4 := by + refine compose HasSnaky 1 childrenC_529_i4 childrenD_529_i4 children_work_529_i4 (3, 6) + required_529_i4 envelope_529_i4 pivot_mem_529_i4 child_required_sub_529_i4 child_envelope_sub_529_i4 ?_ + intro b hb + exact common_sub_529_i4 (mem_commonEnvelope childrenD_529_i4 b hb) +def required_529_i5 : Finset Cell := ⟨(([(4, 4), (4, 6), (5, 3), (5, 4), (5, 5), (5, 6), (6, 6), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_529_i5 : Finset Cell := ⟨(([(4, 4), (4, 6), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 6), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 3), (8, 5), (8, 6), (8, 7), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_529_i5 : Fin 2 → Finset Cell := ![(placed21 3 (4, 6) required_38), (placed21 4 (4, 7) required_351)] +def childrenD_529_i5 : Fin 2 → Finset Cell := ![(placed21 3 (4, 6) envelope_38), (placed21 4 (4, 7) envelope_351)] +theorem common_sub_529_i5 : commonEnvelope childrenD_529_i5 ⊆ insert (7, 3) required_529_i5 := by decide +kernel +theorem child_required_sub_529_i5 : ∀ j, childrenC_529_i5 j ⊆ insert (7, 3) required_529_i5 := by decide +kernel +theorem child_envelope_sub_529_i5 : ∀ j, childrenD_529_i5 j ⊆ envelope_529_i5 := by decide +kernel +theorem pivot_mem_529_i5 : (7, 3) ∈ envelope_529_i5 := by decide +kernel +theorem children_work_529_i5 : ∀ j, Template HasSnaky 4 (childrenC_529_i5 j) (childrenD_529_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_38 3 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_351 4 (4, 7)).mono (by decide +kernel) +theorem row_works_529_i5 : Template HasSnaky 5 required_529_i5 envelope_529_i5 := by + refine compose HasSnaky 4 childrenC_529_i5 childrenD_529_i5 children_work_529_i5 (7, 3) + required_529_i5 envelope_529_i5 pivot_mem_529_i5 child_required_sub_529_i5 child_envelope_sub_529_i5 ?_ + intro b hb + exact common_sub_529_i5 (mem_commonEnvelope childrenD_529_i5 b hb) +def required_529_i3 : Finset Cell := ⟨(([(2, 5), (4, 4), (4, 6), (5, 3), (5, 4), (5, 5), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_529_i3 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (4, 4), (4, 6), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 5), (6, 6), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 3), (8, 5), (8, 6), (8, 7), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_529_i3 : Fin 2 → Finset Cell := ![required_529_i4, required_529_i5] +def childrenD_529_i3 : Fin 2 → Finset Cell := ![envelope_529_i4, envelope_529_i5] +theorem common_sub_529_i3 : commonEnvelope childrenD_529_i3 ⊆ insert (7, 5) required_529_i3 := by decide +kernel +theorem child_required_sub_529_i3 : ∀ j, childrenC_529_i3 j ⊆ insert (7, 5) required_529_i3 := by decide +kernel +theorem child_envelope_sub_529_i3 : ∀ j, childrenD_529_i3 j ⊆ envelope_529_i3 := by decide +kernel +theorem pivot_mem_529_i3 : (7, 5) ∈ envelope_529_i3 := by decide +kernel +theorem children_work_529_i3 : ∀ j, Template HasSnaky 5 (childrenC_529_i3 j) (childrenD_529_i3 j) := by + intro j + fin_cases j + · exact row_works_529_i4.mono (by decide +kernel) + · exact row_works_529_i5.mono (by decide +kernel) +theorem row_works_529_i3 : Template HasSnaky 6 required_529_i3 envelope_529_i3 := by + refine compose HasSnaky 5 childrenC_529_i3 childrenD_529_i3 children_work_529_i3 (7, 5) + required_529_i3 envelope_529_i3 pivot_mem_529_i3 child_required_sub_529_i3 child_envelope_sub_529_i3 ?_ + intro b hb + exact common_sub_529_i3 (mem_commonEnvelope childrenD_529_i3 b hb) +def required_529_i2 : Finset Cell := ⟨(([(2, 5), (4, 4), (5, 3), (5, 4), (5, 5), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_529_i2 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (4, 4), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 5), (6, 6), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 3), (8, 5), (8, 6), (8, 7), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_529_i2 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) required_5), required_529_i3] +def childrenD_529_i2 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) envelope_5), envelope_529_i3] +theorem common_sub_529_i2 : commonEnvelope childrenD_529_i2 ⊆ insert (4, 6) required_529_i2 := by decide +kernel +theorem child_required_sub_529_i2 : ∀ j, childrenC_529_i2 j ⊆ insert (4, 6) required_529_i2 := by decide +kernel +theorem child_envelope_sub_529_i2 : ∀ j, childrenD_529_i2 j ⊆ envelope_529_i2 := by decide +kernel +theorem pivot_mem_529_i2 : (4, 6) ∈ envelope_529_i2 := by decide +kernel +theorem children_work_529_i2 : ∀ j, Template HasSnaky 6 (childrenC_529_i2 j) (childrenD_529_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (5, 3)).mono (by decide +kernel) + · exact row_works_529_i3.mono (by decide +kernel) +theorem row_works_529_i2 : Template HasSnaky 7 required_529_i2 envelope_529_i2 := by + refine compose HasSnaky 6 childrenC_529_i2 childrenD_529_i2 children_work_529_i2 (4, 6) + required_529_i2 envelope_529_i2 pivot_mem_529_i2 child_required_sub_529_i2 child_envelope_sub_529_i2 ?_ + intro b hb + exact common_sub_529_i2 (mem_commonEnvelope childrenD_529_i2 b hb) +def required_529_i1 : Finset Cell := ⟨(([(2, 5), (4, 4), (5, 3), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_529_i1 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (4, 4), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 3), (8, 5), (8, 6), (8, 7), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_529_i1 : Fin 2 → Finset Cell := ![(placed21 1 (5, 3) required_5), required_529_i2] +def childrenD_529_i1 : Fin 2 → Finset Cell := ![(placed21 1 (5, 3) envelope_5), envelope_529_i2] +theorem common_sub_529_i1 : commonEnvelope childrenD_529_i1 ⊆ insert (6, 6) required_529_i1 := by decide +kernel +theorem child_required_sub_529_i1 : ∀ j, childrenC_529_i1 j ⊆ insert (6, 6) required_529_i1 := by decide +kernel +theorem child_envelope_sub_529_i1 : ∀ j, childrenD_529_i1 j ⊆ envelope_529_i1 := by decide +kernel +theorem pivot_mem_529_i1 : (6, 6) ∈ envelope_529_i1 := by decide +kernel +theorem children_work_529_i1 : ∀ j, Template HasSnaky 7 (childrenC_529_i1 j) (childrenD_529_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (5, 3)).mono (by decide +kernel) + · exact row_works_529_i2.mono (by decide +kernel) +theorem row_works_529_i1 : Template HasSnaky 8 required_529_i1 envelope_529_i1 := by + refine compose HasSnaky 7 childrenC_529_i1 childrenD_529_i1 children_work_529_i1 (6, 6) + required_529_i1 envelope_529_i1 pivot_mem_529_i1 child_required_sub_529_i1 child_envelope_sub_529_i1 ?_ + intro b hb + exact common_sub_529_i1 (mem_commonEnvelope childrenD_529_i1 b hb) +def required_529_i0 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 5), (4, 4), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_529_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (2, 2), (2, 5), (3, 2), (3, 5), (3, 6), (4, 1), (4, 2), (4, 4), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 3), (8, 5), (8, 6), (8, 7), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_529_i0 : Fin 3 → Finset Cell := ![(placed21 3 (3, 7) required_133), required_529_i1, (placed21 7 (6, 6) required_505)] +def childrenD_529_i0 : Fin 3 → Finset Cell := ![(placed21 3 (3, 7) envelope_133), envelope_529_i1, (placed21 7 (6, 6) envelope_505)] +theorem common_sub_529_i0 : commonEnvelope childrenD_529_i0 ⊆ insert (5, 3) required_529_i0 := by decide +kernel +theorem child_required_sub_529_i0 : ∀ j, childrenC_529_i0 j ⊆ insert (5, 3) required_529_i0 := by decide +kernel +theorem child_envelope_sub_529_i0 : ∀ j, childrenD_529_i0 j ⊆ envelope_529_i0 := by decide +kernel +theorem pivot_mem_529_i0 : (5, 3) ∈ envelope_529_i0 := by decide +kernel +theorem children_work_529_i0 : ∀ j, Template HasSnaky 8 (childrenC_529_i0 j) (childrenD_529_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_133 3 (3, 7)).mono (by decide +kernel) + · exact row_works_529_i1.mono (by decide +kernel) + · exact (placed21_template row_works_505 7 (6, 6)).mono (by decide +kernel) +theorem row_works_529_i0 : Template HasSnaky 9 required_529_i0 envelope_529_i0 := by + refine compose HasSnaky 8 childrenC_529_i0 childrenD_529_i0 children_work_529_i0 (5, 3) + required_529_i0 envelope_529_i0 pivot_mem_529_i0 child_required_sub_529_i0 child_envelope_sub_529_i0 ?_ + intro b hb + exact common_sub_529_i0 (mem_commonEnvelope childrenD_529_i0 b hb) +def required_529 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 5), (4, 4), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_529 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (2, 1), (2, 2), (2, 5), (3, 2), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 4), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 3), (9, 4), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_529 : Fin 7 → Finset Cell := ![(placed21 2 (6, 2) required_12), (placed21 1 (3, 3) required_181), (placed21 2 (6, 2) required_189), (placed21 2 (6, 1) required_369), (placed21 1 (3, 3) required_474), (placed21 0 (4, 0) required_528), required_529_i0] +def childrenD_529 : Fin 7 → Finset Cell := ![(placed21 2 (6, 2) envelope_12), (placed21 1 (3, 3) envelope_181), (placed21 2 (6, 2) envelope_189), (placed21 2 (6, 1) envelope_369), (placed21 1 (3, 3) envelope_474), (placed21 0 (4, 0) envelope_528), envelope_529_i0] +theorem common_sub_529 : commonEnvelope childrenD_529 ⊆ insert (5, 6) required_529 := by decide +kernel +theorem child_required_sub_529 : ∀ j, childrenC_529 j ⊆ insert (5, 6) required_529 := by decide +kernel +theorem child_envelope_sub_529 : ∀ j, childrenD_529 j ⊆ envelope_529 := by decide +kernel +theorem pivot_mem_529 : (5, 6) ∈ envelope_529 := by decide +kernel +theorem children_work_529 : ∀ j, Template HasSnaky 9 (childrenC_529 j) (childrenD_529 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_181 1 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_189 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_369 2 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_474 1 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_528 0 (4, 0)).mono (by decide +kernel) + · exact row_works_529_i0.mono (by decide +kernel) +theorem row_works_529 : Template HasSnaky 10 required_529 envelope_529 := by + refine compose HasSnaky 9 childrenC_529 childrenD_529 children_work_529 (5, 6) + required_529 envelope_529 pivot_mem_529 child_required_sub_529 child_envelope_sub_529 ?_ + intro b hb + exact common_sub_529 (mem_commonEnvelope childrenD_529 b hb) +def required_535 : Finset Cell := ⟨(([(1, 5), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_535 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 0), (1, 1), (1, 2), (1, 4), (1, 5), (1, 7), (1, 8), (1, 9), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_535 : Fin 7 → Finset Cell := ![(placed21 4 (0, 7) required_345), (placed21 3 (0, 6) required_421), (placed21 4 (0, 7) required_522), (placed21 4 (1, 8) required_530), required_532, (placed21 0 (0, 2) required_533), (placed21 4 (0, 8) required_534)] +def childrenD_535 : Fin 7 → Finset Cell := ![(placed21 4 (0, 7) envelope_345), (placed21 3 (0, 6) envelope_421), (placed21 4 (0, 7) envelope_522), (placed21 4 (1, 8) envelope_530), envelope_532, (placed21 0 (0, 2) envelope_533), (placed21 4 (0, 8) envelope_534)] +theorem common_sub_535 : commonEnvelope childrenD_535 ⊆ insert (3, 5) required_535 := by decide +kernel +theorem child_required_sub_535 : ∀ j, childrenC_535 j ⊆ insert (3, 5) required_535 := by decide +kernel +theorem child_envelope_sub_535 : ∀ j, childrenD_535 j ⊆ envelope_535 := by decide +kernel +theorem pivot_mem_535 : (3, 5) ∈ envelope_535 := by decide +kernel +theorem children_work_535 : ∀ j, Template HasSnaky 9 (childrenC_535 j) (childrenD_535 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_345 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_421 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_522 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_530 4 (1, 8)).mono (by decide +kernel) + · exact row_works_532.mono (by decide +kernel) + · exact (placed21_template row_works_533 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_534 4 (0, 8)).mono (by decide +kernel) +theorem row_works_535 : Template HasSnaky 10 required_535 envelope_535 := by + refine compose HasSnaky 9 childrenC_535 childrenD_535 children_work_535 (3, 5) + required_535 envelope_535 pivot_mem_535 child_required_sub_535 child_envelope_sub_535 ?_ + intro b hb + exact common_sub_535 (mem_commonEnvelope childrenD_535 b hb) +def required_540_i0 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 6), (1, 7), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_540_i0 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_540_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) required_237), (placed21 5 (4, 3) required_281)] +def childrenD_540_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) envelope_237), (placed21 5 (4, 3) envelope_281)] +theorem common_sub_540_i0 : commonEnvelope childrenD_540_i0 ⊆ insert (2, 3) required_540_i0 := by decide +kernel +theorem child_required_sub_540_i0 : ∀ j, childrenC_540_i0 j ⊆ insert (2, 3) required_540_i0 := by decide +kernel +theorem child_envelope_sub_540_i0 : ∀ j, childrenD_540_i0 j ⊆ envelope_540_i0 := by decide +kernel +theorem pivot_mem_540_i0 : (2, 3) ∈ envelope_540_i0 := by decide +kernel +theorem children_work_540_i0 : ∀ j, Template HasSnaky 5 (childrenC_540_i0 j) (childrenD_540_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_237 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_281 5 (4, 3)).mono (by decide +kernel) +theorem row_works_540_i0 : Template HasSnaky 6 required_540_i0 envelope_540_i0 := by + refine compose HasSnaky 5 childrenC_540_i0 childrenD_540_i0 children_work_540_i0 (2, 3) + required_540_i0 envelope_540_i0 pivot_mem_540_i0 child_required_sub_540_i0 child_envelope_sub_540_i0 ?_ + intro b hb + exact common_sub_540_i0 (mem_commonEnvelope childrenD_540_i0 b hb) +def required_540_i3 : Finset Cell := ⟨(([(0, 3), (3, 3), (3, 4), (3, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_540_i3 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_540_i3 : Fin 3 → Finset Cell := ![(placed21 3 (1, 5) required_164), (placed21 4 (3, 7) required_199), (placed21 0 (0, 1) required_283)] +def childrenD_540_i3 : Fin 3 → Finset Cell := ![(placed21 3 (1, 5) envelope_164), (placed21 4 (3, 7) envelope_199), (placed21 0 (0, 1) envelope_283)] +theorem common_sub_540_i3 : commonEnvelope childrenD_540_i3 ⊆ insert (4, 4) required_540_i3 := by decide +kernel +theorem child_required_sub_540_i3 : ∀ j, childrenC_540_i3 j ⊆ insert (4, 4) required_540_i3 := by decide +kernel +theorem child_envelope_sub_540_i3 : ∀ j, childrenD_540_i3 j ⊆ envelope_540_i3 := by decide +kernel +theorem pivot_mem_540_i3 : (4, 4) ∈ envelope_540_i3 := by decide +kernel +theorem children_work_540_i3 : ∀ j, Template HasSnaky 6 (childrenC_540_i3 j) (childrenD_540_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_164 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_199 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_283 0 (0, 1)).mono (by decide +kernel) +theorem row_works_540_i3 : Template HasSnaky 7 required_540_i3 envelope_540_i3 := by + refine compose HasSnaky 6 childrenC_540_i3 childrenD_540_i3 children_work_540_i3 (4, 4) + required_540_i3 envelope_540_i3 pivot_mem_540_i3 child_required_sub_540_i3 child_envelope_sub_540_i3 ?_ + intro b hb + exact common_sub_540_i3 (mem_commonEnvelope childrenD_540_i3 b hb) +def required_540_i2 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 6), (1, 6), (1, 7), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_540_i2 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 5), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_540_i2 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_170), required_540_i3] +def childrenD_540_i2 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_170), envelope_540_i3] +theorem common_sub_540_i2 : commonEnvelope childrenD_540_i2 ⊆ insert (4, 5) required_540_i2 := by decide +kernel +theorem child_required_sub_540_i2 : ∀ j, childrenC_540_i2 j ⊆ insert (4, 5) required_540_i2 := by decide +kernel +theorem child_envelope_sub_540_i2 : ∀ j, childrenD_540_i2 j ⊆ envelope_540_i2 := by decide +kernel +theorem pivot_mem_540_i2 : (4, 5) ∈ envelope_540_i2 := by decide +kernel +theorem children_work_540_i2 : ∀ j, Template HasSnaky 7 (childrenC_540_i2 j) (childrenD_540_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_170 0 (0, 3)).mono (by decide +kernel) + · exact row_works_540_i3.mono (by decide +kernel) +theorem row_works_540_i2 : Template HasSnaky 8 required_540_i2 envelope_540_i2 := by + refine compose HasSnaky 7 childrenC_540_i2 childrenD_540_i2 children_work_540_i2 (4, 5) + required_540_i2 envelope_540_i2 pivot_mem_540_i2 child_required_sub_540_i2 child_envelope_sub_540_i2 ?_ + intro b hb + exact common_sub_540_i2 (mem_commonEnvelope childrenD_540_i2 b hb) +def required_540_i1 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 6), (1, 7), (1, 8), (1, 9), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_540_i1 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 6), (0, 7), (0, 9), (0, 10), (0, 11), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (2, 3), (2, 5), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_540_i1 : Fin 2 → Finset Cell := ![(placed21 2 (1, 6) required_16), required_540_i2] +def childrenD_540_i1 : Fin 2 → Finset Cell := ![(placed21 2 (1, 6) envelope_16), envelope_540_i2] +theorem common_sub_540_i1 : commonEnvelope childrenD_540_i1 ⊆ insert (0, 6) required_540_i1 := by decide +kernel +theorem child_required_sub_540_i1 : ∀ j, childrenC_540_i1 j ⊆ insert (0, 6) required_540_i1 := by decide +kernel +theorem child_envelope_sub_540_i1 : ∀ j, childrenD_540_i1 j ⊆ envelope_540_i1 := by decide +kernel +theorem pivot_mem_540_i1 : (0, 6) ∈ envelope_540_i1 := by decide +kernel +theorem children_work_540_i1 : ∀ j, Template HasSnaky 8 (childrenC_540_i1 j) (childrenD_540_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_16 2 (1, 6)).mono (by decide +kernel) + · exact row_works_540_i2.mono (by decide +kernel) +theorem row_works_540_i1 : Template HasSnaky 9 required_540_i1 envelope_540_i1 := by + refine compose HasSnaky 8 childrenC_540_i1 childrenD_540_i1 children_work_540_i1 (0, 6) + required_540_i1 envelope_540_i1 pivot_mem_540_i1 child_required_sub_540_i1 child_envelope_sub_540_i1 ?_ + intro b hb + exact common_sub_540_i1 (mem_commonEnvelope childrenD_540_i1 b hb) +def required_540 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 6), (1, 7), (1, 8), (1, 9), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_540 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 6), (0, 7), (0, 9), (0, 10), (0, 11), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (2, 2), (2, 3), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_540 : Fin 3 → Finset Cell := ![(placed21 4 (3, 6) required_44), required_540_i0, required_540_i1] +def childrenD_540 : Fin 3 → Finset Cell := ![(placed21 4 (3, 6) envelope_44), envelope_540_i0, envelope_540_i1] +theorem common_sub_540 : commonEnvelope childrenD_540 ⊆ insert (4, 3) required_540 := by decide +kernel +theorem child_required_sub_540 : ∀ j, childrenC_540 j ⊆ insert (4, 3) required_540 := by decide +kernel +theorem child_envelope_sub_540 : ∀ j, childrenD_540 j ⊆ envelope_540 := by decide +kernel +theorem pivot_mem_540 : (4, 3) ∈ envelope_540 := by decide +kernel +theorem children_work_540 : ∀ j, Template HasSnaky 9 (childrenC_540 j) (childrenD_540 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 4 (3, 6)).mono (by decide +kernel) + · exact row_works_540_i0.mono (by decide +kernel) + · exact row_works_540_i1.mono (by decide +kernel) +theorem row_works_540 : Template HasSnaky 10 required_540 envelope_540 := by + refine compose HasSnaky 9 childrenC_540 childrenD_540 children_work_540 (4, 3) + required_540 envelope_540 pivot_mem_540 child_required_sub_540 child_envelope_sub_540 ?_ + intro b hb + exact common_sub_540 (mem_commonEnvelope childrenD_540 b hb) +def required_541_i6 : Finset Cell := ⟨(([(0, 1), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_541_i6 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_541_i6 : Fin 2 → Finset Cell := ![(placed21 3 (3, 6) required_0), (placed21 7 (4, 4) required_35)] +def childrenD_541_i6 : Fin 2 → Finset Cell := ![(placed21 3 (3, 6) envelope_0), (placed21 7 (4, 4) envelope_35)] +theorem common_sub_541_i6 : commonEnvelope childrenD_541_i6 ⊆ insert (4, 2) required_541_i6 := by decide +kernel +theorem child_required_sub_541_i6 : ∀ j, childrenC_541_i6 j ⊆ insert (4, 2) required_541_i6 := by decide +kernel +theorem child_envelope_sub_541_i6 : ∀ j, childrenD_541_i6 j ⊆ envelope_541_i6 := by decide +kernel +theorem pivot_mem_541_i6 : (4, 2) ∈ envelope_541_i6 := by decide +kernel +theorem children_work_541_i6 : ∀ j, Template HasSnaky 2 (childrenC_541_i6 j) (childrenD_541_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_35 7 (4, 4)).mono (by decide +kernel) +theorem row_works_541_i6 : Template HasSnaky 3 required_541_i6 envelope_541_i6 := by + refine compose HasSnaky 2 childrenC_541_i6 childrenD_541_i6 children_work_541_i6 (4, 2) + required_541_i6 envelope_541_i6 pivot_mem_541_i6 child_required_sub_541_i6 child_envelope_sub_541_i6 ?_ + intro b hb + exact common_sub_541_i6 (mem_commonEnvelope childrenD_541_i6 b hb) +def required_541_i5 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 4), (1, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_541_i5 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_541_i5 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_170), required_541_i6] +def childrenD_541_i5 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_170), envelope_541_i6] +theorem common_sub_541_i5 : commonEnvelope childrenD_541_i5 ⊆ insert (4, 3) required_541_i5 := by decide +kernel +theorem child_required_sub_541_i5 : ∀ j, childrenC_541_i5 j ⊆ insert (4, 3) required_541_i5 := by decide +kernel +theorem child_envelope_sub_541_i5 : ∀ j, childrenD_541_i5 j ⊆ envelope_541_i5 := by decide +kernel +theorem pivot_mem_541_i5 : (4, 3) ∈ envelope_541_i5 := by decide +kernel +theorem children_work_541_i5 : ∀ j, Template HasSnaky 3 (childrenC_541_i5 j) (childrenD_541_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_170 0 (0, 1)).mono (by decide +kernel) + · exact row_works_541_i6.mono (by decide +kernel) +theorem row_works_541_i5 : Template HasSnaky 4 required_541_i5 envelope_541_i5 := by + refine compose HasSnaky 3 childrenC_541_i5 childrenD_541_i5 children_work_541_i5 (4, 3) + required_541_i5 envelope_541_i5 pivot_mem_541_i5 child_required_sub_541_i5 child_envelope_sub_541_i5 ?_ + intro b hb + exact common_sub_541_i5 (mem_commonEnvelope childrenD_541_i5 b hb) +def required_541_i4 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 4), (1, 5), (3, 1), (3, 2), (3, 3), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_541_i4 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_541_i4 : Fin 3 → Finset Cell := ![(placed21 4 (3, 5) required_6), required_86, required_541_i5] +def childrenD_541_i4 : Fin 3 → Finset Cell := ![(placed21 4 (3, 5) envelope_6), envelope_86, envelope_541_i5] +theorem common_sub_541_i4 : commonEnvelope childrenD_541_i4 ⊆ insert (3, 4) required_541_i4 := by decide +kernel +theorem child_required_sub_541_i4 : ∀ j, childrenC_541_i4 j ⊆ insert (3, 4) required_541_i4 := by decide +kernel +theorem child_envelope_sub_541_i4 : ∀ j, childrenD_541_i4 j ⊆ envelope_541_i4 := by decide +kernel +theorem pivot_mem_541_i4 : (3, 4) ∈ envelope_541_i4 := by decide +kernel +theorem children_work_541_i4 : ∀ j, Template HasSnaky 4 (childrenC_541_i4 j) (childrenD_541_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 4 (3, 5)).mono (by decide +kernel) + · exact row_works_86.mono (by decide +kernel) + · exact row_works_541_i5.mono (by decide +kernel) +theorem row_works_541_i4 : Template HasSnaky 5 required_541_i4 envelope_541_i4 := by + refine compose HasSnaky 4 childrenC_541_i4 childrenD_541_i4 children_work_541_i4 (3, 4) + required_541_i4 envelope_541_i4 pivot_mem_541_i4 child_required_sub_541_i4 child_envelope_sub_541_i4 ?_ + intro b hb + exact common_sub_541_i4 (mem_commonEnvelope childrenD_541_i4 b hb) +def required_541_i3 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 4), (1, 5), (2, 5), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_541_i3 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 3), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_541_i3 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) required_0), required_541_i4] +def childrenD_541_i3 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) envelope_0), envelope_541_i4] +theorem common_sub_541_i3 : commonEnvelope childrenD_541_i3 ⊆ insert (3, 5) required_541_i3 := by decide +kernel +theorem child_required_sub_541_i3 : ∀ j, childrenC_541_i3 j ⊆ insert (3, 5) required_541_i3 := by decide +kernel +theorem child_envelope_sub_541_i3 : ∀ j, childrenD_541_i3 j ⊆ envelope_541_i3 := by decide +kernel +theorem pivot_mem_541_i3 : (3, 5) ∈ envelope_541_i3 := by decide +kernel +theorem children_work_541_i3 : ∀ j, Template HasSnaky 5 (childrenC_541_i3 j) (childrenD_541_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (4, 5)).mono (by decide +kernel) + · exact row_works_541_i4.mono (by decide +kernel) +theorem row_works_541_i3 : Template HasSnaky 6 required_541_i3 envelope_541_i3 := by + refine compose HasSnaky 5 childrenC_541_i3 childrenD_541_i3 children_work_541_i3 (3, 5) + required_541_i3 envelope_541_i3 pivot_mem_541_i3 child_required_sub_541_i3 child_envelope_sub_541_i3 ?_ + intro b hb + exact common_sub_541_i3 (mem_commonEnvelope childrenD_541_i3 b hb) +def required_541_i2 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_541_i2 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 3), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_541_i2 : Fin 2 → Finset Cell := ![(placed21 3 (1, 9) required_4), required_541_i3] +def childrenD_541_i2 : Fin 2 → Finset Cell := ![(placed21 3 (1, 9) envelope_4), envelope_541_i3] +theorem common_sub_541_i2 : commonEnvelope childrenD_541_i2 ⊆ insert (2, 5) required_541_i2 := by decide +kernel +theorem child_required_sub_541_i2 : ∀ j, childrenC_541_i2 j ⊆ insert (2, 5) required_541_i2 := by decide +kernel +theorem child_envelope_sub_541_i2 : ∀ j, childrenD_541_i2 j ⊆ envelope_541_i2 := by decide +kernel +theorem pivot_mem_541_i2 : (2, 5) ∈ envelope_541_i2 := by decide +kernel +theorem children_work_541_i2 : ∀ j, Template HasSnaky 6 (childrenC_541_i2 j) (childrenD_541_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 3 (1, 9)).mono (by decide +kernel) + · exact row_works_541_i3.mono (by decide +kernel) +theorem row_works_541_i2 : Template HasSnaky 7 required_541_i2 envelope_541_i2 := by + refine compose HasSnaky 6 childrenC_541_i2 childrenD_541_i2 children_work_541_i2 (2, 5) + required_541_i2 envelope_541_i2 pivot_mem_541_i2 child_required_sub_541_i2 child_envelope_sub_541_i2 ?_ + intro b hb + exact common_sub_541_i2 (mem_commonEnvelope childrenD_541_i2 b hb) +def required_541_i1 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_541_i1 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 3), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_541_i1 : Fin 2 → Finset Cell := ![(placed21 7 (1, 8) required_4), required_541_i2] +def childrenD_541_i1 : Fin 2 → Finset Cell := ![(placed21 7 (1, 8) envelope_4), envelope_541_i2] +theorem common_sub_541_i1 : commonEnvelope childrenD_541_i1 ⊆ insert (0, 4) required_541_i1 := by decide +kernel +theorem child_required_sub_541_i1 : ∀ j, childrenC_541_i1 j ⊆ insert (0, 4) required_541_i1 := by decide +kernel +theorem child_envelope_sub_541_i1 : ∀ j, childrenD_541_i1 j ⊆ envelope_541_i1 := by decide +kernel +theorem pivot_mem_541_i1 : (0, 4) ∈ envelope_541_i1 := by decide +kernel +theorem children_work_541_i1 : ∀ j, Template HasSnaky 7 (childrenC_541_i1 j) (childrenD_541_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (1, 8)).mono (by decide +kernel) + · exact row_works_541_i2.mono (by decide +kernel) +theorem row_works_541_i1 : Template HasSnaky 8 required_541_i1 envelope_541_i1 := by + refine compose HasSnaky 7 childrenC_541_i1 childrenD_541_i1 children_work_541_i1 (0, 4) + required_541_i1 envelope_541_i1 pivot_mem_541_i1 child_required_sub_541_i1 child_envelope_sub_541_i1 ?_ + intro b hb + exact common_sub_541_i1 (mem_commonEnvelope childrenD_541_i1 b hb) +def required_541_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_541_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 3), (2, 5), (2, 6), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_541_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 5) required_6), required_541_i1] +def childrenD_541_i0 : Fin 2 → Finset Cell := ![(placed21 0 (1, 5) envelope_6), envelope_541_i1] +theorem common_sub_541_i0 : commonEnvelope childrenD_541_i0 ⊆ insert (1, 9) required_541_i0 := by decide +kernel +theorem child_required_sub_541_i0 : ∀ j, childrenC_541_i0 j ⊆ insert (1, 9) required_541_i0 := by decide +kernel +theorem child_envelope_sub_541_i0 : ∀ j, childrenD_541_i0 j ⊆ envelope_541_i0 := by decide +kernel +theorem pivot_mem_541_i0 : (1, 9) ∈ envelope_541_i0 := by decide +kernel +theorem children_work_541_i0 : ∀ j, Template HasSnaky 8 (childrenC_541_i0 j) (childrenD_541_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (1, 5)).mono (by decide +kernel) + · exact row_works_541_i1.mono (by decide +kernel) +theorem row_works_541_i0 : Template HasSnaky 9 required_541_i0 envelope_541_i0 := by + refine compose HasSnaky 8 childrenC_541_i0 childrenD_541_i0 children_work_541_i0 (1, 9) + required_541_i0 envelope_541_i0 pivot_mem_541_i0 child_required_sub_541_i0 child_envelope_sub_541_i0 ?_ + intro b hb + exact common_sub_541_i0 (mem_commonEnvelope childrenD_541_i0 b hb) +def required_541 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 4), (1, 5), (1, 6), (1, 7), (3, 1), (3, 2), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_541 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 3), (2, 5), (2, 6), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_541 : Fin 2 → Finset Cell := ![(placed21 2 (1, 4) required_6), required_541_i0] +def childrenD_541 : Fin 2 → Finset Cell := ![(placed21 2 (1, 4) envelope_6), envelope_541_i0] +theorem common_sub_541 : commonEnvelope childrenD_541 ⊆ insert (1, 8) required_541 := by decide +kernel +theorem child_required_sub_541 : ∀ j, childrenC_541 j ⊆ insert (1, 8) required_541 := by decide +kernel +theorem child_envelope_sub_541 : ∀ j, childrenD_541 j ⊆ envelope_541 := by decide +kernel +theorem pivot_mem_541 : (1, 8) ∈ envelope_541 := by decide +kernel +theorem children_work_541 : ∀ j, Template HasSnaky 9 (childrenC_541 j) (childrenD_541 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 2 (1, 4)).mono (by decide +kernel) + · exact row_works_541_i0.mono (by decide +kernel) +theorem row_works_541 : Template HasSnaky 10 required_541 envelope_541 := by + refine compose HasSnaky 9 childrenC_541 childrenD_541 children_work_541 (1, 8) + required_541 envelope_541 pivot_mem_541 child_required_sub_541 child_envelope_sub_541 ?_ + intro b hb + exact common_sub_541 (mem_commonEnvelope childrenD_541 b hb) +def required_545_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_545_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 7), (0, 8), (0, 9), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_545_i0 : Fin 4 → Finset Cell := ![(placed21 2 (2, 2) required_19), (placed21 2 (2, 2) required_84), (placed21 5 (2, 3) required_314), (placed21 4 (0, 7) required_419)] +def childrenD_545_i0 : Fin 4 → Finset Cell := ![(placed21 2 (2, 2) envelope_19), (placed21 2 (2, 2) envelope_84), (placed21 5 (2, 3) envelope_314), (placed21 4 (0, 7) envelope_419)] +theorem common_sub_545_i0 : commonEnvelope childrenD_545_i0 ⊆ insert (1, 6) required_545_i0 := by decide +kernel +theorem child_required_sub_545_i0 : ∀ j, childrenC_545_i0 j ⊆ insert (1, 6) required_545_i0 := by decide +kernel +theorem child_envelope_sub_545_i0 : ∀ j, childrenD_545_i0 j ⊆ envelope_545_i0 := by decide +kernel +theorem pivot_mem_545_i0 : (1, 6) ∈ envelope_545_i0 := by decide +kernel +theorem children_work_545_i0 : ∀ j, Template HasSnaky 8 (childrenC_545_i0 j) (childrenD_545_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_84 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_314 5 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_419 4 (0, 7)).mono (by decide +kernel) +theorem row_works_545_i0 : Template HasSnaky 9 required_545_i0 envelope_545_i0 := by + refine compose HasSnaky 8 childrenC_545_i0 childrenD_545_i0 children_work_545_i0 (1, 6) + required_545_i0 envelope_545_i0 pivot_mem_545_i0 child_required_sub_545_i0 child_envelope_sub_545_i0 ?_ + intro b hb + exact common_sub_545_i0 (mem_commonEnvelope childrenD_545_i0 b hb) +def required_545 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_545 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (5, 2), (5, 3), (5, 4), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_545 : Fin 4 → Finset Cell := ![(placed21 4 (1, 6) required_27), (placed21 0 (1, 2) required_52), (placed21 6 (2, 9) required_284), required_545_i0] +def childrenD_545 : Fin 4 → Finset Cell := ![(placed21 4 (1, 6) envelope_27), (placed21 0 (1, 2) envelope_52), (placed21 6 (2, 9) envelope_284), envelope_545_i0] +theorem common_sub_545 : commonEnvelope childrenD_545 ⊆ insert (1, 3) required_545 := by decide +kernel +theorem child_required_sub_545 : ∀ j, childrenC_545 j ⊆ insert (1, 3) required_545 := by decide +kernel +theorem child_envelope_sub_545 : ∀ j, childrenD_545 j ⊆ envelope_545 := by decide +kernel +theorem pivot_mem_545 : (1, 3) ∈ envelope_545 := by decide +kernel +theorem children_work_545 : ∀ j, Template HasSnaky 9 (childrenC_545 j) (childrenD_545 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_27 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_284 6 (2, 9)).mono (by decide +kernel) + · exact row_works_545_i0.mono (by decide +kernel) +theorem row_works_545 : Template HasSnaky 10 required_545 envelope_545 := by + refine compose HasSnaky 9 childrenC_545 childrenD_545 children_work_545 (1, 3) + required_545 envelope_545 pivot_mem_545 child_required_sub_545 child_envelope_sub_545 ?_ + intro b hb + exact common_sub_545 (mem_commonEnvelope childrenD_545 b hb) +def height_529_i4 : ℕ := 2 +def childrenH_529_i4 : Fin 2 → ℕ := ![height_4, height_4] +theorem height_exact_529_i4 : height_529_i4 = 1 + Finset.univ.sup childrenH_529_i4 := by decide +kernel +theorem required_origin_529_i4 : ∀ x ∈ required_529_i4, + (∃ j, x ∈ childrenC_529_i4 j) ∨ ∀ j, x ∈ childrenD_529_i4 j := by decide +kernel +theorem required_exact_529_i4 : required_529_i4 = + ((Finset.univ.biUnion childrenC_529_i4) ∪ commonEnvelope childrenD_529_i4).erase (3, 6) := by + exact required_eq_combination childrenC_529_i4 childrenD_529_i4 (3, 6) required_529_i4 + (by decide +kernel) child_required_sub_529_i4 common_sub_529_i4 required_origin_529_i4 +theorem envelope_origin_529_i4 : ∀ x ∈ envelope_529_i4, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_529_i4 j := by decide +kernel +theorem envelope_exact_529_i4 : envelope_529_i4 = + insert (3, 6) (Finset.univ.biUnion childrenD_529_i4) := by + exact envelope_eq_combination childrenD_529_i4 (3, 6) envelope_529_i4 + pivot_mem_529_i4 child_envelope_sub_529_i4 envelope_origin_529_i4 +def checked_529_i4 : CheckedCard where + required := required_529_i4 + envelope := envelope_529_i4 + height := height_529_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_529_i4 +def height_529_i5 : ℕ := 5 +def childrenH_529_i5 : Fin 2 → ℕ := ![height_38, height_351] +theorem height_exact_529_i5 : height_529_i5 = 1 + Finset.univ.sup childrenH_529_i5 := by decide +kernel +theorem required_origin_529_i5 : ∀ x ∈ required_529_i5, + (∃ j, x ∈ childrenC_529_i5 j) ∨ ∀ j, x ∈ childrenD_529_i5 j := by decide +kernel +theorem required_exact_529_i5 : required_529_i5 = + ((Finset.univ.biUnion childrenC_529_i5) ∪ commonEnvelope childrenD_529_i5).erase (7, 3) := by + exact required_eq_combination childrenC_529_i5 childrenD_529_i5 (7, 3) required_529_i5 + (by decide +kernel) child_required_sub_529_i5 common_sub_529_i5 required_origin_529_i5 +theorem envelope_origin_529_i5 : ∀ x ∈ envelope_529_i5, + x = (7, 3) ∨ ∃ j, x ∈ childrenD_529_i5 j := by decide +kernel +theorem envelope_exact_529_i5 : envelope_529_i5 = + insert (7, 3) (Finset.univ.biUnion childrenD_529_i5) := by + exact envelope_eq_combination childrenD_529_i5 (7, 3) envelope_529_i5 + pivot_mem_529_i5 child_envelope_sub_529_i5 envelope_origin_529_i5 +def checked_529_i5 : CheckedCard where + required := required_529_i5 + envelope := envelope_529_i5 + height := height_529_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_529_i5 +def height_529_i3 : ℕ := 6 +def childrenH_529_i3 : Fin 2 → ℕ := ![height_529_i4, height_529_i5] +theorem height_exact_529_i3 : height_529_i3 = 1 + Finset.univ.sup childrenH_529_i3 := by decide +kernel +theorem required_origin_529_i3 : ∀ x ∈ required_529_i3, + (∃ j, x ∈ childrenC_529_i3 j) ∨ ∀ j, x ∈ childrenD_529_i3 j := by decide +kernel +theorem required_exact_529_i3 : required_529_i3 = + ((Finset.univ.biUnion childrenC_529_i3) ∪ commonEnvelope childrenD_529_i3).erase (7, 5) := by + exact required_eq_combination childrenC_529_i3 childrenD_529_i3 (7, 5) required_529_i3 + (by decide +kernel) child_required_sub_529_i3 common_sub_529_i3 required_origin_529_i3 +theorem envelope_origin_529_i3 : ∀ x ∈ envelope_529_i3, + x = (7, 5) ∨ ∃ j, x ∈ childrenD_529_i3 j := by decide +kernel +theorem envelope_exact_529_i3 : envelope_529_i3 = + insert (7, 5) (Finset.univ.biUnion childrenD_529_i3) := by + exact envelope_eq_combination childrenD_529_i3 (7, 5) envelope_529_i3 + pivot_mem_529_i3 child_envelope_sub_529_i3 envelope_origin_529_i3 +def checked_529_i3 : CheckedCard where + required := required_529_i3 + envelope := envelope_529_i3 + height := height_529_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_529_i3 +def height_529_i2 : ℕ := 7 +def childrenH_529_i2 : Fin 2 → ℕ := ![height_5, height_529_i3] +theorem height_exact_529_i2 : height_529_i2 = 1 + Finset.univ.sup childrenH_529_i2 := by decide +kernel +theorem required_origin_529_i2 : ∀ x ∈ required_529_i2, + (∃ j, x ∈ childrenC_529_i2 j) ∨ ∀ j, x ∈ childrenD_529_i2 j := by decide +kernel +theorem required_exact_529_i2 : required_529_i2 = + ((Finset.univ.biUnion childrenC_529_i2) ∪ commonEnvelope childrenD_529_i2).erase (4, 6) := by + exact required_eq_combination childrenC_529_i2 childrenD_529_i2 (4, 6) required_529_i2 + (by decide +kernel) child_required_sub_529_i2 common_sub_529_i2 required_origin_529_i2 +theorem envelope_origin_529_i2 : ∀ x ∈ envelope_529_i2, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_529_i2 j := by decide +kernel +theorem envelope_exact_529_i2 : envelope_529_i2 = + insert (4, 6) (Finset.univ.biUnion childrenD_529_i2) := by + exact envelope_eq_combination childrenD_529_i2 (4, 6) envelope_529_i2 + pivot_mem_529_i2 child_envelope_sub_529_i2 envelope_origin_529_i2 +def checked_529_i2 : CheckedCard where + required := required_529_i2 + envelope := envelope_529_i2 + height := height_529_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_529_i2 +def height_529_i1 : ℕ := 8 +def childrenH_529_i1 : Fin 2 → ℕ := ![height_5, height_529_i2] +theorem height_exact_529_i1 : height_529_i1 = 1 + Finset.univ.sup childrenH_529_i1 := by decide +kernel +theorem required_origin_529_i1 : ∀ x ∈ required_529_i1, + (∃ j, x ∈ childrenC_529_i1 j) ∨ ∀ j, x ∈ childrenD_529_i1 j := by decide +kernel +theorem required_exact_529_i1 : required_529_i1 = + ((Finset.univ.biUnion childrenC_529_i1) ∪ commonEnvelope childrenD_529_i1).erase (6, 6) := by + exact required_eq_combination childrenC_529_i1 childrenD_529_i1 (6, 6) required_529_i1 + (by decide +kernel) child_required_sub_529_i1 common_sub_529_i1 required_origin_529_i1 +theorem envelope_origin_529_i1 : ∀ x ∈ envelope_529_i1, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_529_i1 j := by decide +kernel +theorem envelope_exact_529_i1 : envelope_529_i1 = + insert (6, 6) (Finset.univ.biUnion childrenD_529_i1) := by + exact envelope_eq_combination childrenD_529_i1 (6, 6) envelope_529_i1 + pivot_mem_529_i1 child_envelope_sub_529_i1 envelope_origin_529_i1 +def checked_529_i1 : CheckedCard where + required := required_529_i1 + envelope := envelope_529_i1 + height := height_529_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_529_i1 +def height_529_i0 : ℕ := 9 +def childrenH_529_i0 : Fin 3 → ℕ := ![height_133, height_529_i1, height_505] +theorem height_exact_529_i0 : height_529_i0 = 1 + Finset.univ.sup childrenH_529_i0 := by decide +kernel +theorem required_origin_529_i0 : ∀ x ∈ required_529_i0, + (∃ j, x ∈ childrenC_529_i0 j) ∨ ∀ j, x ∈ childrenD_529_i0 j := by decide +kernel +theorem required_exact_529_i0 : required_529_i0 = + ((Finset.univ.biUnion childrenC_529_i0) ∪ commonEnvelope childrenD_529_i0).erase (5, 3) := by + exact required_eq_combination childrenC_529_i0 childrenD_529_i0 (5, 3) required_529_i0 + (by decide +kernel) child_required_sub_529_i0 common_sub_529_i0 required_origin_529_i0 +theorem envelope_origin_529_i0 : ∀ x ∈ envelope_529_i0, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_529_i0 j := by decide +kernel +theorem envelope_exact_529_i0 : envelope_529_i0 = + insert (5, 3) (Finset.univ.biUnion childrenD_529_i0) := by + exact envelope_eq_combination childrenD_529_i0 (5, 3) envelope_529_i0 + pivot_mem_529_i0 child_envelope_sub_529_i0 envelope_origin_529_i0 +def checked_529_i0 : CheckedCard where + required := required_529_i0 + envelope := envelope_529_i0 + height := height_529_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_529_i0 +def height_529 : ℕ := 10 +def childrenH_529 : Fin 7 → ℕ := ![height_12, height_181, height_189, height_369, height_474, height_528, height_529_i0] +theorem height_exact_529 : height_529 = 1 + Finset.univ.sup childrenH_529 := by decide +kernel +theorem required_origin_529 : ∀ x ∈ required_529, + (∃ j, x ∈ childrenC_529 j) ∨ ∀ j, x ∈ childrenD_529 j := by decide +kernel +theorem required_exact_529 : required_529 = + ((Finset.univ.biUnion childrenC_529) ∪ commonEnvelope childrenD_529).erase (5, 6) := by + exact required_eq_combination childrenC_529 childrenD_529 (5, 6) required_529 + (by decide +kernel) child_required_sub_529 common_sub_529 required_origin_529 +theorem envelope_origin_529 : ∀ x ∈ envelope_529, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_529 j := by decide +kernel +theorem envelope_exact_529 : envelope_529 = + insert (5, 6) (Finset.univ.biUnion childrenD_529) := by + exact envelope_eq_combination childrenD_529 (5, 6) envelope_529 + pivot_mem_529 child_envelope_sub_529 envelope_origin_529 +def checked_529 : CheckedCard where + required := required_529 + envelope := envelope_529 + height := height_529 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_529 +def height_535 : ℕ := 10 +def childrenH_535 : Fin 7 → ℕ := ![height_345, height_421, height_522, height_530, height_532, height_533, height_534] +theorem height_exact_535 : height_535 = 1 + Finset.univ.sup childrenH_535 := by decide +kernel +theorem required_origin_535 : ∀ x ∈ required_535, + (∃ j, x ∈ childrenC_535 j) ∨ ∀ j, x ∈ childrenD_535 j := by decide +kernel +theorem required_exact_535 : required_535 = + ((Finset.univ.biUnion childrenC_535) ∪ commonEnvelope childrenD_535).erase (3, 5) := by + exact required_eq_combination childrenC_535 childrenD_535 (3, 5) required_535 + (by decide +kernel) child_required_sub_535 common_sub_535 required_origin_535 +theorem envelope_origin_535 : ∀ x ∈ envelope_535, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_535 j := by decide +kernel +theorem envelope_exact_535 : envelope_535 = + insert (3, 5) (Finset.univ.biUnion childrenD_535) := by + exact envelope_eq_combination childrenD_535 (3, 5) envelope_535 + pivot_mem_535 child_envelope_sub_535 envelope_origin_535 +def checked_535 : CheckedCard where + required := required_535 + envelope := envelope_535 + height := height_535 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_535 +def height_540_i0 : ℕ := 6 +def childrenH_540_i0 : Fin 2 → ℕ := ![height_237, height_281] +theorem height_exact_540_i0 : height_540_i0 = 1 + Finset.univ.sup childrenH_540_i0 := by decide +kernel +theorem required_origin_540_i0 : ∀ x ∈ required_540_i0, + (∃ j, x ∈ childrenC_540_i0 j) ∨ ∀ j, x ∈ childrenD_540_i0 j := by decide +kernel +theorem required_exact_540_i0 : required_540_i0 = + ((Finset.univ.biUnion childrenC_540_i0) ∪ commonEnvelope childrenD_540_i0).erase (2, 3) := by + exact required_eq_combination childrenC_540_i0 childrenD_540_i0 (2, 3) required_540_i0 + (by decide +kernel) child_required_sub_540_i0 common_sub_540_i0 required_origin_540_i0 +theorem envelope_origin_540_i0 : ∀ x ∈ envelope_540_i0, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_540_i0 j := by decide +kernel +theorem envelope_exact_540_i0 : envelope_540_i0 = + insert (2, 3) (Finset.univ.biUnion childrenD_540_i0) := by + exact envelope_eq_combination childrenD_540_i0 (2, 3) envelope_540_i0 + pivot_mem_540_i0 child_envelope_sub_540_i0 envelope_origin_540_i0 +def checked_540_i0 : CheckedCard where + required := required_540_i0 + envelope := envelope_540_i0 + height := height_540_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_540_i0 +def height_540_i3 : ℕ := 7 +def childrenH_540_i3 : Fin 3 → ℕ := ![height_164, height_199, height_283] +theorem height_exact_540_i3 : height_540_i3 = 1 + Finset.univ.sup childrenH_540_i3 := by decide +kernel +theorem required_origin_540_i3 : ∀ x ∈ required_540_i3, + (∃ j, x ∈ childrenC_540_i3 j) ∨ ∀ j, x ∈ childrenD_540_i3 j := by decide +kernel +theorem required_exact_540_i3 : required_540_i3 = + ((Finset.univ.biUnion childrenC_540_i3) ∪ commonEnvelope childrenD_540_i3).erase (4, 4) := by + exact required_eq_combination childrenC_540_i3 childrenD_540_i3 (4, 4) required_540_i3 + (by decide +kernel) child_required_sub_540_i3 common_sub_540_i3 required_origin_540_i3 +theorem envelope_origin_540_i3 : ∀ x ∈ envelope_540_i3, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_540_i3 j := by decide +kernel +theorem envelope_exact_540_i3 : envelope_540_i3 = + insert (4, 4) (Finset.univ.biUnion childrenD_540_i3) := by + exact envelope_eq_combination childrenD_540_i3 (4, 4) envelope_540_i3 + pivot_mem_540_i3 child_envelope_sub_540_i3 envelope_origin_540_i3 +def checked_540_i3 : CheckedCard where + required := required_540_i3 + envelope := envelope_540_i3 + height := height_540_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_540_i3 +def height_540_i2 : ℕ := 8 +def childrenH_540_i2 : Fin 2 → ℕ := ![height_170, height_540_i3] +theorem height_exact_540_i2 : height_540_i2 = 1 + Finset.univ.sup childrenH_540_i2 := by decide +kernel +theorem required_origin_540_i2 : ∀ x ∈ required_540_i2, + (∃ j, x ∈ childrenC_540_i2 j) ∨ ∀ j, x ∈ childrenD_540_i2 j := by decide +kernel +theorem required_exact_540_i2 : required_540_i2 = + ((Finset.univ.biUnion childrenC_540_i2) ∪ commonEnvelope childrenD_540_i2).erase (4, 5) := by + exact required_eq_combination childrenC_540_i2 childrenD_540_i2 (4, 5) required_540_i2 + (by decide +kernel) child_required_sub_540_i2 common_sub_540_i2 required_origin_540_i2 +theorem envelope_origin_540_i2 : ∀ x ∈ envelope_540_i2, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_540_i2 j := by decide +kernel +theorem envelope_exact_540_i2 : envelope_540_i2 = + insert (4, 5) (Finset.univ.biUnion childrenD_540_i2) := by + exact envelope_eq_combination childrenD_540_i2 (4, 5) envelope_540_i2 + pivot_mem_540_i2 child_envelope_sub_540_i2 envelope_origin_540_i2 +def checked_540_i2 : CheckedCard where + required := required_540_i2 + envelope := envelope_540_i2 + height := height_540_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_540_i2 +def height_540_i1 : ℕ := 9 +def childrenH_540_i1 : Fin 2 → ℕ := ![height_16, height_540_i2] +theorem height_exact_540_i1 : height_540_i1 = 1 + Finset.univ.sup childrenH_540_i1 := by decide +kernel +theorem required_origin_540_i1 : ∀ x ∈ required_540_i1, + (∃ j, x ∈ childrenC_540_i1 j) ∨ ∀ j, x ∈ childrenD_540_i1 j := by decide +kernel +theorem required_exact_540_i1 : required_540_i1 = + ((Finset.univ.biUnion childrenC_540_i1) ∪ commonEnvelope childrenD_540_i1).erase (0, 6) := by + exact required_eq_combination childrenC_540_i1 childrenD_540_i1 (0, 6) required_540_i1 + (by decide +kernel) child_required_sub_540_i1 common_sub_540_i1 required_origin_540_i1 +theorem envelope_origin_540_i1 : ∀ x ∈ envelope_540_i1, + x = (0, 6) ∨ ∃ j, x ∈ childrenD_540_i1 j := by decide +kernel +theorem envelope_exact_540_i1 : envelope_540_i1 = + insert (0, 6) (Finset.univ.biUnion childrenD_540_i1) := by + exact envelope_eq_combination childrenD_540_i1 (0, 6) envelope_540_i1 + pivot_mem_540_i1 child_envelope_sub_540_i1 envelope_origin_540_i1 +def checked_540_i1 : CheckedCard where + required := required_540_i1 + envelope := envelope_540_i1 + height := height_540_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_540_i1 +def height_540 : ℕ := 10 +def childrenH_540 : Fin 3 → ℕ := ![height_44, height_540_i0, height_540_i1] +theorem height_exact_540 : height_540 = 1 + Finset.univ.sup childrenH_540 := by decide +kernel +theorem required_origin_540 : ∀ x ∈ required_540, + (∃ j, x ∈ childrenC_540 j) ∨ ∀ j, x ∈ childrenD_540 j := by decide +kernel +theorem required_exact_540 : required_540 = + ((Finset.univ.biUnion childrenC_540) ∪ commonEnvelope childrenD_540).erase (4, 3) := by + exact required_eq_combination childrenC_540 childrenD_540 (4, 3) required_540 + (by decide +kernel) child_required_sub_540 common_sub_540 required_origin_540 +theorem envelope_origin_540 : ∀ x ∈ envelope_540, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_540 j := by decide +kernel +theorem envelope_exact_540 : envelope_540 = + insert (4, 3) (Finset.univ.biUnion childrenD_540) := by + exact envelope_eq_combination childrenD_540 (4, 3) envelope_540 + pivot_mem_540 child_envelope_sub_540 envelope_origin_540 +def checked_540 : CheckedCard where + required := required_540 + envelope := envelope_540 + height := height_540 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_540 +def height_541_i6 : ℕ := 3 +def childrenH_541_i6 : Fin 2 → ℕ := ![height_0, height_35] +theorem height_exact_541_i6 : height_541_i6 = 1 + Finset.univ.sup childrenH_541_i6 := by decide +kernel +theorem required_origin_541_i6 : ∀ x ∈ required_541_i6, + (∃ j, x ∈ childrenC_541_i6 j) ∨ ∀ j, x ∈ childrenD_541_i6 j := by decide +kernel +theorem required_exact_541_i6 : required_541_i6 = + ((Finset.univ.biUnion childrenC_541_i6) ∪ commonEnvelope childrenD_541_i6).erase (4, 2) := by + exact required_eq_combination childrenC_541_i6 childrenD_541_i6 (4, 2) required_541_i6 + (by decide +kernel) child_required_sub_541_i6 common_sub_541_i6 required_origin_541_i6 +theorem envelope_origin_541_i6 : ∀ x ∈ envelope_541_i6, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_541_i6 j := by decide +kernel +theorem envelope_exact_541_i6 : envelope_541_i6 = + insert (4, 2) (Finset.univ.biUnion childrenD_541_i6) := by + exact envelope_eq_combination childrenD_541_i6 (4, 2) envelope_541_i6 + pivot_mem_541_i6 child_envelope_sub_541_i6 envelope_origin_541_i6 +def checked_541_i6 : CheckedCard where + required := required_541_i6 + envelope := envelope_541_i6 + height := height_541_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_541_i6 +def height_541_i5 : ℕ := 4 +def childrenH_541_i5 : Fin 2 → ℕ := ![height_170, height_541_i6] +theorem height_exact_541_i5 : height_541_i5 = 1 + Finset.univ.sup childrenH_541_i5 := by decide +kernel +theorem required_origin_541_i5 : ∀ x ∈ required_541_i5, + (∃ j, x ∈ childrenC_541_i5 j) ∨ ∀ j, x ∈ childrenD_541_i5 j := by decide +kernel +theorem required_exact_541_i5 : required_541_i5 = + ((Finset.univ.biUnion childrenC_541_i5) ∪ commonEnvelope childrenD_541_i5).erase (4, 3) := by + exact required_eq_combination childrenC_541_i5 childrenD_541_i5 (4, 3) required_541_i5 + (by decide +kernel) child_required_sub_541_i5 common_sub_541_i5 required_origin_541_i5 +theorem envelope_origin_541_i5 : ∀ x ∈ envelope_541_i5, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_541_i5 j := by decide +kernel +theorem envelope_exact_541_i5 : envelope_541_i5 = + insert (4, 3) (Finset.univ.biUnion childrenD_541_i5) := by + exact envelope_eq_combination childrenD_541_i5 (4, 3) envelope_541_i5 + pivot_mem_541_i5 child_envelope_sub_541_i5 envelope_origin_541_i5 +def checked_541_i5 : CheckedCard where + required := required_541_i5 + envelope := envelope_541_i5 + height := height_541_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_541_i5 +def height_541_i4 : ℕ := 5 +def childrenH_541_i4 : Fin 3 → ℕ := ![height_6, height_86, height_541_i5] +theorem height_exact_541_i4 : height_541_i4 = 1 + Finset.univ.sup childrenH_541_i4 := by decide +kernel +theorem required_origin_541_i4 : ∀ x ∈ required_541_i4, + (∃ j, x ∈ childrenC_541_i4 j) ∨ ∀ j, x ∈ childrenD_541_i4 j := by decide +kernel +theorem required_exact_541_i4 : required_541_i4 = + ((Finset.univ.biUnion childrenC_541_i4) ∪ commonEnvelope childrenD_541_i4).erase (3, 4) := by + exact required_eq_combination childrenC_541_i4 childrenD_541_i4 (3, 4) required_541_i4 + (by decide +kernel) child_required_sub_541_i4 common_sub_541_i4 required_origin_541_i4 +theorem envelope_origin_541_i4 : ∀ x ∈ envelope_541_i4, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_541_i4 j := by decide +kernel +theorem envelope_exact_541_i4 : envelope_541_i4 = + insert (3, 4) (Finset.univ.biUnion childrenD_541_i4) := by + exact envelope_eq_combination childrenD_541_i4 (3, 4) envelope_541_i4 + pivot_mem_541_i4 child_envelope_sub_541_i4 envelope_origin_541_i4 +def checked_541_i4 : CheckedCard where + required := required_541_i4 + envelope := envelope_541_i4 + height := height_541_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_541_i4 +def height_541_i3 : ℕ := 6 +def childrenH_541_i3 : Fin 2 → ℕ := ![height_0, height_541_i4] +theorem height_exact_541_i3 : height_541_i3 = 1 + Finset.univ.sup childrenH_541_i3 := by decide +kernel +theorem required_origin_541_i3 : ∀ x ∈ required_541_i3, + (∃ j, x ∈ childrenC_541_i3 j) ∨ ∀ j, x ∈ childrenD_541_i3 j := by decide +kernel +theorem required_exact_541_i3 : required_541_i3 = + ((Finset.univ.biUnion childrenC_541_i3) ∪ commonEnvelope childrenD_541_i3).erase (3, 5) := by + exact required_eq_combination childrenC_541_i3 childrenD_541_i3 (3, 5) required_541_i3 + (by decide +kernel) child_required_sub_541_i3 common_sub_541_i3 required_origin_541_i3 +theorem envelope_origin_541_i3 : ∀ x ∈ envelope_541_i3, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_541_i3 j := by decide +kernel +theorem envelope_exact_541_i3 : envelope_541_i3 = + insert (3, 5) (Finset.univ.biUnion childrenD_541_i3) := by + exact envelope_eq_combination childrenD_541_i3 (3, 5) envelope_541_i3 + pivot_mem_541_i3 child_envelope_sub_541_i3 envelope_origin_541_i3 +def checked_541_i3 : CheckedCard where + required := required_541_i3 + envelope := envelope_541_i3 + height := height_541_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_541_i3 +def height_541_i2 : ℕ := 7 +def childrenH_541_i2 : Fin 2 → ℕ := ![height_4, height_541_i3] +theorem height_exact_541_i2 : height_541_i2 = 1 + Finset.univ.sup childrenH_541_i2 := by decide +kernel +theorem required_origin_541_i2 : ∀ x ∈ required_541_i2, + (∃ j, x ∈ childrenC_541_i2 j) ∨ ∀ j, x ∈ childrenD_541_i2 j := by decide +kernel +theorem required_exact_541_i2 : required_541_i2 = + ((Finset.univ.biUnion childrenC_541_i2) ∪ commonEnvelope childrenD_541_i2).erase (2, 5) := by + exact required_eq_combination childrenC_541_i2 childrenD_541_i2 (2, 5) required_541_i2 + (by decide +kernel) child_required_sub_541_i2 common_sub_541_i2 required_origin_541_i2 +theorem envelope_origin_541_i2 : ∀ x ∈ envelope_541_i2, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_541_i2 j := by decide +kernel +theorem envelope_exact_541_i2 : envelope_541_i2 = + insert (2, 5) (Finset.univ.biUnion childrenD_541_i2) := by + exact envelope_eq_combination childrenD_541_i2 (2, 5) envelope_541_i2 + pivot_mem_541_i2 child_envelope_sub_541_i2 envelope_origin_541_i2 +def checked_541_i2 : CheckedCard where + required := required_541_i2 + envelope := envelope_541_i2 + height := height_541_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_541_i2 +def height_541_i1 : ℕ := 8 +def childrenH_541_i1 : Fin 2 → ℕ := ![height_4, height_541_i2] +theorem height_exact_541_i1 : height_541_i1 = 1 + Finset.univ.sup childrenH_541_i1 := by decide +kernel +theorem required_origin_541_i1 : ∀ x ∈ required_541_i1, + (∃ j, x ∈ childrenC_541_i1 j) ∨ ∀ j, x ∈ childrenD_541_i1 j := by decide +kernel +theorem required_exact_541_i1 : required_541_i1 = + ((Finset.univ.biUnion childrenC_541_i1) ∪ commonEnvelope childrenD_541_i1).erase (0, 4) := by + exact required_eq_combination childrenC_541_i1 childrenD_541_i1 (0, 4) required_541_i1 + (by decide +kernel) child_required_sub_541_i1 common_sub_541_i1 required_origin_541_i1 +theorem envelope_origin_541_i1 : ∀ x ∈ envelope_541_i1, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_541_i1 j := by decide +kernel +theorem envelope_exact_541_i1 : envelope_541_i1 = + insert (0, 4) (Finset.univ.biUnion childrenD_541_i1) := by + exact envelope_eq_combination childrenD_541_i1 (0, 4) envelope_541_i1 + pivot_mem_541_i1 child_envelope_sub_541_i1 envelope_origin_541_i1 +def checked_541_i1 : CheckedCard where + required := required_541_i1 + envelope := envelope_541_i1 + height := height_541_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_541_i1 +def height_541_i0 : ℕ := 9 +def childrenH_541_i0 : Fin 2 → ℕ := ![height_6, height_541_i1] +theorem height_exact_541_i0 : height_541_i0 = 1 + Finset.univ.sup childrenH_541_i0 := by decide +kernel +theorem required_origin_541_i0 : ∀ x ∈ required_541_i0, + (∃ j, x ∈ childrenC_541_i0 j) ∨ ∀ j, x ∈ childrenD_541_i0 j := by decide +kernel +theorem required_exact_541_i0 : required_541_i0 = + ((Finset.univ.biUnion childrenC_541_i0) ∪ commonEnvelope childrenD_541_i0).erase (1, 9) := by + exact required_eq_combination childrenC_541_i0 childrenD_541_i0 (1, 9) required_541_i0 + (by decide +kernel) child_required_sub_541_i0 common_sub_541_i0 required_origin_541_i0 +theorem envelope_origin_541_i0 : ∀ x ∈ envelope_541_i0, + x = (1, 9) ∨ ∃ j, x ∈ childrenD_541_i0 j := by decide +kernel +theorem envelope_exact_541_i0 : envelope_541_i0 = + insert (1, 9) (Finset.univ.biUnion childrenD_541_i0) := by + exact envelope_eq_combination childrenD_541_i0 (1, 9) envelope_541_i0 + pivot_mem_541_i0 child_envelope_sub_541_i0 envelope_origin_541_i0 +def checked_541_i0 : CheckedCard where + required := required_541_i0 + envelope := envelope_541_i0 + height := height_541_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_541_i0 +def height_541 : ℕ := 10 +def childrenH_541 : Fin 2 → ℕ := ![height_6, height_541_i0] +theorem height_exact_541 : height_541 = 1 + Finset.univ.sup childrenH_541 := by decide +kernel +theorem required_origin_541 : ∀ x ∈ required_541, + (∃ j, x ∈ childrenC_541 j) ∨ ∀ j, x ∈ childrenD_541 j := by decide +kernel +theorem required_exact_541 : required_541 = + ((Finset.univ.biUnion childrenC_541) ∪ commonEnvelope childrenD_541).erase (1, 8) := by + exact required_eq_combination childrenC_541 childrenD_541 (1, 8) required_541 + (by decide +kernel) child_required_sub_541 common_sub_541 required_origin_541 +theorem envelope_origin_541 : ∀ x ∈ envelope_541, + x = (1, 8) ∨ ∃ j, x ∈ childrenD_541 j := by decide +kernel +theorem envelope_exact_541 : envelope_541 = + insert (1, 8) (Finset.univ.biUnion childrenD_541) := by + exact envelope_eq_combination childrenD_541 (1, 8) envelope_541 + pivot_mem_541 child_envelope_sub_541 envelope_origin_541 +def checked_541 : CheckedCard where + required := required_541 + envelope := envelope_541 + height := height_541 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_541 +def height_545_i0 : ℕ := 9 +def childrenH_545_i0 : Fin 4 → ℕ := ![height_19, height_84, height_314, height_419] +theorem height_exact_545_i0 : height_545_i0 = 1 + Finset.univ.sup childrenH_545_i0 := by decide +kernel +theorem required_origin_545_i0 : ∀ x ∈ required_545_i0, + (∃ j, x ∈ childrenC_545_i0 j) ∨ ∀ j, x ∈ childrenD_545_i0 j := by decide +kernel +theorem required_exact_545_i0 : required_545_i0 = + ((Finset.univ.biUnion childrenC_545_i0) ∪ commonEnvelope childrenD_545_i0).erase (1, 6) := by + exact required_eq_combination childrenC_545_i0 childrenD_545_i0 (1, 6) required_545_i0 + (by decide +kernel) child_required_sub_545_i0 common_sub_545_i0 required_origin_545_i0 +theorem envelope_origin_545_i0 : ∀ x ∈ envelope_545_i0, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_545_i0 j := by decide +kernel +theorem envelope_exact_545_i0 : envelope_545_i0 = + insert (1, 6) (Finset.univ.biUnion childrenD_545_i0) := by + exact envelope_eq_combination childrenD_545_i0 (1, 6) envelope_545_i0 + pivot_mem_545_i0 child_envelope_sub_545_i0 envelope_origin_545_i0 +def checked_545_i0 : CheckedCard where + required := required_545_i0 + envelope := envelope_545_i0 + height := height_545_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_545_i0 +def height_545 : ℕ := 10 +def childrenH_545 : Fin 4 → ℕ := ![height_27, height_52, height_284, height_545_i0] +theorem height_exact_545 : height_545 = 1 + Finset.univ.sup childrenH_545 := by decide +kernel +theorem required_origin_545 : ∀ x ∈ required_545, + (∃ j, x ∈ childrenC_545 j) ∨ ∀ j, x ∈ childrenD_545 j := by decide +kernel +theorem required_exact_545 : required_545 = + ((Finset.univ.biUnion childrenC_545) ∪ commonEnvelope childrenD_545).erase (1, 3) := by + exact required_eq_combination childrenC_545 childrenD_545 (1, 3) required_545 + (by decide +kernel) child_required_sub_545 common_sub_545 required_origin_545 +theorem envelope_origin_545 : ∀ x ∈ envelope_545, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_545 j := by decide +kernel +theorem envelope_exact_545 : envelope_545 = + insert (1, 3) (Finset.univ.biUnion childrenD_545) := by + exact envelope_eq_combination childrenD_545 (1, 3) envelope_545 + pivot_mem_545 child_envelope_sub_545 envelope_origin_545 +def checked_545 : CheckedCard where + required := required_545 + envelope := envelope_545 + height := height_545 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_545 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part03.lean new file mode 100644 index 0000000..3280e94 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part03.lean @@ -0,0 +1,994 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_546_i4 : Finset Cell := ⟨(([(0, 6), (1, 5), (1, 6), (2, 3), (2, 4), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_546_i4 : Finset Cell := ⟨(([(0, 5), (0, 6), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 5), (5, 6), (5, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_546_i4 : Fin 3 → Finset Cell := ![(placed21 4 (0, 7) required_25), (placed21 3 (0, 6) required_27), (placed21 1 (0, 5) required_37)] +def childrenD_546_i4 : Fin 3 → Finset Cell := ![(placed21 4 (0, 7) envelope_25), (placed21 3 (0, 6) envelope_27), (placed21 1 (0, 5) envelope_37)] +theorem common_sub_546_i4 : commonEnvelope childrenD_546_i4 ⊆ insert (3, 6) required_546_i4 := by decide +kernel +theorem child_required_sub_546_i4 : ∀ j, childrenC_546_i4 j ⊆ insert (3, 6) required_546_i4 := by decide +kernel +theorem child_envelope_sub_546_i4 : ∀ j, childrenD_546_i4 j ⊆ envelope_546_i4 := by decide +kernel +theorem pivot_mem_546_i4 : (3, 6) ∈ envelope_546_i4 := by decide +kernel +theorem children_work_546_i4 : ∀ j, Template HasSnaky 4 (childrenC_546_i4 j) (childrenD_546_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_25 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_27 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_37 1 (0, 5)).mono (by decide +kernel) +theorem row_works_546_i4 : Template HasSnaky 5 required_546_i4 envelope_546_i4 := by + refine compose HasSnaky 4 childrenC_546_i4 childrenD_546_i4 children_work_546_i4 (3, 6) + required_546_i4 envelope_546_i4 pivot_mem_546_i4 child_required_sub_546_i4 child_envelope_sub_546_i4 ?_ + intro b hb + exact common_sub_546_i4 (mem_commonEnvelope childrenD_546_i4 b hb) +def required_546_i3 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (2, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_546_i3 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 5), (5, 6), (5, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_546_i3 : Fin 2 → Finset Cell := ![(placed21 5 (1, 3) required_5), required_546_i4] +def childrenD_546_i3 : Fin 2 → Finset Cell := ![(placed21 5 (1, 3) envelope_5), envelope_546_i4] +theorem common_sub_546_i3 : commonEnvelope childrenD_546_i3 ⊆ insert (0, 6) required_546_i3 := by decide +kernel +theorem child_required_sub_546_i3 : ∀ j, childrenC_546_i3 j ⊆ insert (0, 6) required_546_i3 := by decide +kernel +theorem child_envelope_sub_546_i3 : ∀ j, childrenD_546_i3 j ⊆ envelope_546_i3 := by decide +kernel +theorem pivot_mem_546_i3 : (0, 6) ∈ envelope_546_i3 := by decide +kernel +theorem children_work_546_i3 : ∀ j, Template HasSnaky 5 (childrenC_546_i3 j) (childrenD_546_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (1, 3)).mono (by decide +kernel) + · exact row_works_546_i4.mono (by decide +kernel) +theorem row_works_546_i3 : Template HasSnaky 6 required_546_i3 envelope_546_i3 := by + refine compose HasSnaky 5 childrenC_546_i3 childrenD_546_i3 children_work_546_i3 (0, 6) + required_546_i3 envelope_546_i3 pivot_mem_546_i3 child_required_sub_546_i3 child_envelope_sub_546_i3 ?_ + intro b hb + exact common_sub_546_i3 (mem_commonEnvelope childrenD_546_i3 b hb) +def required_546_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_546_i2 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 5), (5, 6), (5, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_546_i2 : Fin 2 → Finset Cell := ![(placed21 1 (1, 3) required_5), required_546_i3] +def childrenD_546_i2 : Fin 2 → Finset Cell := ![(placed21 1 (1, 3) envelope_5), envelope_546_i3] +theorem common_sub_546_i2 : commonEnvelope childrenD_546_i2 ⊆ insert (2, 6) required_546_i2 := by decide +kernel +theorem child_required_sub_546_i2 : ∀ j, childrenC_546_i2 j ⊆ insert (2, 6) required_546_i2 := by decide +kernel +theorem child_envelope_sub_546_i2 : ∀ j, childrenD_546_i2 j ⊆ envelope_546_i2 := by decide +kernel +theorem pivot_mem_546_i2 : (2, 6) ∈ envelope_546_i2 := by decide +kernel +theorem children_work_546_i2 : ∀ j, Template HasSnaky 6 (childrenC_546_i2 j) (childrenD_546_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 3)).mono (by decide +kernel) + · exact row_works_546_i3.mono (by decide +kernel) +theorem row_works_546_i2 : Template HasSnaky 7 required_546_i2 envelope_546_i2 := by + refine compose HasSnaky 6 childrenC_546_i2 childrenD_546_i2 children_work_546_i2 (2, 6) + required_546_i2 envelope_546_i2 pivot_mem_546_i2 child_required_sub_546_i2 child_envelope_sub_546_i2 ?_ + intro b hb + exact common_sub_546_i2 (mem_commonEnvelope childrenD_546_i2 b hb) +def required_546_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (1, 6), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_546_i1 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 5), (5, 6), (5, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_546_i1 : Fin 2 → Finset Cell := ![(placed21 3 (1, 6) required_5), required_546_i2] +def childrenD_546_i1 : Fin 2 → Finset Cell := ![(placed21 3 (1, 6) envelope_5), envelope_546_i2] +theorem common_sub_546_i1 : commonEnvelope childrenD_546_i1 ⊆ insert (2, 3) required_546_i1 := by decide +kernel +theorem child_required_sub_546_i1 : ∀ j, childrenC_546_i1 j ⊆ insert (2, 3) required_546_i1 := by decide +kernel +theorem child_envelope_sub_546_i1 : ∀ j, childrenD_546_i1 j ⊆ envelope_546_i1 := by decide +kernel +theorem pivot_mem_546_i1 : (2, 3) ∈ envelope_546_i1 := by decide +kernel +theorem children_work_546_i1 : ∀ j, Template HasSnaky 7 (childrenC_546_i1 j) (childrenD_546_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 6)).mono (by decide +kernel) + · exact row_works_546_i2.mono (by decide +kernel) +theorem row_works_546_i1 : Template HasSnaky 8 required_546_i1 envelope_546_i1 := by + refine compose HasSnaky 7 childrenC_546_i1 childrenD_546_i1 children_work_546_i1 (2, 3) + required_546_i1 envelope_546_i1 pivot_mem_546_i1 child_required_sub_546_i1 child_envelope_sub_546_i1 ?_ + intro b hb + exact common_sub_546_i1 (mem_commonEnvelope childrenD_546_i1 b hb) +def required_546_i0 : Finset Cell := ⟨(([(1, 4), (1, 5), (1, 6), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_546_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 5), (5, 6), (5, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_546_i0 : Fin 4 → Finset Cell := ![(placed21 4 (0, 7) required_19), (placed21 6 (2, 7) required_19), (placed21 4 (0, 7) required_62), required_546_i1] +def childrenD_546_i0 : Fin 4 → Finset Cell := ![(placed21 4 (0, 7) envelope_19), (placed21 6 (2, 7) envelope_19), (placed21 4 (0, 7) envelope_62), envelope_546_i1] +theorem common_sub_546_i0 : commonEnvelope childrenD_546_i0 ⊆ insert (1, 3) required_546_i0 := by decide +kernel +theorem child_required_sub_546_i0 : ∀ j, childrenC_546_i0 j ⊆ insert (1, 3) required_546_i0 := by decide +kernel +theorem child_envelope_sub_546_i0 : ∀ j, childrenD_546_i0 j ⊆ envelope_546_i0 := by decide +kernel +theorem pivot_mem_546_i0 : (1, 3) ∈ envelope_546_i0 := by decide +kernel +theorem children_work_546_i0 : ∀ j, Template HasSnaky 8 (childrenC_546_i0 j) (childrenD_546_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_19 6 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_62 4 (0, 7)).mono (by decide +kernel) + · exact row_works_546_i1.mono (by decide +kernel) +theorem row_works_546_i0 : Template HasSnaky 9 required_546_i0 envelope_546_i0 := by + refine compose HasSnaky 8 childrenC_546_i0 childrenD_546_i0 children_work_546_i0 (1, 3) + required_546_i0 envelope_546_i0 pivot_mem_546_i0 child_required_sub_546_i0 child_envelope_sub_546_i0 ?_ + intro b hb + exact common_sub_546_i0 (mem_commonEnvelope childrenD_546_i0 b hb) +def required_546 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_546 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 5), (5, 6), (5, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_546 : Fin 4 → Finset Cell := ![(placed21 2 (2, 3) required_10), (placed21 4 (1, 7) required_44), (placed21 2 (2, 3) required_63), required_546_i0] +def childrenD_546 : Fin 4 → Finset Cell := ![(placed21 2 (2, 3) envelope_10), (placed21 4 (1, 7) envelope_44), (placed21 2 (2, 3) envelope_63), envelope_546_i0] +theorem common_sub_546 : commonEnvelope childrenD_546 ⊆ insert (1, 6) required_546 := by decide +kernel +theorem child_required_sub_546 : ∀ j, childrenC_546 j ⊆ insert (1, 6) required_546 := by decide +kernel +theorem child_envelope_sub_546 : ∀ j, childrenD_546 j ⊆ envelope_546 := by decide +kernel +theorem pivot_mem_546 : (1, 6) ∈ envelope_546 := by decide +kernel +theorem children_work_546 : ∀ j, Template HasSnaky 9 (childrenC_546 j) (childrenD_546 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 2 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_44 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_63 2 (2, 3)).mono (by decide +kernel) + · exact row_works_546_i0.mono (by decide +kernel) +theorem row_works_546 : Template HasSnaky 10 required_546 envelope_546 := by + refine compose HasSnaky 9 childrenC_546 childrenD_546 children_work_546 (1, 6) + required_546 envelope_546 pivot_mem_546 child_required_sub_546 child_envelope_sub_546 ?_ + intro b hb + exact common_sub_546 (mem_commonEnvelope childrenD_546 b hb) +def required_556_i0 : Finset Cell := ⟨(([(2, 4), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_556_i0 : Finset Cell := ⟨(([(2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5), (8, 3), (8, 4), (8, 5), (9, 3), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_556_i0 : Fin 5 → Finset Cell := ![(placed21 4 (2, 7) required_115), (placed21 4 (2, 7) required_171), (placed21 4 (2, 5) required_197), (placed21 0 (2, 3) required_197), (placed21 4 (2, 7) required_285)] +def childrenD_556_i0 : Fin 5 → Finset Cell := ![(placed21 4 (2, 7) envelope_115), (placed21 4 (2, 7) envelope_171), (placed21 4 (2, 5) envelope_197), (placed21 0 (2, 3) envelope_197), (placed21 4 (2, 7) envelope_285)] +theorem common_sub_556_i0 : commonEnvelope childrenD_556_i0 ⊆ insert (5, 4) required_556_i0 := by decide +kernel +theorem child_required_sub_556_i0 : ∀ j, childrenC_556_i0 j ⊆ insert (5, 4) required_556_i0 := by decide +kernel +theorem child_envelope_sub_556_i0 : ∀ j, childrenD_556_i0 j ⊆ envelope_556_i0 := by decide +kernel +theorem pivot_mem_556_i0 : (5, 4) ∈ envelope_556_i0 := by decide +kernel +theorem children_work_556_i0 : ∀ j, Template HasSnaky 8 (childrenC_556_i0 j) (childrenD_556_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_115 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_171 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_197 4 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_197 0 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_285 4 (2, 7)).mono (by decide +kernel) +theorem row_works_556_i0 : Template HasSnaky 9 required_556_i0 envelope_556_i0 := by + refine compose HasSnaky 8 childrenC_556_i0 childrenD_556_i0 children_work_556_i0 (5, 4) + required_556_i0 envelope_556_i0 pivot_mem_556_i0 child_required_sub_556_i0 child_envelope_sub_556_i0 ?_ + intro b hb + exact common_sub_556_i0 (mem_commonEnvelope childrenD_556_i0 b hb) +def required_556 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_556 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5), (8, 3), (8, 4), (8, 5), (9, 3), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_556 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) required_3), required_556_i0] +def childrenD_556 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) envelope_3), envelope_556_i0] +theorem common_sub_556 : commonEnvelope childrenD_556 ⊆ insert (2, 4) required_556 := by decide +kernel +theorem child_required_sub_556 : ∀ j, childrenC_556 j ⊆ insert (2, 4) required_556 := by decide +kernel +theorem child_envelope_sub_556 : ∀ j, childrenD_556 j ⊆ envelope_556 := by decide +kernel +theorem pivot_mem_556 : (2, 4) ∈ envelope_556 := by decide +kernel +theorem children_work_556 : ∀ j, Template HasSnaky 9 (childrenC_556 j) (childrenD_556 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 6 (4, 4)).mono (by decide +kernel) + · exact row_works_556_i0.mono (by decide +kernel) +theorem row_works_556 : Template HasSnaky 10 required_556 envelope_556 := by + refine compose HasSnaky 9 childrenC_556 childrenD_556 children_work_556 (2, 4) + required_556 envelope_556 pivot_mem_556 child_required_sub_556 child_envelope_sub_556 ?_ + intro b hb + exact common_sub_556 (mem_commonEnvelope childrenD_556 b hb) +def required_560_i4 : Finset Cell := ⟨(([(3, 1), (3, 4), (4, 1), (4, 4), (5, 1), (5, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_560_i4 : Finset Cell := ⟨(([(2, 1), (3, 1), (3, 4), (4, 1), (4, 2), (4, 4), (5, 1), (5, 2), (5, 3), (5, 4), (6, 2), (6, 4), (6, 5), (7, 2), (7, 5), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_560_i4 : Fin 2 → Finset Cell := ![(placed21 1 (2, 1) required_44), (placed21 4 (3, 5) required_156)] +def childrenD_560_i4 : Fin 2 → Finset Cell := ![(placed21 1 (2, 1) envelope_44), (placed21 4 (3, 5) envelope_156)] +theorem common_sub_560_i4 : commonEnvelope childrenD_560_i4 ⊆ insert (5, 2) required_560_i4 := by decide +kernel +theorem child_required_sub_560_i4 : ∀ j, childrenC_560_i4 j ⊆ insert (5, 2) required_560_i4 := by decide +kernel +theorem child_envelope_sub_560_i4 : ∀ j, childrenD_560_i4 j ⊆ envelope_560_i4 := by decide +kernel +theorem pivot_mem_560_i4 : (5, 2) ∈ envelope_560_i4 := by decide +kernel +theorem children_work_560_i4 : ∀ j, Template HasSnaky 3 (childrenC_560_i4 j) (childrenD_560_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 1 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_156 4 (3, 5)).mono (by decide +kernel) +theorem row_works_560_i4 : Template HasSnaky 4 required_560_i4 envelope_560_i4 := by + refine compose HasSnaky 3 childrenC_560_i4 childrenD_560_i4 children_work_560_i4 (5, 2) + required_560_i4 envelope_560_i4 pivot_mem_560_i4 child_required_sub_560_i4 child_envelope_sub_560_i4 ?_ + intro b hb + exact common_sub_560_i4 (mem_commonEnvelope childrenD_560_i4 b hb) +def required_560_i3 : Finset Cell := ⟨(([(3, 1), (3, 2), (3, 4), (4, 1), (4, 4), (5, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_560_i3 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 4), (5, 1), (5, 2), (5, 3), (5, 4), (6, 1), (6, 2), (6, 4), (6, 5), (7, 2), (7, 5), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_560_i3 : Fin 3 → Finset Cell := ![(placed21 5 (6, 1) required_44), (placed21 5 (6, 1) required_52), required_560_i4] +def childrenD_560_i3 : Fin 3 → Finset Cell := ![(placed21 5 (6, 1) envelope_44), (placed21 5 (6, 1) envelope_52), envelope_560_i4] +theorem common_sub_560_i3 : commonEnvelope childrenD_560_i3 ⊆ insert (5, 1) required_560_i3 := by decide +kernel +theorem child_required_sub_560_i3 : ∀ j, childrenC_560_i3 j ⊆ insert (5, 1) required_560_i3 := by decide +kernel +theorem child_envelope_sub_560_i3 : ∀ j, childrenD_560_i3 j ⊆ envelope_560_i3 := by decide +kernel +theorem pivot_mem_560_i3 : (5, 1) ∈ envelope_560_i3 := by decide +kernel +theorem children_work_560_i3 : ∀ j, Template HasSnaky 4 (childrenC_560_i3 j) (childrenD_560_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 5 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_52 5 (6, 1)).mono (by decide +kernel) + · exact row_works_560_i4.mono (by decide +kernel) +theorem row_works_560_i3 : Template HasSnaky 5 required_560_i3 envelope_560_i3 := by + refine compose HasSnaky 4 childrenC_560_i3 childrenD_560_i3 children_work_560_i3 (5, 1) + required_560_i3 envelope_560_i3 pivot_mem_560_i3 child_required_sub_560_i3 child_envelope_sub_560_i3 ?_ + intro b hb + exact common_sub_560_i3 (mem_commonEnvelope childrenD_560_i3 b hb) +def required_560_i2 : Finset Cell := ⟨(([(3, 1), (3, 2), (3, 3), (3, 4), (4, 4), (5, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_560_i2 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 4), (5, 1), (5, 2), (5, 3), (5, 4), (6, 1), (6, 2), (6, 4), (6, 5), (7, 2), (7, 5), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_560_i2 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) required_5), required_560_i3] +def childrenD_560_i2 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) envelope_5), envelope_560_i3] +theorem common_sub_560_i2 : commonEnvelope childrenD_560_i2 ⊆ insert (4, 1) required_560_i2 := by decide +kernel +theorem child_required_sub_560_i2 : ∀ j, childrenC_560_i2 j ⊆ insert (4, 1) required_560_i2 := by decide +kernel +theorem child_envelope_sub_560_i2 : ∀ j, childrenD_560_i2 j ⊆ envelope_560_i2 := by decide +kernel +theorem pivot_mem_560_i2 : (4, 1) ∈ envelope_560_i2 := by decide +kernel +theorem children_work_560_i2 : ∀ j, Template HasSnaky 5 (childrenC_560_i2 j) (childrenD_560_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (3, 4)).mono (by decide +kernel) + · exact row_works_560_i3.mono (by decide +kernel) +theorem row_works_560_i2 : Template HasSnaky 6 required_560_i2 envelope_560_i2 := by + refine compose HasSnaky 5 childrenC_560_i2 childrenD_560_i2 children_work_560_i2 (4, 1) + required_560_i2 envelope_560_i2 pivot_mem_560_i2 child_required_sub_560_i2 child_envelope_sub_560_i2 ?_ + intro b hb + exact common_sub_560_i2 (mem_commonEnvelope childrenD_560_i2 b hb) +def required_560_i1 : Finset Cell := ⟨(([(3, 1), (3, 2), (3, 3), (3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_560_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 4), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 1), (6, 2), (6, 4), (6, 5), (7, 2), (7, 5), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_560_i1 : Fin 2 → Finset Cell := ![(placed21 7 (6, 5) required_153), required_560_i2] +def childrenD_560_i1 : Fin 2 → Finset Cell := ![(placed21 7 (6, 5) envelope_153), envelope_560_i2] +theorem common_sub_560_i1 : commonEnvelope childrenD_560_i1 ⊆ insert (6, 5) required_560_i1 := by decide +kernel +theorem child_required_sub_560_i1 : ∀ j, childrenC_560_i1 j ⊆ insert (6, 5) required_560_i1 := by decide +kernel +theorem child_envelope_sub_560_i1 : ∀ j, childrenD_560_i1 j ⊆ envelope_560_i1 := by decide +kernel +theorem pivot_mem_560_i1 : (6, 5) ∈ envelope_560_i1 := by decide +kernel +theorem children_work_560_i1 : ∀ j, Template HasSnaky 6 (childrenC_560_i1 j) (childrenD_560_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_153 7 (6, 5)).mono (by decide +kernel) + · exact row_works_560_i2.mono (by decide +kernel) +theorem row_works_560_i1 : Template HasSnaky 7 required_560_i1 envelope_560_i1 := by + refine compose HasSnaky 6 childrenC_560_i1 childrenD_560_i1 children_work_560_i1 (6, 5) + required_560_i1 envelope_560_i1 pivot_mem_560_i1 child_required_sub_560_i1 child_envelope_sub_560_i1 ?_ + intro b hb + exact common_sub_560_i1 (mem_commonEnvelope childrenD_560_i1 b hb) +def required_560_i0 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_560_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 1), (6, 2), (6, 4), (6, 5), (7, 2), (7, 5), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_560_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 1) required_5), required_560_i1] +def childrenD_560_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 1) envelope_5), envelope_560_i1] +theorem common_sub_560_i0 : commonEnvelope childrenD_560_i0 ⊆ insert (3, 1) required_560_i0 := by decide +kernel +theorem child_required_sub_560_i0 : ∀ j, childrenC_560_i0 j ⊆ insert (3, 1) required_560_i0 := by decide +kernel +theorem child_envelope_sub_560_i0 : ∀ j, childrenD_560_i0 j ⊆ envelope_560_i0 := by decide +kernel +theorem pivot_mem_560_i0 : (3, 1) ∈ envelope_560_i0 := by decide +kernel +theorem children_work_560_i0 : ∀ j, Template HasSnaky 7 (childrenC_560_i0 j) (childrenD_560_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 1)).mono (by decide +kernel) + · exact row_works_560_i1.mono (by decide +kernel) +theorem row_works_560_i0 : Template HasSnaky 8 required_560_i0 envelope_560_i0 := by + refine compose HasSnaky 7 childrenC_560_i0 childrenD_560_i0 children_work_560_i0 (3, 1) + required_560_i0 envelope_560_i0 pivot_mem_560_i0 child_required_sub_560_i0 child_envelope_sub_560_i0 ?_ + intro b hb + exact common_sub_560_i0 (mem_commonEnvelope childrenD_560_i0 b hb) +def required_560_i5 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_560_i5 : Finset Cell := ⟨(([(1, 5), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 3), (6, 5), (7, 5), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_560_i5 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) required_227), (placed21 7 (6, 5) required_245), (placed21 4 (2, 7) required_274)] +def childrenD_560_i5 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) envelope_227), (placed21 7 (6, 5) envelope_245), (placed21 4 (2, 7) envelope_274)] +theorem common_sub_560_i5 : commonEnvelope childrenD_560_i5 ⊆ insert (5, 3) required_560_i5 := by decide +kernel +theorem child_required_sub_560_i5 : ∀ j, childrenC_560_i5 j ⊆ insert (5, 3) required_560_i5 := by decide +kernel +theorem child_envelope_sub_560_i5 : ∀ j, childrenD_560_i5 j ⊆ envelope_560_i5 := by decide +kernel +theorem pivot_mem_560_i5 : (5, 3) ∈ envelope_560_i5 := by decide +kernel +theorem children_work_560_i5 : ∀ j, Template HasSnaky 5 (childrenC_560_i5 j) (childrenD_560_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_227 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_245 7 (6, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_274 4 (2, 7)).mono (by decide +kernel) +theorem row_works_560_i5 : Template HasSnaky 6 required_560_i5 envelope_560_i5 := by + refine compose HasSnaky 5 childrenC_560_i5 childrenD_560_i5 children_work_560_i5 (5, 3) + required_560_i5 envelope_560_i5 pivot_mem_560_i5 child_required_sub_560_i5 child_envelope_sub_560_i5 ?_ + intro b hb + exact common_sub_560_i5 (mem_commonEnvelope childrenD_560_i5 b hb) +def required_560 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 2), (3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_560 : Finset Cell := ⟨(([(0, 2), (0, 3), (1, 2), (1, 3), (1, 5), (2, 1), (2, 2), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 0), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_560 : Fin 8 → Finset Cell := ![(placed21 3 (1, 5) required_67), (placed21 0 (2, 1) required_228), (placed21 4 (2, 5) required_373), (placed21 4 (2, 7) required_435), (placed21 0 (3, 1) required_531), required_560_i0, required_560_i5, (placed21 4 (0, 5) required_559)] +def childrenD_560 : Fin 8 → Finset Cell := ![(placed21 3 (1, 5) envelope_67), (placed21 0 (2, 1) envelope_228), (placed21 4 (2, 5) envelope_373), (placed21 4 (2, 7) envelope_435), (placed21 0 (3, 1) envelope_531), envelope_560_i0, envelope_560_i5, (placed21 4 (0, 5) envelope_559)] +theorem common_sub_560 : commonEnvelope childrenD_560 ⊆ insert (5, 4) required_560 := by decide +kernel +theorem child_required_sub_560 : ∀ j, childrenC_560 j ⊆ insert (5, 4) required_560 := by decide +kernel +theorem child_envelope_sub_560 : ∀ j, childrenD_560 j ⊆ envelope_560 := by decide +kernel +theorem pivot_mem_560 : (5, 4) ∈ envelope_560 := by decide +kernel +theorem children_work_560 : ∀ j, Template HasSnaky 9 (childrenC_560 j) (childrenD_560 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_67 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_228 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_373 4 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_435 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_531 0 (3, 1)).mono (by decide +kernel) + · exact row_works_560_i0.mono (by decide +kernel) + · exact row_works_560_i5.mono (by decide +kernel) + · exact (placed21_template row_works_559 4 (0, 5)).mono (by decide +kernel) +theorem row_works_560 : Template HasSnaky 10 required_560 envelope_560 := by + refine compose HasSnaky 9 childrenC_560 childrenD_560 children_work_560 (5, 4) + required_560 envelope_560 pivot_mem_560 child_required_sub_560 child_envelope_sub_560 ?_ + intro b hb + exact common_sub_560 (mem_commonEnvelope childrenD_560 b hb) +def required_563_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_563_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_563_i2 : Fin 2 → Finset Cell := ![(placed21 7 (2, 7) required_0), (placed21 4 (1, 7) required_393)] +def childrenD_563_i2 : Fin 2 → Finset Cell := ![(placed21 7 (2, 7) envelope_0), (placed21 4 (1, 7) envelope_393)] +theorem common_sub_563_i2 : commonEnvelope childrenD_563_i2 ⊆ insert (2, 6) required_563_i2 := by decide +kernel +theorem child_required_sub_563_i2 : ∀ j, childrenC_563_i2 j ⊆ insert (2, 6) required_563_i2 := by decide +kernel +theorem child_envelope_sub_563_i2 : ∀ j, childrenD_563_i2 j ⊆ envelope_563_i2 := by decide +kernel +theorem pivot_mem_563_i2 : (2, 6) ∈ envelope_563_i2 := by decide +kernel +theorem children_work_563_i2 : ∀ j, Template HasSnaky 6 (childrenC_563_i2 j) (childrenD_563_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_393 4 (1, 7)).mono (by decide +kernel) +theorem row_works_563_i2 : Template HasSnaky 7 required_563_i2 envelope_563_i2 := by + refine compose HasSnaky 6 childrenC_563_i2 childrenD_563_i2 children_work_563_i2 (2, 6) + required_563_i2 envelope_563_i2 pivot_mem_563_i2 child_required_sub_563_i2 child_envelope_sub_563_i2 ?_ + intro b hb + exact common_sub_563_i2 (mem_commonEnvelope childrenD_563_i2 b hb) +def required_563_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 5), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_563_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_563_i1 : Fin 2 → Finset Cell := ![(placed21 6 (5, 5) required_0), required_563_i2] +def childrenD_563_i1 : Fin 2 → Finset Cell := ![(placed21 6 (5, 5) envelope_0), envelope_563_i2] +theorem common_sub_563_i1 : commonEnvelope childrenD_563_i1 ⊆ insert (2, 4) required_563_i1 := by decide +kernel +theorem child_required_sub_563_i1 : ∀ j, childrenC_563_i1 j ⊆ insert (2, 4) required_563_i1 := by decide +kernel +theorem child_envelope_sub_563_i1 : ∀ j, childrenD_563_i1 j ⊆ envelope_563_i1 := by decide +kernel +theorem pivot_mem_563_i1 : (2, 4) ∈ envelope_563_i1 := by decide +kernel +theorem children_work_563_i1 : ∀ j, Template HasSnaky 7 (childrenC_563_i1 j) (childrenD_563_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 5)).mono (by decide +kernel) + · exact row_works_563_i2.mono (by decide +kernel) +theorem row_works_563_i1 : Template HasSnaky 8 required_563_i1 envelope_563_i1 := by + refine compose HasSnaky 7 childrenC_563_i1 childrenD_563_i1 children_work_563_i1 (2, 4) + required_563_i1 envelope_563_i1 pivot_mem_563_i1 child_required_sub_563_i1 child_envelope_sub_563_i1 ?_ + intro b hb + exact common_sub_563_i1 (mem_commonEnvelope childrenD_563_i1 b hb) +def required_563_i6 : Finset Cell := ⟨(([(1, 3), (2, 5), (3, 4), (3, 5), (3, 6), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_563_i6 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_563_i6 : Fin 2 → Finset Cell := ![(placed21 6 (3, 7) required_11), (placed21 7 (4, 6) required_38)] +def childrenD_563_i6 : Fin 2 → Finset Cell := ![(placed21 6 (3, 7) envelope_11), (placed21 7 (4, 6) envelope_38)] +theorem common_sub_563_i6 : commonEnvelope childrenD_563_i6 ⊆ insert (3, 3) required_563_i6 := by decide +kernel +theorem child_required_sub_563_i6 : ∀ j, childrenC_563_i6 j ⊆ insert (3, 3) required_563_i6 := by decide +kernel +theorem child_envelope_sub_563_i6 : ∀ j, childrenD_563_i6 j ⊆ envelope_563_i6 := by decide +kernel +theorem pivot_mem_563_i6 : (3, 3) ∈ envelope_563_i6 := by decide +kernel +theorem children_work_563_i6 : ∀ j, Template HasSnaky 2 (childrenC_563_i6 j) (childrenD_563_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 6 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_38 7 (4, 6)).mono (by decide +kernel) +theorem row_works_563_i6 : Template HasSnaky 3 required_563_i6 envelope_563_i6 := by + refine compose HasSnaky 2 childrenC_563_i6 childrenD_563_i6 children_work_563_i6 (3, 3) + required_563_i6 envelope_563_i6 pivot_mem_563_i6 child_required_sub_563_i6 child_envelope_sub_563_i6 ?_ + intro b hb + exact common_sub_563_i6 (mem_commonEnvelope childrenD_563_i6 b hb) +def required_563_i5 : Finset Cell := ⟨(([(1, 3), (2, 5), (3, 4), (3, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_563_i5 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_563_i5 : Fin 2 → Finset Cell := ![(placed21 4 (3, 7) required_15), required_563_i6] +def childrenD_563_i5 : Fin 2 → Finset Cell := ![(placed21 4 (3, 7) envelope_15), envelope_563_i6] +theorem common_sub_563_i5 : commonEnvelope childrenD_563_i5 ⊆ insert (3, 6) required_563_i5 := by decide +kernel +theorem child_required_sub_563_i5 : ∀ j, childrenC_563_i5 j ⊆ insert (3, 6) required_563_i5 := by decide +kernel +theorem child_envelope_sub_563_i5 : ∀ j, childrenD_563_i5 j ⊆ envelope_563_i5 := by decide +kernel +theorem pivot_mem_563_i5 : (3, 6) ∈ envelope_563_i5 := by decide +kernel +theorem children_work_563_i5 : ∀ j, Template HasSnaky 3 (childrenC_563_i5 j) (childrenD_563_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 4 (3, 7)).mono (by decide +kernel) + · exact row_works_563_i6.mono (by decide +kernel) +theorem row_works_563_i5 : Template HasSnaky 4 required_563_i5 envelope_563_i5 := by + refine compose HasSnaky 3 childrenC_563_i5 childrenD_563_i5 children_work_563_i5 (3, 6) + required_563_i5 envelope_563_i5 pivot_mem_563_i5 child_required_sub_563_i5 child_envelope_sub_563_i5 ?_ + intro b hb + exact common_sub_563_i5 (mem_commonEnvelope childrenD_563_i5 b hb) +def required_563_i4 : Finset Cell := ⟨(([(1, 3), (1, 5), (2, 5), (3, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_563_i4 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_563_i4 : Fin 2 → Finset Cell := ![(placed21 4 (0, 5) required_0), required_563_i5] +def childrenD_563_i4 : Fin 2 → Finset Cell := ![(placed21 4 (0, 5) envelope_0), envelope_563_i5] +theorem common_sub_563_i4 : commonEnvelope childrenD_563_i4 ⊆ insert (3, 4) required_563_i4 := by decide +kernel +theorem child_required_sub_563_i4 : ∀ j, childrenC_563_i4 j ⊆ insert (3, 4) required_563_i4 := by decide +kernel +theorem child_envelope_sub_563_i4 : ∀ j, childrenD_563_i4 j ⊆ envelope_563_i4 := by decide +kernel +theorem pivot_mem_563_i4 : (3, 4) ∈ envelope_563_i4 := by decide +kernel +theorem children_work_563_i4 : ∀ j, Template HasSnaky 4 (childrenC_563_i4 j) (childrenD_563_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 4 (0, 5)).mono (by decide +kernel) + · exact row_works_563_i5.mono (by decide +kernel) +theorem row_works_563_i4 : Template HasSnaky 5 required_563_i4 envelope_563_i4 := by + refine compose HasSnaky 4 childrenC_563_i4 childrenD_563_i4 children_work_563_i4 (3, 4) + required_563_i4 envelope_563_i4 pivot_mem_563_i4 child_required_sub_563_i4 child_envelope_sub_563_i4 ?_ + intro b hb + exact common_sub_563_i4 (mem_commonEnvelope childrenD_563_i4 b hb) +def required_563_i3 : Finset Cell := ⟨(([(1, 3), (1, 5), (2, 5), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_563_i3 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_563_i3 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) required_5), required_563_i4] +def childrenD_563_i3 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) envelope_5), envelope_563_i4] +theorem common_sub_563_i3 : commonEnvelope childrenD_563_i3 ⊆ insert (4, 4) required_563_i3 := by decide +kernel +theorem child_required_sub_563_i3 : ∀ j, childrenC_563_i3 j ⊆ insert (4, 4) required_563_i3 := by decide +kernel +theorem child_envelope_sub_563_i3 : ∀ j, childrenD_563_i3 j ⊆ envelope_563_i3 := by decide +kernel +theorem pivot_mem_563_i3 : (4, 4) ∈ envelope_563_i3 := by decide +kernel +theorem children_work_563_i3 : ∀ j, Template HasSnaky 5 (childrenC_563_i3 j) (childrenD_563_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (1, 5)).mono (by decide +kernel) + · exact row_works_563_i4.mono (by decide +kernel) +theorem row_works_563_i3 : Template HasSnaky 6 required_563_i3 envelope_563_i3 := by + refine compose HasSnaky 5 childrenC_563_i3 childrenD_563_i3 children_work_563_i3 (4, 4) + required_563_i3 envelope_563_i3 pivot_mem_563_i3 child_required_sub_563_i3 child_envelope_sub_563_i3 ?_ + intro b hb + exact common_sub_563_i3 (mem_commonEnvelope childrenD_563_i3 b hb) +def required_563_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_563_i0 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5), (5, 6), (6, 4), (6, 5), (6, 6), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_563_i0 : Fin 3 → Finset Cell := ![(placed21 1 (1, 4) required_18), required_563_i1, required_563_i3] +def childrenD_563_i0 : Fin 3 → Finset Cell := ![(placed21 1 (1, 4) envelope_18), envelope_563_i1, envelope_563_i3] +theorem common_sub_563_i0 : commonEnvelope childrenD_563_i0 ⊆ insert (4, 5) required_563_i0 := by decide +kernel +theorem child_required_sub_563_i0 : ∀ j, childrenC_563_i0 j ⊆ insert (4, 5) required_563_i0 := by decide +kernel +theorem child_envelope_sub_563_i0 : ∀ j, childrenD_563_i0 j ⊆ envelope_563_i0 := by decide +kernel +theorem pivot_mem_563_i0 : (4, 5) ∈ envelope_563_i0 := by decide +kernel +theorem children_work_563_i0 : ∀ j, Template HasSnaky 8 (childrenC_563_i0 j) (childrenD_563_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 1 (1, 4)).mono (by decide +kernel) + · exact row_works_563_i1.mono (by decide +kernel) + · exact row_works_563_i3.mono (by decide +kernel) +theorem row_works_563_i0 : Template HasSnaky 9 required_563_i0 envelope_563_i0 := by + refine compose HasSnaky 8 childrenC_563_i0 childrenD_563_i0 children_work_563_i0 (4, 5) + required_563_i0 envelope_563_i0 pivot_mem_563_i0 child_required_sub_563_i0 child_envelope_sub_563_i0 ?_ + intro b hb + exact common_sub_563_i0 (mem_commonEnvelope childrenD_563_i0 b hb) +def required_563 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_563 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_563 : Fin 8 → Finset Cell := ![(placed21 4 (0, 7) required_134), (placed21 4 (0, 7) required_180), (placed21 4 (1, 8) required_258), (placed21 4 (0, 8) required_435), (placed21 0 (0, 2) required_507), required_563_i0, required_561, (placed21 0 (0, 1) required_562)] +def childrenD_563 : Fin 8 → Finset Cell := ![(placed21 4 (0, 7) envelope_134), (placed21 4 (0, 7) envelope_180), (placed21 4 (1, 8) envelope_258), (placed21 4 (0, 8) envelope_435), (placed21 0 (0, 2) envelope_507), envelope_563_i0, envelope_561, (placed21 0 (0, 1) envelope_562)] +theorem common_sub_563 : commonEnvelope childrenD_563 ⊆ insert (3, 5) required_563 := by decide +kernel +theorem child_required_sub_563 : ∀ j, childrenC_563 j ⊆ insert (3, 5) required_563 := by decide +kernel +theorem child_envelope_sub_563 : ∀ j, childrenD_563 j ⊆ envelope_563 := by decide +kernel +theorem pivot_mem_563 : (3, 5) ∈ envelope_563 := by decide +kernel +theorem children_work_563 : ∀ j, Template HasSnaky 9 (childrenC_563 j) (childrenD_563 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_134 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_180 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_258 4 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_435 4 (0, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_507 0 (0, 2)).mono (by decide +kernel) + · exact row_works_563_i0.mono (by decide +kernel) + · exact row_works_561.mono (by decide +kernel) + · exact (placed21_template row_works_562 0 (0, 1)).mono (by decide +kernel) +theorem row_works_563 : Template HasSnaky 10 required_563 envelope_563 := by + refine compose HasSnaky 9 childrenC_563 childrenD_563 children_work_563 (3, 5) + required_563 envelope_563 pivot_mem_563 child_required_sub_563 child_envelope_sub_563 ?_ + intro b hb + exact common_sub_563 (mem_commonEnvelope childrenD_563 b hb) +def height_546_i4 : ℕ := 5 +def childrenH_546_i4 : Fin 3 → ℕ := ![height_25, height_27, height_37] +theorem height_exact_546_i4 : height_546_i4 = 1 + Finset.univ.sup childrenH_546_i4 := by decide +kernel +theorem required_origin_546_i4 : ∀ x ∈ required_546_i4, + (∃ j, x ∈ childrenC_546_i4 j) ∨ ∀ j, x ∈ childrenD_546_i4 j := by decide +kernel +theorem required_exact_546_i4 : required_546_i4 = + ((Finset.univ.biUnion childrenC_546_i4) ∪ commonEnvelope childrenD_546_i4).erase (3, 6) := by + exact required_eq_combination childrenC_546_i4 childrenD_546_i4 (3, 6) required_546_i4 + (by decide +kernel) child_required_sub_546_i4 common_sub_546_i4 required_origin_546_i4 +theorem envelope_origin_546_i4 : ∀ x ∈ envelope_546_i4, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_546_i4 j := by decide +kernel +theorem envelope_exact_546_i4 : envelope_546_i4 = + insert (3, 6) (Finset.univ.biUnion childrenD_546_i4) := by + exact envelope_eq_combination childrenD_546_i4 (3, 6) envelope_546_i4 + pivot_mem_546_i4 child_envelope_sub_546_i4 envelope_origin_546_i4 +def checked_546_i4 : CheckedCard where + required := required_546_i4 + envelope := envelope_546_i4 + height := height_546_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_546_i4 +def height_546_i3 : ℕ := 6 +def childrenH_546_i3 : Fin 2 → ℕ := ![height_5, height_546_i4] +theorem height_exact_546_i3 : height_546_i3 = 1 + Finset.univ.sup childrenH_546_i3 := by decide +kernel +theorem required_origin_546_i3 : ∀ x ∈ required_546_i3, + (∃ j, x ∈ childrenC_546_i3 j) ∨ ∀ j, x ∈ childrenD_546_i3 j := by decide +kernel +theorem required_exact_546_i3 : required_546_i3 = + ((Finset.univ.biUnion childrenC_546_i3) ∪ commonEnvelope childrenD_546_i3).erase (0, 6) := by + exact required_eq_combination childrenC_546_i3 childrenD_546_i3 (0, 6) required_546_i3 + (by decide +kernel) child_required_sub_546_i3 common_sub_546_i3 required_origin_546_i3 +theorem envelope_origin_546_i3 : ∀ x ∈ envelope_546_i3, + x = (0, 6) ∨ ∃ j, x ∈ childrenD_546_i3 j := by decide +kernel +theorem envelope_exact_546_i3 : envelope_546_i3 = + insert (0, 6) (Finset.univ.biUnion childrenD_546_i3) := by + exact envelope_eq_combination childrenD_546_i3 (0, 6) envelope_546_i3 + pivot_mem_546_i3 child_envelope_sub_546_i3 envelope_origin_546_i3 +def checked_546_i3 : CheckedCard where + required := required_546_i3 + envelope := envelope_546_i3 + height := height_546_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_546_i3 +def height_546_i2 : ℕ := 7 +def childrenH_546_i2 : Fin 2 → ℕ := ![height_5, height_546_i3] +theorem height_exact_546_i2 : height_546_i2 = 1 + Finset.univ.sup childrenH_546_i2 := by decide +kernel +theorem required_origin_546_i2 : ∀ x ∈ required_546_i2, + (∃ j, x ∈ childrenC_546_i2 j) ∨ ∀ j, x ∈ childrenD_546_i2 j := by decide +kernel +theorem required_exact_546_i2 : required_546_i2 = + ((Finset.univ.biUnion childrenC_546_i2) ∪ commonEnvelope childrenD_546_i2).erase (2, 6) := by + exact required_eq_combination childrenC_546_i2 childrenD_546_i2 (2, 6) required_546_i2 + (by decide +kernel) child_required_sub_546_i2 common_sub_546_i2 required_origin_546_i2 +theorem envelope_origin_546_i2 : ∀ x ∈ envelope_546_i2, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_546_i2 j := by decide +kernel +theorem envelope_exact_546_i2 : envelope_546_i2 = + insert (2, 6) (Finset.univ.biUnion childrenD_546_i2) := by + exact envelope_eq_combination childrenD_546_i2 (2, 6) envelope_546_i2 + pivot_mem_546_i2 child_envelope_sub_546_i2 envelope_origin_546_i2 +def checked_546_i2 : CheckedCard where + required := required_546_i2 + envelope := envelope_546_i2 + height := height_546_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_546_i2 +def height_546_i1 : ℕ := 8 +def childrenH_546_i1 : Fin 2 → ℕ := ![height_5, height_546_i2] +theorem height_exact_546_i1 : height_546_i1 = 1 + Finset.univ.sup childrenH_546_i1 := by decide +kernel +theorem required_origin_546_i1 : ∀ x ∈ required_546_i1, + (∃ j, x ∈ childrenC_546_i1 j) ∨ ∀ j, x ∈ childrenD_546_i1 j := by decide +kernel +theorem required_exact_546_i1 : required_546_i1 = + ((Finset.univ.biUnion childrenC_546_i1) ∪ commonEnvelope childrenD_546_i1).erase (2, 3) := by + exact required_eq_combination childrenC_546_i1 childrenD_546_i1 (2, 3) required_546_i1 + (by decide +kernel) child_required_sub_546_i1 common_sub_546_i1 required_origin_546_i1 +theorem envelope_origin_546_i1 : ∀ x ∈ envelope_546_i1, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_546_i1 j := by decide +kernel +theorem envelope_exact_546_i1 : envelope_546_i1 = + insert (2, 3) (Finset.univ.biUnion childrenD_546_i1) := by + exact envelope_eq_combination childrenD_546_i1 (2, 3) envelope_546_i1 + pivot_mem_546_i1 child_envelope_sub_546_i1 envelope_origin_546_i1 +def checked_546_i1 : CheckedCard where + required := required_546_i1 + envelope := envelope_546_i1 + height := height_546_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_546_i1 +def height_546_i0 : ℕ := 9 +def childrenH_546_i0 : Fin 4 → ℕ := ![height_19, height_19, height_62, height_546_i1] +theorem height_exact_546_i0 : height_546_i0 = 1 + Finset.univ.sup childrenH_546_i0 := by decide +kernel +theorem required_origin_546_i0 : ∀ x ∈ required_546_i0, + (∃ j, x ∈ childrenC_546_i0 j) ∨ ∀ j, x ∈ childrenD_546_i0 j := by decide +kernel +theorem required_exact_546_i0 : required_546_i0 = + ((Finset.univ.biUnion childrenC_546_i0) ∪ commonEnvelope childrenD_546_i0).erase (1, 3) := by + exact required_eq_combination childrenC_546_i0 childrenD_546_i0 (1, 3) required_546_i0 + (by decide +kernel) child_required_sub_546_i0 common_sub_546_i0 required_origin_546_i0 +theorem envelope_origin_546_i0 : ∀ x ∈ envelope_546_i0, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_546_i0 j := by decide +kernel +theorem envelope_exact_546_i0 : envelope_546_i0 = + insert (1, 3) (Finset.univ.biUnion childrenD_546_i0) := by + exact envelope_eq_combination childrenD_546_i0 (1, 3) envelope_546_i0 + pivot_mem_546_i0 child_envelope_sub_546_i0 envelope_origin_546_i0 +def checked_546_i0 : CheckedCard where + required := required_546_i0 + envelope := envelope_546_i0 + height := height_546_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_546_i0 +def height_546 : ℕ := 10 +def childrenH_546 : Fin 4 → ℕ := ![height_10, height_44, height_63, height_546_i0] +theorem height_exact_546 : height_546 = 1 + Finset.univ.sup childrenH_546 := by decide +kernel +theorem required_origin_546 : ∀ x ∈ required_546, + (∃ j, x ∈ childrenC_546 j) ∨ ∀ j, x ∈ childrenD_546 j := by decide +kernel +theorem required_exact_546 : required_546 = + ((Finset.univ.biUnion childrenC_546) ∪ commonEnvelope childrenD_546).erase (1, 6) := by + exact required_eq_combination childrenC_546 childrenD_546 (1, 6) required_546 + (by decide +kernel) child_required_sub_546 common_sub_546 required_origin_546 +theorem envelope_origin_546 : ∀ x ∈ envelope_546, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_546 j := by decide +kernel +theorem envelope_exact_546 : envelope_546 = + insert (1, 6) (Finset.univ.biUnion childrenD_546) := by + exact envelope_eq_combination childrenD_546 (1, 6) envelope_546 + pivot_mem_546 child_envelope_sub_546 envelope_origin_546 +def checked_546 : CheckedCard where + required := required_546 + envelope := envelope_546 + height := height_546 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_546 +def height_556_i0 : ℕ := 9 +def childrenH_556_i0 : Fin 5 → ℕ := ![height_115, height_171, height_197, height_197, height_285] +theorem height_exact_556_i0 : height_556_i0 = 1 + Finset.univ.sup childrenH_556_i0 := by decide +kernel +theorem required_origin_556_i0 : ∀ x ∈ required_556_i0, + (∃ j, x ∈ childrenC_556_i0 j) ∨ ∀ j, x ∈ childrenD_556_i0 j := by decide +kernel +theorem required_exact_556_i0 : required_556_i0 = + ((Finset.univ.biUnion childrenC_556_i0) ∪ commonEnvelope childrenD_556_i0).erase (5, 4) := by + exact required_eq_combination childrenC_556_i0 childrenD_556_i0 (5, 4) required_556_i0 + (by decide +kernel) child_required_sub_556_i0 common_sub_556_i0 required_origin_556_i0 +theorem envelope_origin_556_i0 : ∀ x ∈ envelope_556_i0, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_556_i0 j := by decide +kernel +theorem envelope_exact_556_i0 : envelope_556_i0 = + insert (5, 4) (Finset.univ.biUnion childrenD_556_i0) := by + exact envelope_eq_combination childrenD_556_i0 (5, 4) envelope_556_i0 + pivot_mem_556_i0 child_envelope_sub_556_i0 envelope_origin_556_i0 +def checked_556_i0 : CheckedCard where + required := required_556_i0 + envelope := envelope_556_i0 + height := height_556_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_556_i0 +def height_556 : ℕ := 10 +def childrenH_556 : Fin 2 → ℕ := ![height_3, height_556_i0] +theorem height_exact_556 : height_556 = 1 + Finset.univ.sup childrenH_556 := by decide +kernel +theorem required_origin_556 : ∀ x ∈ required_556, + (∃ j, x ∈ childrenC_556 j) ∨ ∀ j, x ∈ childrenD_556 j := by decide +kernel +theorem required_exact_556 : required_556 = + ((Finset.univ.biUnion childrenC_556) ∪ commonEnvelope childrenD_556).erase (2, 4) := by + exact required_eq_combination childrenC_556 childrenD_556 (2, 4) required_556 + (by decide +kernel) child_required_sub_556 common_sub_556 required_origin_556 +theorem envelope_origin_556 : ∀ x ∈ envelope_556, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_556 j := by decide +kernel +theorem envelope_exact_556 : envelope_556 = + insert (2, 4) (Finset.univ.biUnion childrenD_556) := by + exact envelope_eq_combination childrenD_556 (2, 4) envelope_556 + pivot_mem_556 child_envelope_sub_556 envelope_origin_556 +def checked_556 : CheckedCard where + required := required_556 + envelope := envelope_556 + height := height_556 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_556 +def height_560_i4 : ℕ := 4 +def childrenH_560_i4 : Fin 2 → ℕ := ![height_44, height_156] +theorem height_exact_560_i4 : height_560_i4 = 1 + Finset.univ.sup childrenH_560_i4 := by decide +kernel +theorem required_origin_560_i4 : ∀ x ∈ required_560_i4, + (∃ j, x ∈ childrenC_560_i4 j) ∨ ∀ j, x ∈ childrenD_560_i4 j := by decide +kernel +theorem required_exact_560_i4 : required_560_i4 = + ((Finset.univ.biUnion childrenC_560_i4) ∪ commonEnvelope childrenD_560_i4).erase (5, 2) := by + exact required_eq_combination childrenC_560_i4 childrenD_560_i4 (5, 2) required_560_i4 + (by decide +kernel) child_required_sub_560_i4 common_sub_560_i4 required_origin_560_i4 +theorem envelope_origin_560_i4 : ∀ x ∈ envelope_560_i4, + x = (5, 2) ∨ ∃ j, x ∈ childrenD_560_i4 j := by decide +kernel +theorem envelope_exact_560_i4 : envelope_560_i4 = + insert (5, 2) (Finset.univ.biUnion childrenD_560_i4) := by + exact envelope_eq_combination childrenD_560_i4 (5, 2) envelope_560_i4 + pivot_mem_560_i4 child_envelope_sub_560_i4 envelope_origin_560_i4 +def checked_560_i4 : CheckedCard where + required := required_560_i4 + envelope := envelope_560_i4 + height := height_560_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_560_i4 +def height_560_i3 : ℕ := 5 +def childrenH_560_i3 : Fin 3 → ℕ := ![height_44, height_52, height_560_i4] +theorem height_exact_560_i3 : height_560_i3 = 1 + Finset.univ.sup childrenH_560_i3 := by decide +kernel +theorem required_origin_560_i3 : ∀ x ∈ required_560_i3, + (∃ j, x ∈ childrenC_560_i3 j) ∨ ∀ j, x ∈ childrenD_560_i3 j := by decide +kernel +theorem required_exact_560_i3 : required_560_i3 = + ((Finset.univ.biUnion childrenC_560_i3) ∪ commonEnvelope childrenD_560_i3).erase (5, 1) := by + exact required_eq_combination childrenC_560_i3 childrenD_560_i3 (5, 1) required_560_i3 + (by decide +kernel) child_required_sub_560_i3 common_sub_560_i3 required_origin_560_i3 +theorem envelope_origin_560_i3 : ∀ x ∈ envelope_560_i3, + x = (5, 1) ∨ ∃ j, x ∈ childrenD_560_i3 j := by decide +kernel +theorem envelope_exact_560_i3 : envelope_560_i3 = + insert (5, 1) (Finset.univ.biUnion childrenD_560_i3) := by + exact envelope_eq_combination childrenD_560_i3 (5, 1) envelope_560_i3 + pivot_mem_560_i3 child_envelope_sub_560_i3 envelope_origin_560_i3 +def checked_560_i3 : CheckedCard where + required := required_560_i3 + envelope := envelope_560_i3 + height := height_560_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_560_i3 +def height_560_i2 : ℕ := 6 +def childrenH_560_i2 : Fin 2 → ℕ := ![height_5, height_560_i3] +theorem height_exact_560_i2 : height_560_i2 = 1 + Finset.univ.sup childrenH_560_i2 := by decide +kernel +theorem required_origin_560_i2 : ∀ x ∈ required_560_i2, + (∃ j, x ∈ childrenC_560_i2 j) ∨ ∀ j, x ∈ childrenD_560_i2 j := by decide +kernel +theorem required_exact_560_i2 : required_560_i2 = + ((Finset.univ.biUnion childrenC_560_i2) ∪ commonEnvelope childrenD_560_i2).erase (4, 1) := by + exact required_eq_combination childrenC_560_i2 childrenD_560_i2 (4, 1) required_560_i2 + (by decide +kernel) child_required_sub_560_i2 common_sub_560_i2 required_origin_560_i2 +theorem envelope_origin_560_i2 : ∀ x ∈ envelope_560_i2, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_560_i2 j := by decide +kernel +theorem envelope_exact_560_i2 : envelope_560_i2 = + insert (4, 1) (Finset.univ.biUnion childrenD_560_i2) := by + exact envelope_eq_combination childrenD_560_i2 (4, 1) envelope_560_i2 + pivot_mem_560_i2 child_envelope_sub_560_i2 envelope_origin_560_i2 +def checked_560_i2 : CheckedCard where + required := required_560_i2 + envelope := envelope_560_i2 + height := height_560_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_560_i2 +def height_560_i1 : ℕ := 7 +def childrenH_560_i1 : Fin 2 → ℕ := ![height_153, height_560_i2] +theorem height_exact_560_i1 : height_560_i1 = 1 + Finset.univ.sup childrenH_560_i1 := by decide +kernel +theorem required_origin_560_i1 : ∀ x ∈ required_560_i1, + (∃ j, x ∈ childrenC_560_i1 j) ∨ ∀ j, x ∈ childrenD_560_i1 j := by decide +kernel +theorem required_exact_560_i1 : required_560_i1 = + ((Finset.univ.biUnion childrenC_560_i1) ∪ commonEnvelope childrenD_560_i1).erase (6, 5) := by + exact required_eq_combination childrenC_560_i1 childrenD_560_i1 (6, 5) required_560_i1 + (by decide +kernel) child_required_sub_560_i1 common_sub_560_i1 required_origin_560_i1 +theorem envelope_origin_560_i1 : ∀ x ∈ envelope_560_i1, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_560_i1 j := by decide +kernel +theorem envelope_exact_560_i1 : envelope_560_i1 = + insert (6, 5) (Finset.univ.biUnion childrenD_560_i1) := by + exact envelope_eq_combination childrenD_560_i1 (6, 5) envelope_560_i1 + pivot_mem_560_i1 child_envelope_sub_560_i1 envelope_origin_560_i1 +def checked_560_i1 : CheckedCard where + required := required_560_i1 + envelope := envelope_560_i1 + height := height_560_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_560_i1 +def height_560_i0 : ℕ := 8 +def childrenH_560_i0 : Fin 2 → ℕ := ![height_5, height_560_i1] +theorem height_exact_560_i0 : height_560_i0 = 1 + Finset.univ.sup childrenH_560_i0 := by decide +kernel +theorem required_origin_560_i0 : ∀ x ∈ required_560_i0, + (∃ j, x ∈ childrenC_560_i0 j) ∨ ∀ j, x ∈ childrenD_560_i0 j := by decide +kernel +theorem required_exact_560_i0 : required_560_i0 = + ((Finset.univ.biUnion childrenC_560_i0) ∪ commonEnvelope childrenD_560_i0).erase (3, 1) := by + exact required_eq_combination childrenC_560_i0 childrenD_560_i0 (3, 1) required_560_i0 + (by decide +kernel) child_required_sub_560_i0 common_sub_560_i0 required_origin_560_i0 +theorem envelope_origin_560_i0 : ∀ x ∈ envelope_560_i0, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_560_i0 j := by decide +kernel +theorem envelope_exact_560_i0 : envelope_560_i0 = + insert (3, 1) (Finset.univ.biUnion childrenD_560_i0) := by + exact envelope_eq_combination childrenD_560_i0 (3, 1) envelope_560_i0 + pivot_mem_560_i0 child_envelope_sub_560_i0 envelope_origin_560_i0 +def checked_560_i0 : CheckedCard where + required := required_560_i0 + envelope := envelope_560_i0 + height := height_560_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_560_i0 +def height_560_i5 : ℕ := 6 +def childrenH_560_i5 : Fin 3 → ℕ := ![height_227, height_245, height_274] +theorem height_exact_560_i5 : height_560_i5 = 1 + Finset.univ.sup childrenH_560_i5 := by decide +kernel +theorem required_origin_560_i5 : ∀ x ∈ required_560_i5, + (∃ j, x ∈ childrenC_560_i5 j) ∨ ∀ j, x ∈ childrenD_560_i5 j := by decide +kernel +theorem required_exact_560_i5 : required_560_i5 = + ((Finset.univ.biUnion childrenC_560_i5) ∪ commonEnvelope childrenD_560_i5).erase (5, 3) := by + exact required_eq_combination childrenC_560_i5 childrenD_560_i5 (5, 3) required_560_i5 + (by decide +kernel) child_required_sub_560_i5 common_sub_560_i5 required_origin_560_i5 +theorem envelope_origin_560_i5 : ∀ x ∈ envelope_560_i5, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_560_i5 j := by decide +kernel +theorem envelope_exact_560_i5 : envelope_560_i5 = + insert (5, 3) (Finset.univ.biUnion childrenD_560_i5) := by + exact envelope_eq_combination childrenD_560_i5 (5, 3) envelope_560_i5 + pivot_mem_560_i5 child_envelope_sub_560_i5 envelope_origin_560_i5 +def checked_560_i5 : CheckedCard where + required := required_560_i5 + envelope := envelope_560_i5 + height := height_560_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_560_i5 +def height_560 : ℕ := 10 +def childrenH_560 : Fin 8 → ℕ := ![height_67, height_228, height_373, height_435, height_531, height_560_i0, height_560_i5, height_559] +theorem height_exact_560 : height_560 = 1 + Finset.univ.sup childrenH_560 := by decide +kernel +theorem required_origin_560 : ∀ x ∈ required_560, + (∃ j, x ∈ childrenC_560 j) ∨ ∀ j, x ∈ childrenD_560 j := by decide +kernel +theorem required_exact_560 : required_560 = + ((Finset.univ.biUnion childrenC_560) ∪ commonEnvelope childrenD_560).erase (5, 4) := by + exact required_eq_combination childrenC_560 childrenD_560 (5, 4) required_560 + (by decide +kernel) child_required_sub_560 common_sub_560 required_origin_560 +theorem envelope_origin_560 : ∀ x ∈ envelope_560, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_560 j := by decide +kernel +theorem envelope_exact_560 : envelope_560 = + insert (5, 4) (Finset.univ.biUnion childrenD_560) := by + exact envelope_eq_combination childrenD_560 (5, 4) envelope_560 + pivot_mem_560 child_envelope_sub_560 envelope_origin_560 +def checked_560 : CheckedCard where + required := required_560 + envelope := envelope_560 + height := height_560 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_560 +def height_563_i2 : ℕ := 7 +def childrenH_563_i2 : Fin 2 → ℕ := ![height_0, height_393] +theorem height_exact_563_i2 : height_563_i2 = 1 + Finset.univ.sup childrenH_563_i2 := by decide +kernel +theorem required_origin_563_i2 : ∀ x ∈ required_563_i2, + (∃ j, x ∈ childrenC_563_i2 j) ∨ ∀ j, x ∈ childrenD_563_i2 j := by decide +kernel +theorem required_exact_563_i2 : required_563_i2 = + ((Finset.univ.biUnion childrenC_563_i2) ∪ commonEnvelope childrenD_563_i2).erase (2, 6) := by + exact required_eq_combination childrenC_563_i2 childrenD_563_i2 (2, 6) required_563_i2 + (by decide +kernel) child_required_sub_563_i2 common_sub_563_i2 required_origin_563_i2 +theorem envelope_origin_563_i2 : ∀ x ∈ envelope_563_i2, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_563_i2 j := by decide +kernel +theorem envelope_exact_563_i2 : envelope_563_i2 = + insert (2, 6) (Finset.univ.biUnion childrenD_563_i2) := by + exact envelope_eq_combination childrenD_563_i2 (2, 6) envelope_563_i2 + pivot_mem_563_i2 child_envelope_sub_563_i2 envelope_origin_563_i2 +def checked_563_i2 : CheckedCard where + required := required_563_i2 + envelope := envelope_563_i2 + height := height_563_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_563_i2 +def height_563_i1 : ℕ := 8 +def childrenH_563_i1 : Fin 2 → ℕ := ![height_0, height_563_i2] +theorem height_exact_563_i1 : height_563_i1 = 1 + Finset.univ.sup childrenH_563_i1 := by decide +kernel +theorem required_origin_563_i1 : ∀ x ∈ required_563_i1, + (∃ j, x ∈ childrenC_563_i1 j) ∨ ∀ j, x ∈ childrenD_563_i1 j := by decide +kernel +theorem required_exact_563_i1 : required_563_i1 = + ((Finset.univ.biUnion childrenC_563_i1) ∪ commonEnvelope childrenD_563_i1).erase (2, 4) := by + exact required_eq_combination childrenC_563_i1 childrenD_563_i1 (2, 4) required_563_i1 + (by decide +kernel) child_required_sub_563_i1 common_sub_563_i1 required_origin_563_i1 +theorem envelope_origin_563_i1 : ∀ x ∈ envelope_563_i1, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_563_i1 j := by decide +kernel +theorem envelope_exact_563_i1 : envelope_563_i1 = + insert (2, 4) (Finset.univ.biUnion childrenD_563_i1) := by + exact envelope_eq_combination childrenD_563_i1 (2, 4) envelope_563_i1 + pivot_mem_563_i1 child_envelope_sub_563_i1 envelope_origin_563_i1 +def checked_563_i1 : CheckedCard where + required := required_563_i1 + envelope := envelope_563_i1 + height := height_563_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_563_i1 +def height_563_i6 : ℕ := 3 +def childrenH_563_i6 : Fin 2 → ℕ := ![height_11, height_38] +theorem height_exact_563_i6 : height_563_i6 = 1 + Finset.univ.sup childrenH_563_i6 := by decide +kernel +theorem required_origin_563_i6 : ∀ x ∈ required_563_i6, + (∃ j, x ∈ childrenC_563_i6 j) ∨ ∀ j, x ∈ childrenD_563_i6 j := by decide +kernel +theorem required_exact_563_i6 : required_563_i6 = + ((Finset.univ.biUnion childrenC_563_i6) ∪ commonEnvelope childrenD_563_i6).erase (3, 3) := by + exact required_eq_combination childrenC_563_i6 childrenD_563_i6 (3, 3) required_563_i6 + (by decide +kernel) child_required_sub_563_i6 common_sub_563_i6 required_origin_563_i6 +theorem envelope_origin_563_i6 : ∀ x ∈ envelope_563_i6, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_563_i6 j := by decide +kernel +theorem envelope_exact_563_i6 : envelope_563_i6 = + insert (3, 3) (Finset.univ.biUnion childrenD_563_i6) := by + exact envelope_eq_combination childrenD_563_i6 (3, 3) envelope_563_i6 + pivot_mem_563_i6 child_envelope_sub_563_i6 envelope_origin_563_i6 +def checked_563_i6 : CheckedCard where + required := required_563_i6 + envelope := envelope_563_i6 + height := height_563_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_563_i6 +def height_563_i5 : ℕ := 4 +def childrenH_563_i5 : Fin 2 → ℕ := ![height_15, height_563_i6] +theorem height_exact_563_i5 : height_563_i5 = 1 + Finset.univ.sup childrenH_563_i5 := by decide +kernel +theorem required_origin_563_i5 : ∀ x ∈ required_563_i5, + (∃ j, x ∈ childrenC_563_i5 j) ∨ ∀ j, x ∈ childrenD_563_i5 j := by decide +kernel +theorem required_exact_563_i5 : required_563_i5 = + ((Finset.univ.biUnion childrenC_563_i5) ∪ commonEnvelope childrenD_563_i5).erase (3, 6) := by + exact required_eq_combination childrenC_563_i5 childrenD_563_i5 (3, 6) required_563_i5 + (by decide +kernel) child_required_sub_563_i5 common_sub_563_i5 required_origin_563_i5 +theorem envelope_origin_563_i5 : ∀ x ∈ envelope_563_i5, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_563_i5 j := by decide +kernel +theorem envelope_exact_563_i5 : envelope_563_i5 = + insert (3, 6) (Finset.univ.biUnion childrenD_563_i5) := by + exact envelope_eq_combination childrenD_563_i5 (3, 6) envelope_563_i5 + pivot_mem_563_i5 child_envelope_sub_563_i5 envelope_origin_563_i5 +def checked_563_i5 : CheckedCard where + required := required_563_i5 + envelope := envelope_563_i5 + height := height_563_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_563_i5 +def height_563_i4 : ℕ := 5 +def childrenH_563_i4 : Fin 2 → ℕ := ![height_0, height_563_i5] +theorem height_exact_563_i4 : height_563_i4 = 1 + Finset.univ.sup childrenH_563_i4 := by decide +kernel +theorem required_origin_563_i4 : ∀ x ∈ required_563_i4, + (∃ j, x ∈ childrenC_563_i4 j) ∨ ∀ j, x ∈ childrenD_563_i4 j := by decide +kernel +theorem required_exact_563_i4 : required_563_i4 = + ((Finset.univ.biUnion childrenC_563_i4) ∪ commonEnvelope childrenD_563_i4).erase (3, 4) := by + exact required_eq_combination childrenC_563_i4 childrenD_563_i4 (3, 4) required_563_i4 + (by decide +kernel) child_required_sub_563_i4 common_sub_563_i4 required_origin_563_i4 +theorem envelope_origin_563_i4 : ∀ x ∈ envelope_563_i4, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_563_i4 j := by decide +kernel +theorem envelope_exact_563_i4 : envelope_563_i4 = + insert (3, 4) (Finset.univ.biUnion childrenD_563_i4) := by + exact envelope_eq_combination childrenD_563_i4 (3, 4) envelope_563_i4 + pivot_mem_563_i4 child_envelope_sub_563_i4 envelope_origin_563_i4 +def checked_563_i4 : CheckedCard where + required := required_563_i4 + envelope := envelope_563_i4 + height := height_563_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_563_i4 +def height_563_i3 : ℕ := 6 +def childrenH_563_i3 : Fin 2 → ℕ := ![height_5, height_563_i4] +theorem height_exact_563_i3 : height_563_i3 = 1 + Finset.univ.sup childrenH_563_i3 := by decide +kernel +theorem required_origin_563_i3 : ∀ x ∈ required_563_i3, + (∃ j, x ∈ childrenC_563_i3 j) ∨ ∀ j, x ∈ childrenD_563_i3 j := by decide +kernel +theorem required_exact_563_i3 : required_563_i3 = + ((Finset.univ.biUnion childrenC_563_i3) ∪ commonEnvelope childrenD_563_i3).erase (4, 4) := by + exact required_eq_combination childrenC_563_i3 childrenD_563_i3 (4, 4) required_563_i3 + (by decide +kernel) child_required_sub_563_i3 common_sub_563_i3 required_origin_563_i3 +theorem envelope_origin_563_i3 : ∀ x ∈ envelope_563_i3, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_563_i3 j := by decide +kernel +theorem envelope_exact_563_i3 : envelope_563_i3 = + insert (4, 4) (Finset.univ.biUnion childrenD_563_i3) := by + exact envelope_eq_combination childrenD_563_i3 (4, 4) envelope_563_i3 + pivot_mem_563_i3 child_envelope_sub_563_i3 envelope_origin_563_i3 +def checked_563_i3 : CheckedCard where + required := required_563_i3 + envelope := envelope_563_i3 + height := height_563_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_563_i3 +def height_563_i0 : ℕ := 9 +def childrenH_563_i0 : Fin 3 → ℕ := ![height_18, height_563_i1, height_563_i3] +theorem height_exact_563_i0 : height_563_i0 = 1 + Finset.univ.sup childrenH_563_i0 := by decide +kernel +theorem required_origin_563_i0 : ∀ x ∈ required_563_i0, + (∃ j, x ∈ childrenC_563_i0 j) ∨ ∀ j, x ∈ childrenD_563_i0 j := by decide +kernel +theorem required_exact_563_i0 : required_563_i0 = + ((Finset.univ.biUnion childrenC_563_i0) ∪ commonEnvelope childrenD_563_i0).erase (4, 5) := by + exact required_eq_combination childrenC_563_i0 childrenD_563_i0 (4, 5) required_563_i0 + (by decide +kernel) child_required_sub_563_i0 common_sub_563_i0 required_origin_563_i0 +theorem envelope_origin_563_i0 : ∀ x ∈ envelope_563_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_563_i0 j := by decide +kernel +theorem envelope_exact_563_i0 : envelope_563_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_563_i0) := by + exact envelope_eq_combination childrenD_563_i0 (4, 5) envelope_563_i0 + pivot_mem_563_i0 child_envelope_sub_563_i0 envelope_origin_563_i0 +def checked_563_i0 : CheckedCard where + required := required_563_i0 + envelope := envelope_563_i0 + height := height_563_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_563_i0 +def height_563 : ℕ := 10 +def childrenH_563 : Fin 8 → ℕ := ![height_134, height_180, height_258, height_435, height_507, height_563_i0, height_561, height_562] +theorem height_exact_563 : height_563 = 1 + Finset.univ.sup childrenH_563 := by decide +kernel +theorem required_origin_563 : ∀ x ∈ required_563, + (∃ j, x ∈ childrenC_563 j) ∨ ∀ j, x ∈ childrenD_563 j := by decide +kernel +theorem required_exact_563 : required_563 = + ((Finset.univ.biUnion childrenC_563) ∪ commonEnvelope childrenD_563).erase (3, 5) := by + exact required_eq_combination childrenC_563 childrenD_563 (3, 5) required_563 + (by decide +kernel) child_required_sub_563 common_sub_563 required_origin_563 +theorem envelope_origin_563 : ∀ x ∈ envelope_563, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_563 j := by decide +kernel +theorem envelope_exact_563 : envelope_563 = + insert (3, 5) (Finset.univ.biUnion childrenD_563) := by + exact envelope_eq_combination childrenD_563 (3, 5) envelope_563 + pivot_mem_563 child_envelope_sub_563 envelope_origin_563 +def checked_563 : CheckedCard where + required := required_563 + envelope := envelope_563 + height := height_563 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_563 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part04.lean new file mode 100644 index 0000000..e7f4bea --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part04.lean @@ -0,0 +1,862 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_569_i2 : Finset Cell := ⟨(([(3, 5), (4, 5), (5, 3), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_569_i2 : Finset Cell := ⟨(([(3, 5), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 5), (6, 6), (6, 7), (6, 8), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_569_i2 : Fin 2 → Finset Cell := ![(placed21 0 (3, 5) required_5), (placed21 0 (5, 2) required_54)] +def childrenD_569_i2 : Fin 2 → Finset Cell := ![(placed21 0 (3, 5) envelope_5), (placed21 0 (5, 2) envelope_54)] +theorem common_sub_569_i2 : commonEnvelope childrenD_569_i2 ⊆ insert (6, 6) required_569_i2 := by decide +kernel +theorem child_required_sub_569_i2 : ∀ j, childrenC_569_i2 j ⊆ insert (6, 6) required_569_i2 := by decide +kernel +theorem child_envelope_sub_569_i2 : ∀ j, childrenD_569_i2 j ⊆ envelope_569_i2 := by decide +kernel +theorem pivot_mem_569_i2 : (6, 6) ∈ envelope_569_i2 := by decide +kernel +theorem children_work_569_i2 : ∀ j, Template HasSnaky 3 (childrenC_569_i2 j) (childrenD_569_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_54 0 (5, 2)).mono (by decide +kernel) +theorem row_works_569_i2 : Template HasSnaky 4 required_569_i2 envelope_569_i2 := by + refine compose HasSnaky 3 childrenC_569_i2 childrenD_569_i2 children_work_569_i2 (6, 6) + required_569_i2 envelope_569_i2 pivot_mem_569_i2 child_required_sub_569_i2 child_envelope_sub_569_i2 ?_ + intro b hb + exact common_sub_569_i2 (mem_commonEnvelope childrenD_569_i2 b hb) +def required_569_i1 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_569_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_569_i1 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) required_68), required_569_i2] +def childrenD_569_i1 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) envelope_68), envelope_569_i2] +theorem common_sub_569_i1 : commonEnvelope childrenD_569_i1 ⊆ insert (5, 3) required_569_i1 := by decide +kernel +theorem child_required_sub_569_i1 : ∀ j, childrenC_569_i1 j ⊆ insert (5, 3) required_569_i1 := by decide +kernel +theorem child_envelope_sub_569_i1 : ∀ j, childrenD_569_i1 j ⊆ envelope_569_i1 := by decide +kernel +theorem pivot_mem_569_i1 : (5, 3) ∈ envelope_569_i1 := by decide +kernel +theorem children_work_569_i1 : ∀ j, Template HasSnaky 4 (childrenC_569_i1 j) (childrenD_569_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_68 1 (0, 2)).mono (by decide +kernel) + · exact row_works_569_i2.mono (by decide +kernel) +theorem row_works_569_i1 : Template HasSnaky 5 required_569_i1 envelope_569_i1 := by + refine compose HasSnaky 4 childrenC_569_i1 childrenD_569_i1 children_work_569_i1 (5, 3) + required_569_i1 envelope_569_i1 pivot_mem_569_i1 child_required_sub_569_i1 child_envelope_sub_569_i1 ?_ + intro b hb + exact common_sub_569_i1 (mem_commonEnvelope childrenD_569_i1 b hb) +def required_569_i3 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_569_i3 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_569_i3 : Fin 2 → Finset Cell := ![(placed21 7 (6, 3) required_169), (placed21 4 (3, 6) required_202)] +def childrenD_569_i3 : Fin 2 → Finset Cell := ![(placed21 7 (6, 3) envelope_169), (placed21 4 (3, 6) envelope_202)] +theorem common_sub_569_i3 : commonEnvelope childrenD_569_i3 ⊆ insert (6, 3) required_569_i3 := by decide +kernel +theorem child_required_sub_569_i3 : ∀ j, childrenC_569_i3 j ⊆ insert (6, 3) required_569_i3 := by decide +kernel +theorem child_envelope_sub_569_i3 : ∀ j, childrenD_569_i3 j ⊆ envelope_569_i3 := by decide +kernel +theorem pivot_mem_569_i3 : (6, 3) ∈ envelope_569_i3 := by decide +kernel +theorem children_work_569_i3 : ∀ j, Template HasSnaky 5 (childrenC_569_i3 j) (childrenD_569_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_169 7 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_202 4 (3, 6)).mono (by decide +kernel) +theorem row_works_569_i3 : Template HasSnaky 6 required_569_i3 envelope_569_i3 := by + refine compose HasSnaky 5 childrenC_569_i3 childrenD_569_i3 children_work_569_i3 (6, 3) + required_569_i3 envelope_569_i3 pivot_mem_569_i3 child_required_sub_569_i3 child_envelope_sub_569_i3 ?_ + intro b hb + exact common_sub_569_i3 (mem_commonEnvelope childrenD_569_i3 b hb) +def required_569_i0 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_569_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_569_i0 : Fin 3 → Finset Cell := ![(placed21 0 (3, 4) required_8), required_569_i1, required_569_i3] +def childrenD_569_i0 : Fin 3 → Finset Cell := ![(placed21 0 (3, 4) envelope_8), envelope_569_i1, envelope_569_i3] +theorem common_sub_569_i0 : commonEnvelope childrenD_569_i0 ⊆ insert (6, 5) required_569_i0 := by decide +kernel +theorem child_required_sub_569_i0 : ∀ j, childrenC_569_i0 j ⊆ insert (6, 5) required_569_i0 := by decide +kernel +theorem child_envelope_sub_569_i0 : ∀ j, childrenD_569_i0 j ⊆ envelope_569_i0 := by decide +kernel +theorem pivot_mem_569_i0 : (6, 5) ∈ envelope_569_i0 := by decide +kernel +theorem children_work_569_i0 : ∀ j, Template HasSnaky 6 (childrenC_569_i0 j) (childrenD_569_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (3, 4)).mono (by decide +kernel) + · exact row_works_569_i1.mono (by decide +kernel) + · exact row_works_569_i3.mono (by decide +kernel) +theorem row_works_569_i0 : Template HasSnaky 7 required_569_i0 envelope_569_i0 := by + refine compose HasSnaky 6 childrenC_569_i0 childrenD_569_i0 children_work_569_i0 (6, 5) + required_569_i0 envelope_569_i0 pivot_mem_569_i0 child_required_sub_569_i0 child_envelope_sub_569_i0 ?_ + intro b hb + exact common_sub_569_i0 (mem_commonEnvelope childrenD_569_i0 b hb) +def required_569_i4 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (4, 3), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_569_i4 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 6), (6, 7), (6, 8), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_569_i4 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) required_68), (placed21 0 (3, 0) required_495)] +def childrenD_569_i4 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) envelope_68), (placed21 0 (3, 0) envelope_495)] +theorem common_sub_569_i4 : commonEnvelope childrenD_569_i4 ⊆ insert (5, 3) required_569_i4 := by decide +kernel +theorem child_required_sub_569_i4 : ∀ j, childrenC_569_i4 j ⊆ insert (5, 3) required_569_i4 := by decide +kernel +theorem child_envelope_sub_569_i4 : ∀ j, childrenD_569_i4 j ⊆ envelope_569_i4 := by decide +kernel +theorem pivot_mem_569_i4 : (5, 3) ∈ envelope_569_i4 := by decide +kernel +theorem children_work_569_i4 : ∀ j, Template HasSnaky 5 (childrenC_569_i4 j) (childrenD_569_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_68 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_495 0 (3, 0)).mono (by decide +kernel) +theorem row_works_569_i4 : Template HasSnaky 6 required_569_i4 envelope_569_i4 := by + refine compose HasSnaky 5 childrenC_569_i4 childrenD_569_i4 children_work_569_i4 (5, 3) + required_569_i4 envelope_569_i4 pivot_mem_569_i4 child_required_sub_569_i4 child_envelope_sub_569_i4 ?_ + intro b hb + exact common_sub_569_i4 (mem_commonEnvelope childrenD_569_i4 b hb) +def required_569_i6 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_569_i6 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 4), (6, 5), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_569_i6 : Fin 2 → Finset Cell := ![(placed21 0 (3, 2) required_99), (placed21 7 (6, 3) required_169)] +def childrenD_569_i6 : Fin 2 → Finset Cell := ![(placed21 0 (3, 2) envelope_99), (placed21 7 (6, 3) envelope_169)] +theorem common_sub_569_i6 : commonEnvelope childrenD_569_i6 ⊆ insert (6, 3) required_569_i6 := by decide +kernel +theorem child_required_sub_569_i6 : ∀ j, childrenC_569_i6 j ⊆ insert (6, 3) required_569_i6 := by decide +kernel +theorem child_envelope_sub_569_i6 : ∀ j, childrenD_569_i6 j ⊆ envelope_569_i6 := by decide +kernel +theorem pivot_mem_569_i6 : (6, 3) ∈ envelope_569_i6 := by decide +kernel +theorem children_work_569_i6 : ∀ j, Template HasSnaky 4 (childrenC_569_i6 j) (childrenD_569_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_99 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_169 7 (6, 3)).mono (by decide +kernel) +theorem row_works_569_i6 : Template HasSnaky 5 required_569_i6 envelope_569_i6 := by + refine compose HasSnaky 4 childrenC_569_i6 childrenD_569_i6 children_work_569_i6 (6, 3) + required_569_i6 envelope_569_i6 pivot_mem_569_i6 child_required_sub_569_i6 child_envelope_sub_569_i6 ?_ + intro b hb + exact common_sub_569_i6 (mem_commonEnvelope childrenD_569_i6 b hb) +def required_569_i7 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_569_i7 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 6), (3, 2), (3, 3), (3, 5), (3, 6), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_569_i7 : Fin 2 → Finset Cell := ![(placed21 1 (2, 5) required_11), (placed21 1 (0, 2) required_288)] +def childrenD_569_i7 : Fin 2 → Finset Cell := ![(placed21 1 (2, 5) envelope_11), (placed21 1 (0, 2) envelope_288)] +theorem common_sub_569_i7 : commonEnvelope childrenD_569_i7 ⊆ insert (4, 6) required_569_i7 := by decide +kernel +theorem child_required_sub_569_i7 : ∀ j, childrenC_569_i7 j ⊆ insert (4, 6) required_569_i7 := by decide +kernel +theorem child_envelope_sub_569_i7 : ∀ j, childrenD_569_i7 j ⊆ envelope_569_i7 := by decide +kernel +theorem pivot_mem_569_i7 : (4, 6) ∈ envelope_569_i7 := by decide +kernel +theorem children_work_569_i7 : ∀ j, Template HasSnaky 4 (childrenC_569_i7 j) (childrenD_569_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 1 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_288 1 (0, 2)).mono (by decide +kernel) +theorem row_works_569_i7 : Template HasSnaky 5 required_569_i7 envelope_569_i7 := by + refine compose HasSnaky 4 childrenC_569_i7 childrenD_569_i7 children_work_569_i7 (4, 6) + required_569_i7 envelope_569_i7 pivot_mem_569_i7 child_required_sub_569_i7 child_envelope_sub_569_i7 ?_ + intro b hb + exact common_sub_569_i7 (mem_commonEnvelope childrenD_569_i7 b hb) +def required_569_i5 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_569_i5 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 6), (3, 2), (3, 3), (3, 5), (3, 6), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 4), (6, 5), (7, 4), (7, 5), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_569_i5 : Fin 3 → Finset Cell := ![(placed21 3 (2, 6) required_9), required_569_i6, required_569_i7] +def childrenD_569_i5 : Fin 3 → Finset Cell := ![(placed21 3 (2, 6) envelope_9), envelope_569_i6, envelope_569_i7] +theorem common_sub_569_i5 : commonEnvelope childrenD_569_i5 ⊆ insert (6, 5) required_569_i5 := by decide +kernel +theorem child_required_sub_569_i5 : ∀ j, childrenC_569_i5 j ⊆ insert (6, 5) required_569_i5 := by decide +kernel +theorem child_envelope_sub_569_i5 : ∀ j, childrenD_569_i5 j ⊆ envelope_569_i5 := by decide +kernel +theorem pivot_mem_569_i5 : (6, 5) ∈ envelope_569_i5 := by decide +kernel +theorem children_work_569_i5 : ∀ j, Template HasSnaky 5 (childrenC_569_i5 j) (childrenD_569_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 3 (2, 6)).mono (by decide +kernel) + · exact row_works_569_i6.mono (by decide +kernel) + · exact row_works_569_i7.mono (by decide +kernel) +theorem row_works_569_i5 : Template HasSnaky 6 required_569_i5 envelope_569_i5 := by + refine compose HasSnaky 5 childrenC_569_i5 childrenD_569_i5 children_work_569_i5 (6, 5) + required_569_i5 envelope_569_i5 pivot_mem_569_i5 child_required_sub_569_i5 child_envelope_sub_569_i5 ?_ + intro b hb + exact common_sub_569_i5 (mem_commonEnvelope childrenD_569_i5 b hb) +def required_569 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (3, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_569 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 2), (2, 6), (3, 2), (3, 3), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_569 : Fin 6 → Finset Cell := ![(placed21 1 (0, 2) required_287), (placed21 4 (2, 9) required_322), (placed21 1 (2, 4) required_457), required_569_i0, required_569_i4, required_569_i5] +def childrenD_569 : Fin 6 → Finset Cell := ![(placed21 1 (0, 2) envelope_287), (placed21 4 (2, 9) envelope_322), (placed21 1 (2, 4) envelope_457), envelope_569_i0, envelope_569_i4, envelope_569_i5] +theorem common_sub_569 : commonEnvelope childrenD_569 ⊆ insert (5, 5) required_569 := by decide +kernel +theorem child_required_sub_569 : ∀ j, childrenC_569 j ⊆ insert (5, 5) required_569 := by decide +kernel +theorem child_envelope_sub_569 : ∀ j, childrenD_569 j ⊆ envelope_569 := by decide +kernel +theorem pivot_mem_569 : (5, 5) ∈ envelope_569 := by decide +kernel +theorem children_work_569 : ∀ j, Template HasSnaky 9 (childrenC_569 j) (childrenD_569 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_287 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_322 4 (2, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_457 1 (2, 4)).mono (by decide +kernel) + · exact row_works_569_i0.mono (by decide +kernel) + · exact row_works_569_i4.mono (by decide +kernel) + · exact row_works_569_i5.mono (by decide +kernel) +theorem row_works_569 : Template HasSnaky 10 required_569 envelope_569 := by + refine compose HasSnaky 9 childrenC_569 childrenD_569 children_work_569 (5, 5) + required_569 envelope_569 pivot_mem_569 child_required_sub_569 child_envelope_sub_569 ?_ + intro b hb + exact common_sub_569 (mem_commonEnvelope childrenD_569 b hb) +def required_575_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_575_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 4), (3, 4), (4, 4), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (7, 3), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_575_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) required_3), (placed21 0 (2, 3) required_8)] +def childrenD_575_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) envelope_3), (placed21 0 (2, 3) envelope_8)] +theorem common_sub_575_i0 : commonEnvelope childrenD_575_i0 ⊆ insert (2, 4) required_575_i0 := by decide +kernel +theorem child_required_sub_575_i0 : ∀ j, childrenC_575_i0 j ⊆ insert (2, 4) required_575_i0 := by decide +kernel +theorem child_envelope_sub_575_i0 : ∀ j, childrenD_575_i0 j ⊆ envelope_575_i0 := by decide +kernel +theorem pivot_mem_575_i0 : (2, 4) ∈ envelope_575_i0 := by decide +kernel +theorem children_work_575_i0 : ∀ j, Template HasSnaky 3 (childrenC_575_i0 j) (childrenD_575_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 6 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_8 0 (2, 3)).mono (by decide +kernel) +theorem row_works_575_i0 : Template HasSnaky 4 required_575_i0 envelope_575_i0 := by + refine compose HasSnaky 3 childrenC_575_i0 childrenD_575_i0 children_work_575_i0 (2, 4) + required_575_i0 envelope_575_i0 pivot_mem_575_i0 child_required_sub_575_i0 child_envelope_sub_575_i0 ?_ + intro b hb + exact common_sub_575_i0 (mem_commonEnvelope childrenD_575_i0 b hb) +def required_575_i2 : Finset Cell := ⟨(([(0, 3), (1, 3), (3, 4), (4, 4), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_575_i2 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 4), (3, 4), (4, 4), (5, 3), (5, 4), (6, 3), (6, 4), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_575_i2 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) required_3), (placed21 3 (2, 4) required_6)] +def childrenD_575_i2 : Fin 2 → Finset Cell := ![(placed21 6 (4, 4) envelope_3), (placed21 3 (2, 4) envelope_6)] +theorem common_sub_575_i2 : commonEnvelope childrenD_575_i2 ⊆ insert (2, 4) required_575_i2 := by decide +kernel +theorem child_required_sub_575_i2 : ∀ j, childrenC_575_i2 j ⊆ insert (2, 4) required_575_i2 := by decide +kernel +theorem child_envelope_sub_575_i2 : ∀ j, childrenD_575_i2 j ⊆ envelope_575_i2 := by decide +kernel +theorem pivot_mem_575_i2 : (2, 4) ∈ envelope_575_i2 := by decide +kernel +theorem children_work_575_i2 : ∀ j, Template HasSnaky 2 (childrenC_575_i2 j) (childrenD_575_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 6 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_6 3 (2, 4)).mono (by decide +kernel) +theorem row_works_575_i2 : Template HasSnaky 3 required_575_i2 envelope_575_i2 := by + refine compose HasSnaky 2 childrenC_575_i2 childrenD_575_i2 children_work_575_i2 (2, 4) + required_575_i2 envelope_575_i2 pivot_mem_575_i2 child_required_sub_575_i2 child_envelope_sub_575_i2 ?_ + intro b hb + exact common_sub_575_i2 (mem_commonEnvelope childrenD_575_i2 b hb) +def required_575_i1 : Finset Cell := ⟨(([(0, 3), (0, 6), (1, 3), (1, 6), (3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_575_i1 : Finset Cell := ⟨(([(0, 3), (0, 6), (1, 3), (1, 4), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 7), (4, 8), (5, 3), (5, 4), (6, 3), (6, 4), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_575_i1 : Fin 2 → Finset Cell := ![required_575_i2, (placed21 5 (7, 4) required_554)] +def childrenD_575_i1 : Fin 2 → Finset Cell := ![envelope_575_i2, (placed21 5 (7, 4) envelope_554)] +theorem common_sub_575_i1 : commonEnvelope childrenD_575_i1 ⊆ insert (6, 4) required_575_i1 := by decide +kernel +theorem child_required_sub_575_i1 : ∀ j, childrenC_575_i1 j ⊆ insert (6, 4) required_575_i1 := by decide +kernel +theorem child_envelope_sub_575_i1 : ∀ j, childrenD_575_i1 j ⊆ envelope_575_i1 := by decide +kernel +theorem pivot_mem_575_i1 : (6, 4) ∈ envelope_575_i1 := by decide +kernel +theorem children_work_575_i1 : ∀ j, Template HasSnaky 7 (childrenC_575_i1 j) (childrenD_575_i1 j) := by + intro j + fin_cases j + · exact row_works_575_i2.mono (by decide +kernel) + · exact (placed21_template row_works_554 5 (7, 4)).mono (by decide +kernel) +theorem row_works_575_i1 : Template HasSnaky 8 required_575_i1 envelope_575_i1 := by + refine compose HasSnaky 7 childrenC_575_i1 childrenD_575_i1 children_work_575_i1 (6, 4) + required_575_i1 envelope_575_i1 pivot_mem_575_i1 child_required_sub_575_i1 child_envelope_sub_575_i1 ?_ + intro b hb + exact common_sub_575_i1 (mem_commonEnvelope childrenD_575_i1 b hb) +def required_575_i3 : Finset Cell := ⟨(([(0, 3), (0, 6), (1, 3), (1, 6), (3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_575_i3 : Finset Cell := ⟨(([(0, 3), (0, 6), (1, 3), (1, 4), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 7), (4, 8), (5, 4), (5, 5), (6, 4), (6, 5), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_575_i3 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) required_280), (placed21 5 (7, 4) required_554)] +def childrenD_575_i3 : Fin 2 → Finset Cell := ![(placed21 1 (0, 3) envelope_280), (placed21 5 (7, 4) envelope_554)] +theorem common_sub_575_i3 : commonEnvelope childrenD_575_i3 ⊆ insert (6, 4) required_575_i3 := by decide +kernel +theorem child_required_sub_575_i3 : ∀ j, childrenC_575_i3 j ⊆ insert (6, 4) required_575_i3 := by decide +kernel +theorem child_envelope_sub_575_i3 : ∀ j, childrenD_575_i3 j ⊆ envelope_575_i3 := by decide +kernel +theorem pivot_mem_575_i3 : (6, 4) ∈ envelope_575_i3 := by decide +kernel +theorem children_work_575_i3 : ∀ j, Template HasSnaky 7 (childrenC_575_i3 j) (childrenD_575_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_280 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_554 5 (7, 4)).mono (by decide +kernel) +theorem row_works_575_i3 : Template HasSnaky 8 required_575_i3 envelope_575_i3 := by + refine compose HasSnaky 7 childrenC_575_i3 childrenD_575_i3 children_work_575_i3 (6, 4) + required_575_i3 envelope_575_i3 pivot_mem_575_i3 child_required_sub_575_i3 child_envelope_sub_575_i3 ?_ + intro b hb + exact common_sub_575_i3 (mem_commonEnvelope childrenD_575_i3 b hb) +def required_575 : Finset Cell := ⟨(([(0, 3), (0, 6), (1, 3), (1, 6), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_575 : Finset Cell := ⟨(([(0, 3), (0, 6), (1, 3), (1, 4), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 3), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_575 : Fin 5 → Finset Cell := ![(placed21 0 (2, 1) required_257), required_326, required_575_i0, required_575_i1, required_575_i3] +def childrenD_575 : Fin 5 → Finset Cell := ![(placed21 0 (2, 1) envelope_257), envelope_326, envelope_575_i0, envelope_575_i1, envelope_575_i3] +theorem common_sub_575 : commonEnvelope childrenD_575 ⊆ insert (5, 4) required_575 := by decide +kernel +theorem child_required_sub_575 : ∀ j, childrenC_575 j ⊆ insert (5, 4) required_575 := by decide +kernel +theorem child_envelope_sub_575 : ∀ j, childrenD_575 j ⊆ envelope_575 := by decide +kernel +theorem pivot_mem_575 : (5, 4) ∈ envelope_575 := by decide +kernel +theorem children_work_575 : ∀ j, Template HasSnaky 9 (childrenC_575 j) (childrenD_575 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_257 0 (2, 1)).mono (by decide +kernel) + · exact row_works_326.mono (by decide +kernel) + · exact row_works_575_i0.mono (by decide +kernel) + · exact row_works_575_i1.mono (by decide +kernel) + · exact row_works_575_i3.mono (by decide +kernel) +theorem row_works_575 : Template HasSnaky 10 required_575 envelope_575 := by + refine compose HasSnaky 9 childrenC_575 childrenD_575 children_work_575 (5, 4) + required_575 envelope_575 pivot_mem_575 child_required_sub_575 child_envelope_sub_575 ?_ + intro b hb + exact common_sub_575 (mem_commonEnvelope childrenD_575 b hb) +def required_578 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_578 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_578 : Fin 4 → Finset Cell := ![(placed21 0 (1, 2) required_26), (placed21 4 (1, 4) required_49), (placed21 0 (1, 0) required_117), (placed21 0 (0, 1) required_577)] +def childrenD_578 : Fin 4 → Finset Cell := ![(placed21 0 (1, 2) envelope_26), (placed21 4 (1, 4) envelope_49), (placed21 0 (1, 0) envelope_117), (placed21 0 (0, 1) envelope_577)] +theorem common_sub_578 : commonEnvelope childrenD_578 ⊆ insert (4, 3) required_578 := by decide +kernel +theorem child_required_sub_578 : ∀ j, childrenC_578 j ⊆ insert (4, 3) required_578 := by decide +kernel +theorem child_envelope_sub_578 : ∀ j, childrenD_578 j ⊆ envelope_578 := by decide +kernel +theorem pivot_mem_578 : (4, 3) ∈ envelope_578 := by decide +kernel +theorem children_work_578 : ∀ j, Template HasSnaky 9 (childrenC_578 j) (childrenD_578 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_26 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_49 4 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_117 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_577 0 (0, 1)).mono (by decide +kernel) +theorem row_works_578 : Template HasSnaky 10 required_578 envelope_578 := by + refine compose HasSnaky 9 childrenC_578 childrenD_578 children_work_578 (4, 3) + required_578 envelope_578 pivot_mem_578 child_required_sub_578 child_envelope_sub_578 ?_ + intro b hb + exact common_sub_578 (mem_commonEnvelope childrenD_578 b hb) +def required_580 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_580 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (6, 1), (6, 2), (6, 3), (7, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_580 : Fin 4 → Finset Cell := ![(placed21 0 (1, 1) required_24), (placed21 4 (1, 3) required_49), (placed21 1 (1, 1) required_194), required_577] +def childrenD_580 : Fin 4 → Finset Cell := ![(placed21 0 (1, 1) envelope_24), (placed21 4 (1, 3) envelope_49), (placed21 1 (1, 1) envelope_194), envelope_577] +theorem common_sub_580 : commonEnvelope childrenD_580 ⊆ insert (4, 2) required_580 := by decide +kernel +theorem child_required_sub_580 : ∀ j, childrenC_580 j ⊆ insert (4, 2) required_580 := by decide +kernel +theorem child_envelope_sub_580 : ∀ j, childrenD_580 j ⊆ envelope_580 := by decide +kernel +theorem pivot_mem_580 : (4, 2) ∈ envelope_580 := by decide +kernel +theorem children_work_580 : ∀ j, Template HasSnaky 9 (childrenC_580 j) (childrenD_580 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_24 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_49 4 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_194 1 (1, 1)).mono (by decide +kernel) + · exact row_works_577.mono (by decide +kernel) +theorem row_works_580 : Template HasSnaky 10 required_580 envelope_580 := by + refine compose HasSnaky 9 childrenC_580 childrenD_580 children_work_580 (4, 2) + required_580 envelope_580 pivot_mem_580 child_required_sub_580 child_envelope_sub_580 ?_ + intro b hb + exact common_sub_580 (mem_commonEnvelope childrenD_580 b hb) +def required_585_i2 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 2), (3, 2), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_585_i2 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_585_i2 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) required_11), (placed21 1 (0, 1) required_358)] +def childrenD_585_i2 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) envelope_11), (placed21 1 (0, 1) envelope_358)] +theorem common_sub_585_i2 : commonEnvelope childrenD_585_i2 ⊆ insert (1, 4) required_585_i2 := by decide +kernel +theorem child_required_sub_585_i2 : ∀ j, childrenC_585_i2 j ⊆ insert (1, 4) required_585_i2 := by decide +kernel +theorem child_envelope_sub_585_i2 : ∀ j, childrenD_585_i2 j ⊆ envelope_585_i2 := by decide +kernel +theorem pivot_mem_585_i2 : (1, 4) ∈ envelope_585_i2 := by decide +kernel +theorem children_work_585_i2 : ∀ j, Template HasSnaky 6 (childrenC_585_i2 j) (childrenD_585_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_358 1 (0, 1)).mono (by decide +kernel) +theorem row_works_585_i2 : Template HasSnaky 7 required_585_i2 envelope_585_i2 := by + refine compose HasSnaky 6 childrenC_585_i2 childrenD_585_i2 children_work_585_i2 (1, 4) + required_585_i2 envelope_585_i2 pivot_mem_585_i2 child_required_sub_585_i2 child_envelope_sub_585_i2 ?_ + intro b hb + exact common_sub_585_i2 (mem_commonEnvelope childrenD_585_i2 b hb) +def required_585_i1 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_585_i1 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_585_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 2) required_5), required_585_i2] +def childrenD_585_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 2) envelope_5), envelope_585_i2] +theorem common_sub_585_i1 : commonEnvelope childrenD_585_i1 ⊆ insert (4, 1) required_585_i1 := by decide +kernel +theorem child_required_sub_585_i1 : ∀ j, childrenC_585_i1 j ⊆ insert (4, 1) required_585_i1 := by decide +kernel +theorem child_envelope_sub_585_i1 : ∀ j, childrenD_585_i1 j ⊆ envelope_585_i1 := by decide +kernel +theorem pivot_mem_585_i1 : (4, 1) ∈ envelope_585_i1 := by decide +kernel +theorem children_work_585_i1 : ∀ j, Template HasSnaky 7 (childrenC_585_i1 j) (childrenD_585_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (1, 2)).mono (by decide +kernel) + · exact row_works_585_i2.mono (by decide +kernel) +theorem row_works_585_i1 : Template HasSnaky 8 required_585_i1 envelope_585_i1 := by + refine compose HasSnaky 7 childrenC_585_i1 childrenD_585_i1 children_work_585_i1 (4, 1) + required_585_i1 envelope_585_i1 pivot_mem_585_i1 child_required_sub_585_i1 child_envelope_sub_585_i1 ?_ + intro b hb + exact common_sub_585_i1 (mem_commonEnvelope childrenD_585_i1 b hb) +def required_585_i0 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_585_i0 : Finset Cell := ⟨(([(0, 1), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_585_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) required_5), required_585_i1] +def childrenD_585_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 2) envelope_5), envelope_585_i1] +theorem common_sub_585_i0 : commonEnvelope childrenD_585_i0 ⊆ insert (1, 1) required_585_i0 := by decide +kernel +theorem child_required_sub_585_i0 : ∀ j, childrenC_585_i0 j ⊆ insert (1, 1) required_585_i0 := by decide +kernel +theorem child_envelope_sub_585_i0 : ∀ j, childrenD_585_i0 j ⊆ envelope_585_i0 := by decide +kernel +theorem pivot_mem_585_i0 : (1, 1) ∈ envelope_585_i0 := by decide +kernel +theorem children_work_585_i0 : ∀ j, Template HasSnaky 8 (childrenC_585_i0 j) (childrenD_585_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 2)).mono (by decide +kernel) + · exact row_works_585_i1.mono (by decide +kernel) +theorem row_works_585_i0 : Template HasSnaky 9 required_585_i0 envelope_585_i0 := by + refine compose HasSnaky 8 childrenC_585_i0 childrenD_585_i0 children_work_585_i0 (1, 1) + required_585_i0 envelope_585_i0 pivot_mem_585_i0 child_required_sub_585_i0 child_envelope_sub_585_i0 ?_ + intro b hb + exact common_sub_585_i0 (mem_commonEnvelope childrenD_585_i0 b hb) +def required_585 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_585 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_585 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) required_5), required_585_i0] +def childrenD_585 : Fin 2 → Finset Cell := ![(placed21 2 (4, 2) envelope_5), envelope_585_i0] +theorem common_sub_585 : commonEnvelope childrenD_585 ⊆ insert (1, 3) required_585 := by decide +kernel +theorem child_required_sub_585 : ∀ j, childrenC_585 j ⊆ insert (1, 3) required_585 := by decide +kernel +theorem child_envelope_sub_585 : ∀ j, childrenD_585 j ⊆ envelope_585 := by decide +kernel +theorem pivot_mem_585 : (1, 3) ∈ envelope_585 := by decide +kernel +theorem children_work_585 : ∀ j, Template HasSnaky 9 (childrenC_585 j) (childrenD_585 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 2)).mono (by decide +kernel) + · exact row_works_585_i0.mono (by decide +kernel) +theorem row_works_585 : Template HasSnaky 10 required_585 envelope_585 := by + refine compose HasSnaky 9 childrenC_585 childrenD_585 children_work_585 (1, 3) + required_585 envelope_585 pivot_mem_585 child_required_sub_585 child_envelope_sub_585 ?_ + intro b hb + exact common_sub_585 (mem_commonEnvelope childrenD_585 b hb) +def height_569_i2 : ℕ := 4 +def childrenH_569_i2 : Fin 2 → ℕ := ![height_5, height_54] +theorem height_exact_569_i2 : height_569_i2 = 1 + Finset.univ.sup childrenH_569_i2 := by decide +kernel +theorem required_origin_569_i2 : ∀ x ∈ required_569_i2, + (∃ j, x ∈ childrenC_569_i2 j) ∨ ∀ j, x ∈ childrenD_569_i2 j := by decide +kernel +theorem required_exact_569_i2 : required_569_i2 = + ((Finset.univ.biUnion childrenC_569_i2) ∪ commonEnvelope childrenD_569_i2).erase (6, 6) := by + exact required_eq_combination childrenC_569_i2 childrenD_569_i2 (6, 6) required_569_i2 + (by decide +kernel) child_required_sub_569_i2 common_sub_569_i2 required_origin_569_i2 +theorem envelope_origin_569_i2 : ∀ x ∈ envelope_569_i2, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_569_i2 j := by decide +kernel +theorem envelope_exact_569_i2 : envelope_569_i2 = + insert (6, 6) (Finset.univ.biUnion childrenD_569_i2) := by + exact envelope_eq_combination childrenD_569_i2 (6, 6) envelope_569_i2 + pivot_mem_569_i2 child_envelope_sub_569_i2 envelope_origin_569_i2 +def checked_569_i2 : CheckedCard where + required := required_569_i2 + envelope := envelope_569_i2 + height := height_569_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_569_i2 +def height_569_i1 : ℕ := 5 +def childrenH_569_i1 : Fin 2 → ℕ := ![height_68, height_569_i2] +theorem height_exact_569_i1 : height_569_i1 = 1 + Finset.univ.sup childrenH_569_i1 := by decide +kernel +theorem required_origin_569_i1 : ∀ x ∈ required_569_i1, + (∃ j, x ∈ childrenC_569_i1 j) ∨ ∀ j, x ∈ childrenD_569_i1 j := by decide +kernel +theorem required_exact_569_i1 : required_569_i1 = + ((Finset.univ.biUnion childrenC_569_i1) ∪ commonEnvelope childrenD_569_i1).erase (5, 3) := by + exact required_eq_combination childrenC_569_i1 childrenD_569_i1 (5, 3) required_569_i1 + (by decide +kernel) child_required_sub_569_i1 common_sub_569_i1 required_origin_569_i1 +theorem envelope_origin_569_i1 : ∀ x ∈ envelope_569_i1, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_569_i1 j := by decide +kernel +theorem envelope_exact_569_i1 : envelope_569_i1 = + insert (5, 3) (Finset.univ.biUnion childrenD_569_i1) := by + exact envelope_eq_combination childrenD_569_i1 (5, 3) envelope_569_i1 + pivot_mem_569_i1 child_envelope_sub_569_i1 envelope_origin_569_i1 +def checked_569_i1 : CheckedCard where + required := required_569_i1 + envelope := envelope_569_i1 + height := height_569_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_569_i1 +def height_569_i3 : ℕ := 6 +def childrenH_569_i3 : Fin 2 → ℕ := ![height_169, height_202] +theorem height_exact_569_i3 : height_569_i3 = 1 + Finset.univ.sup childrenH_569_i3 := by decide +kernel +theorem required_origin_569_i3 : ∀ x ∈ required_569_i3, + (∃ j, x ∈ childrenC_569_i3 j) ∨ ∀ j, x ∈ childrenD_569_i3 j := by decide +kernel +theorem required_exact_569_i3 : required_569_i3 = + ((Finset.univ.biUnion childrenC_569_i3) ∪ commonEnvelope childrenD_569_i3).erase (6, 3) := by + exact required_eq_combination childrenC_569_i3 childrenD_569_i3 (6, 3) required_569_i3 + (by decide +kernel) child_required_sub_569_i3 common_sub_569_i3 required_origin_569_i3 +theorem envelope_origin_569_i3 : ∀ x ∈ envelope_569_i3, + x = (6, 3) ∨ ∃ j, x ∈ childrenD_569_i3 j := by decide +kernel +theorem envelope_exact_569_i3 : envelope_569_i3 = + insert (6, 3) (Finset.univ.biUnion childrenD_569_i3) := by + exact envelope_eq_combination childrenD_569_i3 (6, 3) envelope_569_i3 + pivot_mem_569_i3 child_envelope_sub_569_i3 envelope_origin_569_i3 +def checked_569_i3 : CheckedCard where + required := required_569_i3 + envelope := envelope_569_i3 + height := height_569_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_569_i3 +def height_569_i0 : ℕ := 7 +def childrenH_569_i0 : Fin 3 → ℕ := ![height_8, height_569_i1, height_569_i3] +theorem height_exact_569_i0 : height_569_i0 = 1 + Finset.univ.sup childrenH_569_i0 := by decide +kernel +theorem required_origin_569_i0 : ∀ x ∈ required_569_i0, + (∃ j, x ∈ childrenC_569_i0 j) ∨ ∀ j, x ∈ childrenD_569_i0 j := by decide +kernel +theorem required_exact_569_i0 : required_569_i0 = + ((Finset.univ.biUnion childrenC_569_i0) ∪ commonEnvelope childrenD_569_i0).erase (6, 5) := by + exact required_eq_combination childrenC_569_i0 childrenD_569_i0 (6, 5) required_569_i0 + (by decide +kernel) child_required_sub_569_i0 common_sub_569_i0 required_origin_569_i0 +theorem envelope_origin_569_i0 : ∀ x ∈ envelope_569_i0, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_569_i0 j := by decide +kernel +theorem envelope_exact_569_i0 : envelope_569_i0 = + insert (6, 5) (Finset.univ.biUnion childrenD_569_i0) := by + exact envelope_eq_combination childrenD_569_i0 (6, 5) envelope_569_i0 + pivot_mem_569_i0 child_envelope_sub_569_i0 envelope_origin_569_i0 +def checked_569_i0 : CheckedCard where + required := required_569_i0 + envelope := envelope_569_i0 + height := height_569_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_569_i0 +def height_569_i4 : ℕ := 6 +def childrenH_569_i4 : Fin 2 → ℕ := ![height_68, height_495] +theorem height_exact_569_i4 : height_569_i4 = 1 + Finset.univ.sup childrenH_569_i4 := by decide +kernel +theorem required_origin_569_i4 : ∀ x ∈ required_569_i4, + (∃ j, x ∈ childrenC_569_i4 j) ∨ ∀ j, x ∈ childrenD_569_i4 j := by decide +kernel +theorem required_exact_569_i4 : required_569_i4 = + ((Finset.univ.biUnion childrenC_569_i4) ∪ commonEnvelope childrenD_569_i4).erase (5, 3) := by + exact required_eq_combination childrenC_569_i4 childrenD_569_i4 (5, 3) required_569_i4 + (by decide +kernel) child_required_sub_569_i4 common_sub_569_i4 required_origin_569_i4 +theorem envelope_origin_569_i4 : ∀ x ∈ envelope_569_i4, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_569_i4 j := by decide +kernel +theorem envelope_exact_569_i4 : envelope_569_i4 = + insert (5, 3) (Finset.univ.biUnion childrenD_569_i4) := by + exact envelope_eq_combination childrenD_569_i4 (5, 3) envelope_569_i4 + pivot_mem_569_i4 child_envelope_sub_569_i4 envelope_origin_569_i4 +def checked_569_i4 : CheckedCard where + required := required_569_i4 + envelope := envelope_569_i4 + height := height_569_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_569_i4 +def height_569_i6 : ℕ := 5 +def childrenH_569_i6 : Fin 2 → ℕ := ![height_99, height_169] +theorem height_exact_569_i6 : height_569_i6 = 1 + Finset.univ.sup childrenH_569_i6 := by decide +kernel +theorem required_origin_569_i6 : ∀ x ∈ required_569_i6, + (∃ j, x ∈ childrenC_569_i6 j) ∨ ∀ j, x ∈ childrenD_569_i6 j := by decide +kernel +theorem required_exact_569_i6 : required_569_i6 = + ((Finset.univ.biUnion childrenC_569_i6) ∪ commonEnvelope childrenD_569_i6).erase (6, 3) := by + exact required_eq_combination childrenC_569_i6 childrenD_569_i6 (6, 3) required_569_i6 + (by decide +kernel) child_required_sub_569_i6 common_sub_569_i6 required_origin_569_i6 +theorem envelope_origin_569_i6 : ∀ x ∈ envelope_569_i6, + x = (6, 3) ∨ ∃ j, x ∈ childrenD_569_i6 j := by decide +kernel +theorem envelope_exact_569_i6 : envelope_569_i6 = + insert (6, 3) (Finset.univ.biUnion childrenD_569_i6) := by + exact envelope_eq_combination childrenD_569_i6 (6, 3) envelope_569_i6 + pivot_mem_569_i6 child_envelope_sub_569_i6 envelope_origin_569_i6 +def checked_569_i6 : CheckedCard where + required := required_569_i6 + envelope := envelope_569_i6 + height := height_569_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_569_i6 +def height_569_i7 : ℕ := 5 +def childrenH_569_i7 : Fin 2 → ℕ := ![height_11, height_288] +theorem height_exact_569_i7 : height_569_i7 = 1 + Finset.univ.sup childrenH_569_i7 := by decide +kernel +theorem required_origin_569_i7 : ∀ x ∈ required_569_i7, + (∃ j, x ∈ childrenC_569_i7 j) ∨ ∀ j, x ∈ childrenD_569_i7 j := by decide +kernel +theorem required_exact_569_i7 : required_569_i7 = + ((Finset.univ.biUnion childrenC_569_i7) ∪ commonEnvelope childrenD_569_i7).erase (4, 6) := by + exact required_eq_combination childrenC_569_i7 childrenD_569_i7 (4, 6) required_569_i7 + (by decide +kernel) child_required_sub_569_i7 common_sub_569_i7 required_origin_569_i7 +theorem envelope_origin_569_i7 : ∀ x ∈ envelope_569_i7, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_569_i7 j := by decide +kernel +theorem envelope_exact_569_i7 : envelope_569_i7 = + insert (4, 6) (Finset.univ.biUnion childrenD_569_i7) := by + exact envelope_eq_combination childrenD_569_i7 (4, 6) envelope_569_i7 + pivot_mem_569_i7 child_envelope_sub_569_i7 envelope_origin_569_i7 +def checked_569_i7 : CheckedCard where + required := required_569_i7 + envelope := envelope_569_i7 + height := height_569_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_569_i7 +def height_569_i5 : ℕ := 6 +def childrenH_569_i5 : Fin 3 → ℕ := ![height_9, height_569_i6, height_569_i7] +theorem height_exact_569_i5 : height_569_i5 = 1 + Finset.univ.sup childrenH_569_i5 := by decide +kernel +theorem required_origin_569_i5 : ∀ x ∈ required_569_i5, + (∃ j, x ∈ childrenC_569_i5 j) ∨ ∀ j, x ∈ childrenD_569_i5 j := by decide +kernel +theorem required_exact_569_i5 : required_569_i5 = + ((Finset.univ.biUnion childrenC_569_i5) ∪ commonEnvelope childrenD_569_i5).erase (6, 5) := by + exact required_eq_combination childrenC_569_i5 childrenD_569_i5 (6, 5) required_569_i5 + (by decide +kernel) child_required_sub_569_i5 common_sub_569_i5 required_origin_569_i5 +theorem envelope_origin_569_i5 : ∀ x ∈ envelope_569_i5, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_569_i5 j := by decide +kernel +theorem envelope_exact_569_i5 : envelope_569_i5 = + insert (6, 5) (Finset.univ.biUnion childrenD_569_i5) := by + exact envelope_eq_combination childrenD_569_i5 (6, 5) envelope_569_i5 + pivot_mem_569_i5 child_envelope_sub_569_i5 envelope_origin_569_i5 +def checked_569_i5 : CheckedCard where + required := required_569_i5 + envelope := envelope_569_i5 + height := height_569_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_569_i5 +def height_569 : ℕ := 10 +def childrenH_569 : Fin 6 → ℕ := ![height_287, height_322, height_457, height_569_i0, height_569_i4, height_569_i5] +theorem height_exact_569 : height_569 = 1 + Finset.univ.sup childrenH_569 := by decide +kernel +theorem required_origin_569 : ∀ x ∈ required_569, + (∃ j, x ∈ childrenC_569 j) ∨ ∀ j, x ∈ childrenD_569 j := by decide +kernel +theorem required_exact_569 : required_569 = + ((Finset.univ.biUnion childrenC_569) ∪ commonEnvelope childrenD_569).erase (5, 5) := by + exact required_eq_combination childrenC_569 childrenD_569 (5, 5) required_569 + (by decide +kernel) child_required_sub_569 common_sub_569 required_origin_569 +theorem envelope_origin_569 : ∀ x ∈ envelope_569, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_569 j := by decide +kernel +theorem envelope_exact_569 : envelope_569 = + insert (5, 5) (Finset.univ.biUnion childrenD_569) := by + exact envelope_eq_combination childrenD_569 (5, 5) envelope_569 + pivot_mem_569 child_envelope_sub_569 envelope_origin_569 +def checked_569 : CheckedCard where + required := required_569 + envelope := envelope_569 + height := height_569 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_569 +def height_575_i0 : ℕ := 4 +def childrenH_575_i0 : Fin 2 → ℕ := ![height_3, height_8] +theorem height_exact_575_i0 : height_575_i0 = 1 + Finset.univ.sup childrenH_575_i0 := by decide +kernel +theorem required_origin_575_i0 : ∀ x ∈ required_575_i0, + (∃ j, x ∈ childrenC_575_i0 j) ∨ ∀ j, x ∈ childrenD_575_i0 j := by decide +kernel +theorem required_exact_575_i0 : required_575_i0 = + ((Finset.univ.biUnion childrenC_575_i0) ∪ commonEnvelope childrenD_575_i0).erase (2, 4) := by + exact required_eq_combination childrenC_575_i0 childrenD_575_i0 (2, 4) required_575_i0 + (by decide +kernel) child_required_sub_575_i0 common_sub_575_i0 required_origin_575_i0 +theorem envelope_origin_575_i0 : ∀ x ∈ envelope_575_i0, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_575_i0 j := by decide +kernel +theorem envelope_exact_575_i0 : envelope_575_i0 = + insert (2, 4) (Finset.univ.biUnion childrenD_575_i0) := by + exact envelope_eq_combination childrenD_575_i0 (2, 4) envelope_575_i0 + pivot_mem_575_i0 child_envelope_sub_575_i0 envelope_origin_575_i0 +def checked_575_i0 : CheckedCard where + required := required_575_i0 + envelope := envelope_575_i0 + height := height_575_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_575_i0 +def height_575_i2 : ℕ := 3 +def childrenH_575_i2 : Fin 2 → ℕ := ![height_3, height_6] +theorem height_exact_575_i2 : height_575_i2 = 1 + Finset.univ.sup childrenH_575_i2 := by decide +kernel +theorem required_origin_575_i2 : ∀ x ∈ required_575_i2, + (∃ j, x ∈ childrenC_575_i2 j) ∨ ∀ j, x ∈ childrenD_575_i2 j := by decide +kernel +theorem required_exact_575_i2 : required_575_i2 = + ((Finset.univ.biUnion childrenC_575_i2) ∪ commonEnvelope childrenD_575_i2).erase (2, 4) := by + exact required_eq_combination childrenC_575_i2 childrenD_575_i2 (2, 4) required_575_i2 + (by decide +kernel) child_required_sub_575_i2 common_sub_575_i2 required_origin_575_i2 +theorem envelope_origin_575_i2 : ∀ x ∈ envelope_575_i2, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_575_i2 j := by decide +kernel +theorem envelope_exact_575_i2 : envelope_575_i2 = + insert (2, 4) (Finset.univ.biUnion childrenD_575_i2) := by + exact envelope_eq_combination childrenD_575_i2 (2, 4) envelope_575_i2 + pivot_mem_575_i2 child_envelope_sub_575_i2 envelope_origin_575_i2 +def checked_575_i2 : CheckedCard where + required := required_575_i2 + envelope := envelope_575_i2 + height := height_575_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_575_i2 +def height_575_i1 : ℕ := 8 +def childrenH_575_i1 : Fin 2 → ℕ := ![height_575_i2, height_554] +theorem height_exact_575_i1 : height_575_i1 = 1 + Finset.univ.sup childrenH_575_i1 := by decide +kernel +theorem required_origin_575_i1 : ∀ x ∈ required_575_i1, + (∃ j, x ∈ childrenC_575_i1 j) ∨ ∀ j, x ∈ childrenD_575_i1 j := by decide +kernel +theorem required_exact_575_i1 : required_575_i1 = + ((Finset.univ.biUnion childrenC_575_i1) ∪ commonEnvelope childrenD_575_i1).erase (6, 4) := by + exact required_eq_combination childrenC_575_i1 childrenD_575_i1 (6, 4) required_575_i1 + (by decide +kernel) child_required_sub_575_i1 common_sub_575_i1 required_origin_575_i1 +theorem envelope_origin_575_i1 : ∀ x ∈ envelope_575_i1, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_575_i1 j := by decide +kernel +theorem envelope_exact_575_i1 : envelope_575_i1 = + insert (6, 4) (Finset.univ.biUnion childrenD_575_i1) := by + exact envelope_eq_combination childrenD_575_i1 (6, 4) envelope_575_i1 + pivot_mem_575_i1 child_envelope_sub_575_i1 envelope_origin_575_i1 +def checked_575_i1 : CheckedCard where + required := required_575_i1 + envelope := envelope_575_i1 + height := height_575_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_575_i1 +def height_575_i3 : ℕ := 8 +def childrenH_575_i3 : Fin 2 → ℕ := ![height_280, height_554] +theorem height_exact_575_i3 : height_575_i3 = 1 + Finset.univ.sup childrenH_575_i3 := by decide +kernel +theorem required_origin_575_i3 : ∀ x ∈ required_575_i3, + (∃ j, x ∈ childrenC_575_i3 j) ∨ ∀ j, x ∈ childrenD_575_i3 j := by decide +kernel +theorem required_exact_575_i3 : required_575_i3 = + ((Finset.univ.biUnion childrenC_575_i3) ∪ commonEnvelope childrenD_575_i3).erase (6, 4) := by + exact required_eq_combination childrenC_575_i3 childrenD_575_i3 (6, 4) required_575_i3 + (by decide +kernel) child_required_sub_575_i3 common_sub_575_i3 required_origin_575_i3 +theorem envelope_origin_575_i3 : ∀ x ∈ envelope_575_i3, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_575_i3 j := by decide +kernel +theorem envelope_exact_575_i3 : envelope_575_i3 = + insert (6, 4) (Finset.univ.biUnion childrenD_575_i3) := by + exact envelope_eq_combination childrenD_575_i3 (6, 4) envelope_575_i3 + pivot_mem_575_i3 child_envelope_sub_575_i3 envelope_origin_575_i3 +def checked_575_i3 : CheckedCard where + required := required_575_i3 + envelope := envelope_575_i3 + height := height_575_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_575_i3 +def height_575 : ℕ := 10 +def childrenH_575 : Fin 5 → ℕ := ![height_257, height_326, height_575_i0, height_575_i1, height_575_i3] +theorem height_exact_575 : height_575 = 1 + Finset.univ.sup childrenH_575 := by decide +kernel +theorem required_origin_575 : ∀ x ∈ required_575, + (∃ j, x ∈ childrenC_575 j) ∨ ∀ j, x ∈ childrenD_575 j := by decide +kernel +theorem required_exact_575 : required_575 = + ((Finset.univ.biUnion childrenC_575) ∪ commonEnvelope childrenD_575).erase (5, 4) := by + exact required_eq_combination childrenC_575 childrenD_575 (5, 4) required_575 + (by decide +kernel) child_required_sub_575 common_sub_575 required_origin_575 +theorem envelope_origin_575 : ∀ x ∈ envelope_575, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_575 j := by decide +kernel +theorem envelope_exact_575 : envelope_575 = + insert (5, 4) (Finset.univ.biUnion childrenD_575) := by + exact envelope_eq_combination childrenD_575 (5, 4) envelope_575 + pivot_mem_575 child_envelope_sub_575 envelope_origin_575 +def checked_575 : CheckedCard where + required := required_575 + envelope := envelope_575 + height := height_575 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_575 +def height_578 : ℕ := 10 +def childrenH_578 : Fin 4 → ℕ := ![height_26, height_49, height_117, height_577] +theorem height_exact_578 : height_578 = 1 + Finset.univ.sup childrenH_578 := by decide +kernel +theorem required_origin_578 : ∀ x ∈ required_578, + (∃ j, x ∈ childrenC_578 j) ∨ ∀ j, x ∈ childrenD_578 j := by decide +kernel +theorem required_exact_578 : required_578 = + ((Finset.univ.biUnion childrenC_578) ∪ commonEnvelope childrenD_578).erase (4, 3) := by + exact required_eq_combination childrenC_578 childrenD_578 (4, 3) required_578 + (by decide +kernel) child_required_sub_578 common_sub_578 required_origin_578 +theorem envelope_origin_578 : ∀ x ∈ envelope_578, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_578 j := by decide +kernel +theorem envelope_exact_578 : envelope_578 = + insert (4, 3) (Finset.univ.biUnion childrenD_578) := by + exact envelope_eq_combination childrenD_578 (4, 3) envelope_578 + pivot_mem_578 child_envelope_sub_578 envelope_origin_578 +def checked_578 : CheckedCard where + required := required_578 + envelope := envelope_578 + height := height_578 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_578 +def height_580 : ℕ := 10 +def childrenH_580 : Fin 4 → ℕ := ![height_24, height_49, height_194, height_577] +theorem height_exact_580 : height_580 = 1 + Finset.univ.sup childrenH_580 := by decide +kernel +theorem required_origin_580 : ∀ x ∈ required_580, + (∃ j, x ∈ childrenC_580 j) ∨ ∀ j, x ∈ childrenD_580 j := by decide +kernel +theorem required_exact_580 : required_580 = + ((Finset.univ.biUnion childrenC_580) ∪ commonEnvelope childrenD_580).erase (4, 2) := by + exact required_eq_combination childrenC_580 childrenD_580 (4, 2) required_580 + (by decide +kernel) child_required_sub_580 common_sub_580 required_origin_580 +theorem envelope_origin_580 : ∀ x ∈ envelope_580, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_580 j := by decide +kernel +theorem envelope_exact_580 : envelope_580 = + insert (4, 2) (Finset.univ.biUnion childrenD_580) := by + exact envelope_eq_combination childrenD_580 (4, 2) envelope_580 + pivot_mem_580 child_envelope_sub_580 envelope_origin_580 +def checked_580 : CheckedCard where + required := required_580 + envelope := envelope_580 + height := height_580 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_580 +def height_585_i2 : ℕ := 7 +def childrenH_585_i2 : Fin 2 → ℕ := ![height_11, height_358] +theorem height_exact_585_i2 : height_585_i2 = 1 + Finset.univ.sup childrenH_585_i2 := by decide +kernel +theorem required_origin_585_i2 : ∀ x ∈ required_585_i2, + (∃ j, x ∈ childrenC_585_i2 j) ∨ ∀ j, x ∈ childrenD_585_i2 j := by decide +kernel +theorem required_exact_585_i2 : required_585_i2 = + ((Finset.univ.biUnion childrenC_585_i2) ∪ commonEnvelope childrenD_585_i2).erase (1, 4) := by + exact required_eq_combination childrenC_585_i2 childrenD_585_i2 (1, 4) required_585_i2 + (by decide +kernel) child_required_sub_585_i2 common_sub_585_i2 required_origin_585_i2 +theorem envelope_origin_585_i2 : ∀ x ∈ envelope_585_i2, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_585_i2 j := by decide +kernel +theorem envelope_exact_585_i2 : envelope_585_i2 = + insert (1, 4) (Finset.univ.biUnion childrenD_585_i2) := by + exact envelope_eq_combination childrenD_585_i2 (1, 4) envelope_585_i2 + pivot_mem_585_i2 child_envelope_sub_585_i2 envelope_origin_585_i2 +def checked_585_i2 : CheckedCard where + required := required_585_i2 + envelope := envelope_585_i2 + height := height_585_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_585_i2 +def height_585_i1 : ℕ := 8 +def childrenH_585_i1 : Fin 2 → ℕ := ![height_5, height_585_i2] +theorem height_exact_585_i1 : height_585_i1 = 1 + Finset.univ.sup childrenH_585_i1 := by decide +kernel +theorem required_origin_585_i1 : ∀ x ∈ required_585_i1, + (∃ j, x ∈ childrenC_585_i1 j) ∨ ∀ j, x ∈ childrenD_585_i1 j := by decide +kernel +theorem required_exact_585_i1 : required_585_i1 = + ((Finset.univ.biUnion childrenC_585_i1) ∪ commonEnvelope childrenD_585_i1).erase (4, 1) := by + exact required_eq_combination childrenC_585_i1 childrenD_585_i1 (4, 1) required_585_i1 + (by decide +kernel) child_required_sub_585_i1 common_sub_585_i1 required_origin_585_i1 +theorem envelope_origin_585_i1 : ∀ x ∈ envelope_585_i1, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_585_i1 j := by decide +kernel +theorem envelope_exact_585_i1 : envelope_585_i1 = + insert (4, 1) (Finset.univ.biUnion childrenD_585_i1) := by + exact envelope_eq_combination childrenD_585_i1 (4, 1) envelope_585_i1 + pivot_mem_585_i1 child_envelope_sub_585_i1 envelope_origin_585_i1 +def checked_585_i1 : CheckedCard where + required := required_585_i1 + envelope := envelope_585_i1 + height := height_585_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_585_i1 +def height_585_i0 : ℕ := 9 +def childrenH_585_i0 : Fin 2 → ℕ := ![height_5, height_585_i1] +theorem height_exact_585_i0 : height_585_i0 = 1 + Finset.univ.sup childrenH_585_i0 := by decide +kernel +theorem required_origin_585_i0 : ∀ x ∈ required_585_i0, + (∃ j, x ∈ childrenC_585_i0 j) ∨ ∀ j, x ∈ childrenD_585_i0 j := by decide +kernel +theorem required_exact_585_i0 : required_585_i0 = + ((Finset.univ.biUnion childrenC_585_i0) ∪ commonEnvelope childrenD_585_i0).erase (1, 1) := by + exact required_eq_combination childrenC_585_i0 childrenD_585_i0 (1, 1) required_585_i0 + (by decide +kernel) child_required_sub_585_i0 common_sub_585_i0 required_origin_585_i0 +theorem envelope_origin_585_i0 : ∀ x ∈ envelope_585_i0, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_585_i0 j := by decide +kernel +theorem envelope_exact_585_i0 : envelope_585_i0 = + insert (1, 1) (Finset.univ.biUnion childrenD_585_i0) := by + exact envelope_eq_combination childrenD_585_i0 (1, 1) envelope_585_i0 + pivot_mem_585_i0 child_envelope_sub_585_i0 envelope_origin_585_i0 +def checked_585_i0 : CheckedCard where + required := required_585_i0 + envelope := envelope_585_i0 + height := height_585_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_585_i0 +def height_585 : ℕ := 10 +def childrenH_585 : Fin 2 → ℕ := ![height_5, height_585_i0] +theorem height_exact_585 : height_585 = 1 + Finset.univ.sup childrenH_585 := by decide +kernel +theorem required_origin_585 : ∀ x ∈ required_585, + (∃ j, x ∈ childrenC_585 j) ∨ ∀ j, x ∈ childrenD_585 j := by decide +kernel +theorem required_exact_585 : required_585 = + ((Finset.univ.biUnion childrenC_585) ∪ commonEnvelope childrenD_585).erase (1, 3) := by + exact required_eq_combination childrenC_585 childrenD_585 (1, 3) required_585 + (by decide +kernel) child_required_sub_585 common_sub_585 required_origin_585 +theorem envelope_origin_585 : ∀ x ∈ envelope_585, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_585 j := by decide +kernel +theorem envelope_exact_585 : envelope_585 = + insert (1, 3) (Finset.univ.biUnion childrenD_585) := by + exact envelope_eq_combination childrenD_585 (1, 3) envelope_585 + pivot_mem_585 child_envelope_sub_585 envelope_origin_585 +def checked_585 : CheckedCard where + required := required_585 + envelope := envelope_585 + height := height_585 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_585 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part05.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part05.lean new file mode 100644 index 0000000..ba55259 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part05.lean @@ -0,0 +1,908 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_594_i0 : Finset Cell := ⟨(([(4, 3), (4, 6), (5, 3), (5, 4), (5, 6), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_594_i0 : Finset Cell := ⟨(([(4, 3), (4, 4), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_594_i0 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) required_5), (placed21 0 (4, 3) required_91)] +def childrenD_594_i0 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) envelope_5), (placed21 0 (4, 3) envelope_91)] +theorem common_sub_594_i0 : commonEnvelope childrenD_594_i0 ⊆ insert (5, 5) required_594_i0 := by decide +kernel +theorem child_required_sub_594_i0 : ∀ j, childrenC_594_i0 j ⊆ insert (5, 5) required_594_i0 := by decide +kernel +theorem child_envelope_sub_594_i0 : ∀ j, childrenD_594_i0 j ⊆ envelope_594_i0 := by decide +kernel +theorem pivot_mem_594_i0 : (5, 5) ∈ envelope_594_i0 := by decide +kernel +theorem children_work_594_i0 : ∀ j, Template HasSnaky 4 (childrenC_594_i0 j) (childrenD_594_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_91 0 (4, 3)).mono (by decide +kernel) +theorem row_works_594_i0 : Template HasSnaky 5 required_594_i0 envelope_594_i0 := by + refine compose HasSnaky 4 childrenC_594_i0 childrenD_594_i0 children_work_594_i0 (5, 5) + required_594_i0 envelope_594_i0 pivot_mem_594_i0 child_required_sub_594_i0 child_envelope_sub_594_i0 ?_ + intro b hb + exact common_sub_594_i0 (mem_commonEnvelope childrenD_594_i0 b hb) +def required_594_i7 : Finset Cell := ⟨(([(5, 1), (5, 3), (5, 4), (5, 5), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_594_i7 : Finset Cell := ⟨(([(5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_594_i7 : Fin 2 → Finset Cell := ![(placed21 1 (5, 1) required_5), (placed21 4 (5, 5) required_6)] +def childrenD_594_i7 : Fin 2 → Finset Cell := ![(placed21 1 (5, 1) envelope_5), (placed21 4 (5, 5) envelope_6)] +theorem common_sub_594_i7 : commonEnvelope childrenD_594_i7 ⊆ insert (5, 2) required_594_i7 := by decide +kernel +theorem child_required_sub_594_i7 : ∀ j, childrenC_594_i7 j ⊆ insert (5, 2) required_594_i7 := by decide +kernel +theorem child_envelope_sub_594_i7 : ∀ j, childrenD_594_i7 j ⊆ envelope_594_i7 := by decide +kernel +theorem pivot_mem_594_i7 : (5, 2) ∈ envelope_594_i7 := by decide +kernel +theorem children_work_594_i7 : ∀ j, Template HasSnaky 2 (childrenC_594_i7 j) (childrenD_594_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_6 4 (5, 5)).mono (by decide +kernel) +theorem row_works_594_i7 : Template HasSnaky 3 required_594_i7 envelope_594_i7 := by + refine compose HasSnaky 2 childrenC_594_i7 childrenD_594_i7 children_work_594_i7 (5, 2) + required_594_i7 envelope_594_i7 pivot_mem_594_i7 child_required_sub_594_i7 child_envelope_sub_594_i7 ?_ + intro b hb + exact common_sub_594_i7 (mem_commonEnvelope childrenD_594_i7 b hb) +def required_594_i6 : Finset Cell := ⟨(([(4, 6), (5, 1), (5, 3), (5, 4), (5, 6), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_594_i6 : Finset Cell := ⟨(([(4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_594_i6 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) required_5), required_594_i7] +def childrenD_594_i6 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) envelope_5), envelope_594_i7] +theorem common_sub_594_i6 : commonEnvelope childrenD_594_i6 ⊆ insert (5, 5) required_594_i6 := by decide +kernel +theorem child_required_sub_594_i6 : ∀ j, childrenC_594_i6 j ⊆ insert (5, 5) required_594_i6 := by decide +kernel +theorem child_envelope_sub_594_i6 : ∀ j, childrenD_594_i6 j ⊆ envelope_594_i6 := by decide +kernel +theorem pivot_mem_594_i6 : (5, 5) ∈ envelope_594_i6 := by decide +kernel +theorem children_work_594_i6 : ∀ j, Template HasSnaky 3 (childrenC_594_i6 j) (childrenD_594_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (5, 3)).mono (by decide +kernel) + · exact row_works_594_i7.mono (by decide +kernel) +theorem row_works_594_i6 : Template HasSnaky 4 required_594_i6 envelope_594_i6 := by + refine compose HasSnaky 3 childrenC_594_i6 childrenD_594_i6 children_work_594_i6 (5, 5) + required_594_i6 envelope_594_i6 pivot_mem_594_i6 child_required_sub_594_i6 child_envelope_sub_594_i6 ?_ + intro b hb + exact common_sub_594_i6 (mem_commonEnvelope childrenD_594_i6 b hb) +def required_594_i5 : Finset Cell := ⟨(([(1, 2), (2, 3), (2, 4), (2, 5), (4, 6), (5, 3), (5, 4), (5, 6), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_594_i5 : Finset Cell := ⟨(([(1, 1), (1, 2), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (4, 1), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_594_i5 : Fin 2 → Finset Cell := ![(placed21 3 (1, 5) required_375), required_594_i6] +def childrenD_594_i5 : Fin 2 → Finset Cell := ![(placed21 3 (1, 5) envelope_375), envelope_594_i6] +theorem common_sub_594_i5 : commonEnvelope childrenD_594_i5 ⊆ insert (5, 1) required_594_i5 := by decide +kernel +theorem child_required_sub_594_i5 : ∀ j, childrenC_594_i5 j ⊆ insert (5, 1) required_594_i5 := by decide +kernel +theorem child_envelope_sub_594_i5 : ∀ j, childrenD_594_i5 j ⊆ envelope_594_i5 := by decide +kernel +theorem pivot_mem_594_i5 : (5, 1) ∈ envelope_594_i5 := by decide +kernel +theorem children_work_594_i5 : ∀ j, Template HasSnaky 4 (childrenC_594_i5 j) (childrenD_594_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_375 3 (1, 5)).mono (by decide +kernel) + · exact row_works_594_i6.mono (by decide +kernel) +theorem row_works_594_i5 : Template HasSnaky 5 required_594_i5 envelope_594_i5 := by + refine compose HasSnaky 4 childrenC_594_i5 childrenD_594_i5 children_work_594_i5 (5, 1) + required_594_i5 envelope_594_i5 pivot_mem_594_i5 child_required_sub_594_i5 child_envelope_sub_594_i5 ?_ + intro b hb + exact common_sub_594_i5 (mem_commonEnvelope childrenD_594_i5 b hb) +def required_594_i4 : Finset Cell := ⟨(([(2, 3), (2, 4), (2, 5), (2, 6), (4, 6), (5, 3), (5, 4), (5, 6), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_594_i4 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (4, 1), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_594_i4 : Fin 2 → Finset Cell := ![(placed21 7 (2, 6) required_4), required_594_i5] +def childrenD_594_i4 : Fin 2 → Finset Cell := ![(placed21 7 (2, 6) envelope_4), envelope_594_i5] +theorem common_sub_594_i4 : commonEnvelope childrenD_594_i4 ⊆ insert (1, 2) required_594_i4 := by decide +kernel +theorem child_required_sub_594_i4 : ∀ j, childrenC_594_i4 j ⊆ insert (1, 2) required_594_i4 := by decide +kernel +theorem child_envelope_sub_594_i4 : ∀ j, childrenD_594_i4 j ⊆ envelope_594_i4 := by decide +kernel +theorem pivot_mem_594_i4 : (1, 2) ∈ envelope_594_i4 := by decide +kernel +theorem children_work_594_i4 : ∀ j, Template HasSnaky 5 (childrenC_594_i4 j) (childrenD_594_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (2, 6)).mono (by decide +kernel) + · exact row_works_594_i5.mono (by decide +kernel) +theorem row_works_594_i4 : Template HasSnaky 6 required_594_i4 envelope_594_i4 := by + refine compose HasSnaky 5 childrenC_594_i4 childrenD_594_i4 children_work_594_i4 (1, 2) + required_594_i4 envelope_594_i4 pivot_mem_594_i4 child_required_sub_594_i4 child_envelope_sub_594_i4 ?_ + intro b hb + exact common_sub_594_i4 (mem_commonEnvelope childrenD_594_i4 b hb) +def required_594_i3 : Finset Cell := ⟨(([(2, 3), (2, 4), (2, 6), (4, 6), (5, 3), (5, 4), (5, 6), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_594_i3 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 7), (3, 8), (4, 1), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_594_i3 : Fin 3 → Finset Cell := ![(placed21 6 (2, 7) required_7), (placed21 1 (1, 3) required_208), required_594_i4] +def childrenD_594_i3 : Fin 3 → Finset Cell := ![(placed21 6 (2, 7) envelope_7), (placed21 1 (1, 3) envelope_208), envelope_594_i4] +theorem common_sub_594_i3 : commonEnvelope childrenD_594_i3 ⊆ insert (2, 5) required_594_i3 := by decide +kernel +theorem child_required_sub_594_i3 : ∀ j, childrenC_594_i3 j ⊆ insert (2, 5) required_594_i3 := by decide +kernel +theorem child_envelope_sub_594_i3 : ∀ j, childrenD_594_i3 j ⊆ envelope_594_i3 := by decide +kernel +theorem pivot_mem_594_i3 : (2, 5) ∈ envelope_594_i3 := by decide +kernel +theorem children_work_594_i3 : ∀ j, Template HasSnaky 6 (childrenC_594_i3 j) (childrenD_594_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 6 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_208 1 (1, 3)).mono (by decide +kernel) + · exact row_works_594_i4.mono (by decide +kernel) +theorem row_works_594_i3 : Template HasSnaky 7 required_594_i3 envelope_594_i3 := by + refine compose HasSnaky 6 childrenC_594_i3 childrenD_594_i3 children_work_594_i3 (2, 5) + required_594_i3 envelope_594_i3 pivot_mem_594_i3 child_required_sub_594_i3 child_envelope_sub_594_i3 ?_ + intro b hb + exact common_sub_594_i3 (mem_commonEnvelope childrenD_594_i3 b hb) +def required_594_i2 : Finset Cell := ⟨(([(2, 4), (2, 6), (4, 3), (4, 6), (5, 3), (5, 4), (5, 6), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_594_i2 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 7), (3, 8), (4, 1), (4, 3), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_594_i2 : Fin 2 → Finset Cell := ![(placed21 0 (2, 3) required_1), required_594_i3] +def childrenD_594_i2 : Fin 2 → Finset Cell := ![(placed21 0 (2, 3) envelope_1), envelope_594_i3] +theorem common_sub_594_i2 : commonEnvelope childrenD_594_i2 ⊆ insert (2, 3) required_594_i2 := by decide +kernel +theorem child_required_sub_594_i2 : ∀ j, childrenC_594_i2 j ⊆ insert (2, 3) required_594_i2 := by decide +kernel +theorem child_envelope_sub_594_i2 : ∀ j, childrenD_594_i2 j ⊆ envelope_594_i2 := by decide +kernel +theorem pivot_mem_594_i2 : (2, 3) ∈ envelope_594_i2 := by decide +kernel +theorem children_work_594_i2 : ∀ j, Template HasSnaky 7 (childrenC_594_i2 j) (childrenD_594_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (2, 3)).mono (by decide +kernel) + · exact row_works_594_i3.mono (by decide +kernel) +theorem row_works_594_i2 : Template HasSnaky 8 required_594_i2 envelope_594_i2 := by + refine compose HasSnaky 7 childrenC_594_i2 childrenD_594_i2 children_work_594_i2 (2, 3) + required_594_i2 envelope_594_i2 pivot_mem_594_i2 child_required_sub_594_i2 child_envelope_sub_594_i2 ?_ + intro b hb + exact common_sub_594_i2 (mem_commonEnvelope childrenD_594_i2 b hb) +def required_594_i8 : Finset Cell := ⟨(([(2, 4), (2, 6), (4, 3), (5, 3), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_594_i8 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (5, 3), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_594_i8 : Fin 2 → Finset Cell := ![(placed21 0 (2, 3) required_1), (placed21 0 (1, 1) required_268)] +def childrenD_594_i8 : Fin 2 → Finset Cell := ![(placed21 0 (2, 3) envelope_1), (placed21 0 (1, 1) envelope_268)] +theorem common_sub_594_i8 : commonEnvelope childrenD_594_i8 ⊆ insert (2, 3) required_594_i8 := by decide +kernel +theorem child_required_sub_594_i8 : ∀ j, childrenC_594_i8 j ⊆ insert (2, 3) required_594_i8 := by decide +kernel +theorem child_envelope_sub_594_i8 : ∀ j, childrenD_594_i8 j ⊆ envelope_594_i8 := by decide +kernel +theorem pivot_mem_594_i8 : (2, 3) ∈ envelope_594_i8 := by decide +kernel +theorem children_work_594_i8 : ∀ j, Template HasSnaky 4 (childrenC_594_i8 j) (childrenD_594_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_268 0 (1, 1)).mono (by decide +kernel) +theorem row_works_594_i8 : Template HasSnaky 5 required_594_i8 envelope_594_i8 := by + refine compose HasSnaky 4 childrenC_594_i8 childrenD_594_i8 children_work_594_i8 (2, 3) + required_594_i8 envelope_594_i8 pivot_mem_594_i8 child_required_sub_594_i8 child_envelope_sub_594_i8 ?_ + intro b hb + exact common_sub_594_i8 (mem_commonEnvelope childrenD_594_i8 b hb) +def required_594_i1 : Finset Cell := ⟨(([(2, 4), (4, 3), (4, 6), (5, 3), (5, 4), (5, 6), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_594_i1 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 1), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 3), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5), (6, 7), (6, 8), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_594_i1 : Fin 5 → Finset Cell := ![(placed21 5 (6, 3) required_272), (placed21 7 (6, 7) required_290), required_594_i2, required_594_i8, (placed21 5 (7, 3) required_593)] +def childrenD_594_i1 : Fin 5 → Finset Cell := ![(placed21 5 (6, 3) envelope_272), (placed21 7 (6, 7) envelope_290), envelope_594_i2, envelope_594_i8, (placed21 5 (7, 3) envelope_593)] +theorem common_sub_594_i1 : commonEnvelope childrenD_594_i1 ⊆ insert (2, 6) required_594_i1 := by decide +kernel +theorem child_required_sub_594_i1 : ∀ j, childrenC_594_i1 j ⊆ insert (2, 6) required_594_i1 := by decide +kernel +theorem child_envelope_sub_594_i1 : ∀ j, childrenD_594_i1 j ⊆ envelope_594_i1 := by decide +kernel +theorem pivot_mem_594_i1 : (2, 6) ∈ envelope_594_i1 := by decide +kernel +theorem children_work_594_i1 : ∀ j, Template HasSnaky 8 (childrenC_594_i1 j) (childrenD_594_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_272 5 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_290 7 (6, 7)).mono (by decide +kernel) + · exact row_works_594_i2.mono (by decide +kernel) + · exact row_works_594_i8.mono (by decide +kernel) + · exact (placed21_template row_works_593 5 (7, 3)).mono (by decide +kernel) +theorem row_works_594_i1 : Template HasSnaky 9 required_594_i1 envelope_594_i1 := by + refine compose HasSnaky 8 childrenC_594_i1 childrenD_594_i1 children_work_594_i1 (2, 6) + required_594_i1 envelope_594_i1 pivot_mem_594_i1 child_required_sub_594_i1 child_envelope_sub_594_i1 ?_ + intro b hb + exact common_sub_594_i1 (mem_commonEnvelope childrenD_594_i1 b hb) +def required_594 : Finset Cell := ⟨(([(2, 4), (4, 3), (4, 6), (5, 3), (5, 4), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_594 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 1), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 3), (4, 4), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (7, 4), (7, 8), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_594 : Fin 3 → Finset Cell := ![(placed21 7 (8, 4) required_53), required_594_i0, required_594_i1] +def childrenD_594 : Fin 3 → Finset Cell := ![(placed21 7 (8, 4) envelope_53), envelope_594_i0, envelope_594_i1] +theorem common_sub_594 : commonEnvelope childrenD_594 ⊆ insert (6, 4) required_594 := by decide +kernel +theorem child_required_sub_594 : ∀ j, childrenC_594 j ⊆ insert (6, 4) required_594 := by decide +kernel +theorem child_envelope_sub_594 : ∀ j, childrenD_594 j ⊆ envelope_594 := by decide +kernel +theorem pivot_mem_594 : (6, 4) ∈ envelope_594 := by decide +kernel +theorem children_work_594 : ∀ j, Template HasSnaky 9 (childrenC_594 j) (childrenD_594 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 7 (8, 4)).mono (by decide +kernel) + · exact row_works_594_i0.mono (by decide +kernel) + · exact row_works_594_i1.mono (by decide +kernel) +theorem row_works_594 : Template HasSnaky 10 required_594 envelope_594 := by + refine compose HasSnaky 9 childrenC_594 childrenD_594 children_work_594 (6, 4) + required_594 envelope_594 pivot_mem_594 child_required_sub_594 child_envelope_sub_594 ?_ + intro b hb + exact common_sub_594 (mem_commonEnvelope childrenD_594 b hb) +def required_608_i1 : Finset Cell := ⟨(([(1, 2), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_608_i1 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 1), (3, 2), (3, 3), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_608_i1 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) required_18), (placed21 7 (5, 6) required_375)] +def childrenD_608_i1 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) envelope_18), (placed21 7 (5, 6) envelope_375)] +theorem common_sub_608_i1 : commonEnvelope childrenD_608_i1 ⊆ insert (5, 3) required_608_i1 := by decide +kernel +theorem child_required_sub_608_i1 : ∀ j, childrenC_608_i1 j ⊆ insert (5, 3) required_608_i1 := by decide +kernel +theorem child_envelope_sub_608_i1 : ∀ j, childrenD_608_i1 j ⊆ envelope_608_i1 := by decide +kernel +theorem pivot_mem_608_i1 : (5, 3) ∈ envelope_608_i1 := by decide +kernel +theorem children_work_608_i1 : ∀ j, Template HasSnaky 4 (childrenC_608_i1 j) (childrenD_608_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 2 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_375 7 (5, 6)).mono (by decide +kernel) +theorem row_works_608_i1 : Template HasSnaky 5 required_608_i1 envelope_608_i1 := by + refine compose HasSnaky 4 childrenC_608_i1 childrenD_608_i1 children_work_608_i1 (5, 3) + required_608_i1 envelope_608_i1 pivot_mem_608_i1 child_required_sub_608_i1 child_envelope_sub_608_i1 ?_ + intro b hb + exact common_sub_608_i1 (mem_commonEnvelope childrenD_608_i1 b hb) +def required_608_i2 : Finset Cell := ⟨(([(1, 2), (1, 4), (1, 5), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_608_i2 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6), (3, 5), (4, 4), (4, 5), (4, 6), (5, 4), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_608_i2 : Fin 2 → Finset Cell := ![(placed21 7 (5, 6) required_28), (placed21 6 (2, 6) required_42)] +def childrenD_608_i2 : Fin 2 → Finset Cell := ![(placed21 7 (5, 6) envelope_28), (placed21 6 (2, 6) envelope_42)] +theorem common_sub_608_i2 : commonEnvelope childrenD_608_i2 ⊆ insert (2, 5) required_608_i2 := by decide +kernel +theorem child_required_sub_608_i2 : ∀ j, childrenC_608_i2 j ⊆ insert (2, 5) required_608_i2 := by decide +kernel +theorem child_envelope_sub_608_i2 : ∀ j, childrenD_608_i2 j ⊆ envelope_608_i2 := by decide +kernel +theorem pivot_mem_608_i2 : (2, 5) ∈ envelope_608_i2 := by decide +kernel +theorem children_work_608_i2 : ∀ j, Template HasSnaky 4 (childrenC_608_i2 j) (childrenD_608_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_28 7 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_42 6 (2, 6)).mono (by decide +kernel) +theorem row_works_608_i2 : Template HasSnaky 5 required_608_i2 envelope_608_i2 := by + refine compose HasSnaky 4 childrenC_608_i2 childrenD_608_i2 children_work_608_i2 (2, 5) + required_608_i2 envelope_608_i2 pivot_mem_608_i2 child_required_sub_608_i2 child_envelope_sub_608_i2 ?_ + intro b hb + exact common_sub_608_i2 (mem_commonEnvelope childrenD_608_i2 b hb) +def required_608_i3 : Finset Cell := ⟨(([(1, 2), (1, 4), (1, 5), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_608_i3 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 6), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_608_i3 : Fin 2 → Finset Cell := ![(placed21 6 (2, 6) required_42), (placed21 0 (1, 3) required_58)] +def childrenD_608_i3 : Fin 2 → Finset Cell := ![(placed21 6 (2, 6) envelope_42), (placed21 0 (1, 3) envelope_58)] +theorem common_sub_608_i3 : commonEnvelope childrenD_608_i3 ⊆ insert (2, 5) required_608_i3 := by decide +kernel +theorem child_required_sub_608_i3 : ∀ j, childrenC_608_i3 j ⊆ insert (2, 5) required_608_i3 := by decide +kernel +theorem child_envelope_sub_608_i3 : ∀ j, childrenD_608_i3 j ⊆ envelope_608_i3 := by decide +kernel +theorem pivot_mem_608_i3 : (2, 5) ∈ envelope_608_i3 := by decide +kernel +theorem children_work_608_i3 : ∀ j, Template HasSnaky 4 (childrenC_608_i3 j) (childrenD_608_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_42 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_58 0 (1, 3)).mono (by decide +kernel) +theorem row_works_608_i3 : Template HasSnaky 5 required_608_i3 envelope_608_i3 := by + refine compose HasSnaky 4 childrenC_608_i3 childrenD_608_i3 children_work_608_i3 (2, 5) + required_608_i3 envelope_608_i3 pivot_mem_608_i3 child_required_sub_608_i3 child_envelope_sub_608_i3 ?_ + intro b hb + exact common_sub_608_i3 (mem_commonEnvelope childrenD_608_i3 b hb) +def required_608_i0 : Finset Cell := ⟨(([(1, 4), (1, 5), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_608_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 5), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_608_i0 : Fin 3 → Finset Cell := ![required_608_i1, required_608_i2, required_608_i3] +def childrenD_608_i0 : Fin 3 → Finset Cell := ![envelope_608_i1, envelope_608_i2, envelope_608_i3] +theorem common_sub_608_i0 : commonEnvelope childrenD_608_i0 ⊆ insert (1, 2) required_608_i0 := by decide +kernel +theorem child_required_sub_608_i0 : ∀ j, childrenC_608_i0 j ⊆ insert (1, 2) required_608_i0 := by decide +kernel +theorem child_envelope_sub_608_i0 : ∀ j, childrenD_608_i0 j ⊆ envelope_608_i0 := by decide +kernel +theorem pivot_mem_608_i0 : (1, 2) ∈ envelope_608_i0 := by decide +kernel +theorem children_work_608_i0 : ∀ j, Template HasSnaky 5 (childrenC_608_i0 j) (childrenD_608_i0 j) := by + intro j + fin_cases j + · exact row_works_608_i1.mono (by decide +kernel) + · exact row_works_608_i2.mono (by decide +kernel) + · exact row_works_608_i3.mono (by decide +kernel) +theorem row_works_608_i0 : Template HasSnaky 6 required_608_i0 envelope_608_i0 := by + refine compose HasSnaky 5 childrenC_608_i0 childrenD_608_i0 children_work_608_i0 (1, 2) + required_608_i0 envelope_608_i0 pivot_mem_608_i0 child_required_sub_608_i0 child_envelope_sub_608_i0 ?_ + intro b hb + exact common_sub_608_i0 (mem_commonEnvelope childrenD_608_i0 b hb) +def required_608 : Finset Cell := ⟨(([(1, 4), (1, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_608 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 7), (0, 8), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 7), (1, 8), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 6), (6, 7), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_608 : Fin 6 → Finset Cell := ![(placed21 4 (3, 8) required_13), (placed21 4 (3, 8) required_31), (placed21 4 (1, 7) required_355), (placed21 0 (1, 2) required_364), (placed21 0 (0, 3) required_434), required_608_i0] +def childrenD_608 : Fin 6 → Finset Cell := ![(placed21 4 (3, 8) envelope_13), (placed21 4 (3, 8) envelope_31), (placed21 4 (1, 7) envelope_355), (placed21 0 (1, 2) envelope_364), (placed21 0 (0, 3) envelope_434), envelope_608_i0] +theorem common_sub_608 : commonEnvelope childrenD_608 ⊆ insert (4, 6) required_608 := by decide +kernel +theorem child_required_sub_608 : ∀ j, childrenC_608 j ⊆ insert (4, 6) required_608 := by decide +kernel +theorem child_envelope_sub_608 : ∀ j, childrenD_608 j ⊆ envelope_608 := by decide +kernel +theorem pivot_mem_608 : (4, 6) ∈ envelope_608 := by decide +kernel +theorem children_work_608 : ∀ j, Template HasSnaky 9 (childrenC_608 j) (childrenD_608 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_31 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_355 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_364 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_434 0 (0, 3)).mono (by decide +kernel) + · exact row_works_608_i0.mono (by decide +kernel) +theorem row_works_608 : Template HasSnaky 10 required_608 envelope_608 := by + refine compose HasSnaky 9 childrenC_608 childrenD_608 children_work_608 (4, 6) + required_608 envelope_608 pivot_mem_608 child_required_sub_608 child_envelope_sub_608 ?_ + intro b hb + exact common_sub_608 (mem_commonEnvelope childrenD_608 b hb) +def required_616_i1 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_616_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_616_i1 : Fin 2 → Finset Cell := ![(placed21 0 (2, 2) required_6), (placed21 5 (3, 3) required_123)] +def childrenD_616_i1 : Fin 2 → Finset Cell := ![(placed21 0 (2, 2) envelope_6), (placed21 5 (3, 3) envelope_123)] +theorem common_sub_616_i1 : commonEnvelope childrenD_616_i1 ⊆ insert (2, 6) required_616_i1 := by decide +kernel +theorem child_required_sub_616_i1 : ∀ j, childrenC_616_i1 j ⊆ insert (2, 6) required_616_i1 := by decide +kernel +theorem child_envelope_sub_616_i1 : ∀ j, childrenD_616_i1 j ⊆ envelope_616_i1 := by decide +kernel +theorem pivot_mem_616_i1 : (2, 6) ∈ envelope_616_i1 := by decide +kernel +theorem children_work_616_i1 : ∀ j, Template HasSnaky 2 (childrenC_616_i1 j) (childrenD_616_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_123 5 (3, 3)).mono (by decide +kernel) +theorem row_works_616_i1 : Template HasSnaky 3 required_616_i1 envelope_616_i1 := by + refine compose HasSnaky 2 childrenC_616_i1 childrenD_616_i1 children_work_616_i1 (2, 6) + required_616_i1 envelope_616_i1 pivot_mem_616_i1 child_required_sub_616_i1 child_envelope_sub_616_i1 ?_ + intro b hb + exact common_sub_616_i1 (mem_commonEnvelope childrenD_616_i1 b hb) +def required_616_i0 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_616_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 5), (4, 6), (5, 2), (5, 5), (6, 2), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_616_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 1) required_11), required_616_i1, (placed21 0 (1, 1) required_521)] +def childrenD_616_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 1) envelope_11), envelope_616_i1, (placed21 0 (1, 1) envelope_521)] +theorem common_sub_616_i0 : commonEnvelope childrenD_616_i0 ⊆ insert (2, 5) required_616_i0 := by decide +kernel +theorem child_required_sub_616_i0 : ∀ j, childrenC_616_i0 j ⊆ insert (2, 5) required_616_i0 := by decide +kernel +theorem child_envelope_sub_616_i0 : ∀ j, childrenD_616_i0 j ⊆ envelope_616_i0 := by decide +kernel +theorem pivot_mem_616_i0 : (2, 5) ∈ envelope_616_i0 := by decide +kernel +theorem children_work_616_i0 : ∀ j, Template HasSnaky 6 (childrenC_616_i0 j) (childrenD_616_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 0 (2, 1)).mono (by decide +kernel) + · exact row_works_616_i1.mono (by decide +kernel) + · exact (placed21_template row_works_521 0 (1, 1)).mono (by decide +kernel) +theorem row_works_616_i0 : Template HasSnaky 7 required_616_i0 envelope_616_i0 := by + refine compose HasSnaky 6 childrenC_616_i0 childrenD_616_i0 children_work_616_i0 (2, 5) + required_616_i0 envelope_616_i0 pivot_mem_616_i0 child_required_sub_616_i0 child_envelope_sub_616_i0 ?_ + intro b hb + exact common_sub_616_i0 (mem_commonEnvelope childrenD_616_i0 b hb) +def required_616 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_616 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_616 : Fin 7 → Finset Cell := ![(placed21 0 (0, 1) required_345), (placed21 1 (0, 2) required_421), (placed21 0 (0, 1) required_522), (placed21 0 (1, 0) required_530), (placed21 4 (0, 6) required_533), required_534, required_616_i0] +def childrenD_616 : Fin 7 → Finset Cell := ![(placed21 0 (0, 1) envelope_345), (placed21 1 (0, 2) envelope_421), (placed21 0 (0, 1) envelope_522), (placed21 0 (1, 0) envelope_530), (placed21 4 (0, 6) envelope_533), envelope_534, envelope_616_i0] +theorem common_sub_616 : commonEnvelope childrenD_616 ⊆ insert (3, 3) required_616 := by decide +kernel +theorem child_required_sub_616 : ∀ j, childrenC_616 j ⊆ insert (3, 3) required_616 := by decide +kernel +theorem child_envelope_sub_616 : ∀ j, childrenD_616 j ⊆ envelope_616 := by decide +kernel +theorem pivot_mem_616 : (3, 3) ∈ envelope_616 := by decide +kernel +theorem children_work_616 : ∀ j, Template HasSnaky 9 (childrenC_616 j) (childrenD_616 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_345 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_421 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_522 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_530 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_533 4 (0, 6)).mono (by decide +kernel) + · exact row_works_534.mono (by decide +kernel) + · exact row_works_616_i0.mono (by decide +kernel) +theorem row_works_616 : Template HasSnaky 10 required_616 envelope_616 := by + refine compose HasSnaky 9 childrenC_616 childrenD_616 children_work_616 (3, 3) + required_616 envelope_616 pivot_mem_616 child_required_sub_616 child_envelope_sub_616 ?_ + intro b hb + exact common_sub_616 (mem_commonEnvelope childrenD_616 b hb) +def required_631_i1 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_631_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (5, 4), (5, 5), (5, 6), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_631_i1 : Fin 2 → Finset Cell := ![(placed21 7 (5, 5) required_45), (placed21 1 (2, 2) required_418)] +def childrenD_631_i1 : Fin 2 → Finset Cell := ![(placed21 7 (5, 5) envelope_45), (placed21 1 (2, 2) envelope_418)] +theorem common_sub_631_i1 : commonEnvelope childrenD_631_i1 ⊆ insert (3, 2) required_631_i1 := by decide +kernel +theorem child_required_sub_631_i1 : ∀ j, childrenC_631_i1 j ⊆ insert (3, 2) required_631_i1 := by decide +kernel +theorem child_envelope_sub_631_i1 : ∀ j, childrenD_631_i1 j ⊆ envelope_631_i1 := by decide +kernel +theorem pivot_mem_631_i1 : (3, 2) ∈ envelope_631_i1 := by decide +kernel +theorem children_work_631_i1 : ∀ j, Template HasSnaky 7 (childrenC_631_i1 j) (childrenD_631_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_45 7 (5, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_418 1 (2, 2)).mono (by decide +kernel) +theorem row_works_631_i1 : Template HasSnaky 8 required_631_i1 envelope_631_i1 := by + refine compose HasSnaky 7 childrenC_631_i1 childrenD_631_i1 children_work_631_i1 (3, 2) + required_631_i1 envelope_631_i1 pivot_mem_631_i1 child_required_sub_631_i1 child_envelope_sub_631_i1 ?_ + intro b hb + exact common_sub_631_i1 (mem_commonEnvelope childrenD_631_i1 b hb) +def required_631_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_631_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (5, 4), (5, 5), (5, 6), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_631_i0 : Fin 3 → Finset Cell := ![(placed21 4 (3, 5) required_43), (placed21 4 (3, 5) required_51), required_631_i1] +def childrenD_631_i0 : Fin 3 → Finset Cell := ![(placed21 4 (3, 5) envelope_43), (placed21 4 (3, 5) envelope_51), envelope_631_i1] +theorem common_sub_631_i0 : commonEnvelope childrenD_631_i0 ⊆ insert (4, 2) required_631_i0 := by decide +kernel +theorem child_required_sub_631_i0 : ∀ j, childrenC_631_i0 j ⊆ insert (4, 2) required_631_i0 := by decide +kernel +theorem child_envelope_sub_631_i0 : ∀ j, childrenD_631_i0 j ⊆ envelope_631_i0 := by decide +kernel +theorem pivot_mem_631_i0 : (4, 2) ∈ envelope_631_i0 := by decide +kernel +theorem children_work_631_i0 : ∀ j, Template HasSnaky 8 (childrenC_631_i0 j) (childrenD_631_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_43 4 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_51 4 (3, 5)).mono (by decide +kernel) + · exact row_works_631_i1.mono (by decide +kernel) +theorem row_works_631_i0 : Template HasSnaky 9 required_631_i0 envelope_631_i0 := by + refine compose HasSnaky 8 childrenC_631_i0 childrenD_631_i0 children_work_631_i0 (4, 2) + required_631_i0 envelope_631_i0 pivot_mem_631_i0 child_required_sub_631_i0 child_envelope_sub_631_i0 ?_ + intro b hb + exact common_sub_631_i0 (mem_commonEnvelope childrenD_631_i0 b hb) +def required_631 : Finset Cell := ⟨(([(3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_631 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_631 : Fin 4 → Finset Cell := ![(placed21 4 (3, 6) required_44), (placed21 4 (3, 6) required_52), (placed21 2 (4, 2) required_63), required_631_i0] +def childrenD_631 : Fin 4 → Finset Cell := ![(placed21 4 (3, 6) envelope_44), (placed21 4 (3, 6) envelope_52), (placed21 2 (4, 2) envelope_63), envelope_631_i0] +theorem common_sub_631 : commonEnvelope childrenD_631 ⊆ insert (3, 5) required_631 := by decide +kernel +theorem child_required_sub_631 : ∀ j, childrenC_631 j ⊆ insert (3, 5) required_631 := by decide +kernel +theorem child_envelope_sub_631 : ∀ j, childrenD_631 j ⊆ envelope_631 := by decide +kernel +theorem pivot_mem_631 : (3, 5) ∈ envelope_631 := by decide +kernel +theorem children_work_631 : ∀ j, Template HasSnaky 9 (childrenC_631 j) (childrenD_631 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_63 2 (4, 2)).mono (by decide +kernel) + · exact row_works_631_i0.mono (by decide +kernel) +theorem row_works_631 : Template HasSnaky 10 required_631 envelope_631 := by + refine compose HasSnaky 9 childrenC_631 childrenD_631 children_work_631 (3, 5) + required_631 envelope_631 pivot_mem_631 child_required_sub_631 child_envelope_sub_631 ?_ + intro b hb + exact common_sub_631 (mem_commonEnvelope childrenD_631 b hb) +def height_594_i0 : ℕ := 5 +def childrenH_594_i0 : Fin 2 → ℕ := ![height_5, height_91] +theorem height_exact_594_i0 : height_594_i0 = 1 + Finset.univ.sup childrenH_594_i0 := by decide +kernel +theorem required_origin_594_i0 : ∀ x ∈ required_594_i0, + (∃ j, x ∈ childrenC_594_i0 j) ∨ ∀ j, x ∈ childrenD_594_i0 j := by decide +kernel +theorem required_exact_594_i0 : required_594_i0 = + ((Finset.univ.biUnion childrenC_594_i0) ∪ commonEnvelope childrenD_594_i0).erase (5, 5) := by + exact required_eq_combination childrenC_594_i0 childrenD_594_i0 (5, 5) required_594_i0 + (by decide +kernel) child_required_sub_594_i0 common_sub_594_i0 required_origin_594_i0 +theorem envelope_origin_594_i0 : ∀ x ∈ envelope_594_i0, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_594_i0 j := by decide +kernel +theorem envelope_exact_594_i0 : envelope_594_i0 = + insert (5, 5) (Finset.univ.biUnion childrenD_594_i0) := by + exact envelope_eq_combination childrenD_594_i0 (5, 5) envelope_594_i0 + pivot_mem_594_i0 child_envelope_sub_594_i0 envelope_origin_594_i0 +def checked_594_i0 : CheckedCard where + required := required_594_i0 + envelope := envelope_594_i0 + height := height_594_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_594_i0 +def height_594_i7 : ℕ := 3 +def childrenH_594_i7 : Fin 2 → ℕ := ![height_5, height_6] +theorem height_exact_594_i7 : height_594_i7 = 1 + Finset.univ.sup childrenH_594_i7 := by decide +kernel +theorem required_origin_594_i7 : ∀ x ∈ required_594_i7, + (∃ j, x ∈ childrenC_594_i7 j) ∨ ∀ j, x ∈ childrenD_594_i7 j := by decide +kernel +theorem required_exact_594_i7 : required_594_i7 = + ((Finset.univ.biUnion childrenC_594_i7) ∪ commonEnvelope childrenD_594_i7).erase (5, 2) := by + exact required_eq_combination childrenC_594_i7 childrenD_594_i7 (5, 2) required_594_i7 + (by decide +kernel) child_required_sub_594_i7 common_sub_594_i7 required_origin_594_i7 +theorem envelope_origin_594_i7 : ∀ x ∈ envelope_594_i7, + x = (5, 2) ∨ ∃ j, x ∈ childrenD_594_i7 j := by decide +kernel +theorem envelope_exact_594_i7 : envelope_594_i7 = + insert (5, 2) (Finset.univ.biUnion childrenD_594_i7) := by + exact envelope_eq_combination childrenD_594_i7 (5, 2) envelope_594_i7 + pivot_mem_594_i7 child_envelope_sub_594_i7 envelope_origin_594_i7 +def checked_594_i7 : CheckedCard where + required := required_594_i7 + envelope := envelope_594_i7 + height := height_594_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_594_i7 +def height_594_i6 : ℕ := 4 +def childrenH_594_i6 : Fin 2 → ℕ := ![height_5, height_594_i7] +theorem height_exact_594_i6 : height_594_i6 = 1 + Finset.univ.sup childrenH_594_i6 := by decide +kernel +theorem required_origin_594_i6 : ∀ x ∈ required_594_i6, + (∃ j, x ∈ childrenC_594_i6 j) ∨ ∀ j, x ∈ childrenD_594_i6 j := by decide +kernel +theorem required_exact_594_i6 : required_594_i6 = + ((Finset.univ.biUnion childrenC_594_i6) ∪ commonEnvelope childrenD_594_i6).erase (5, 5) := by + exact required_eq_combination childrenC_594_i6 childrenD_594_i6 (5, 5) required_594_i6 + (by decide +kernel) child_required_sub_594_i6 common_sub_594_i6 required_origin_594_i6 +theorem envelope_origin_594_i6 : ∀ x ∈ envelope_594_i6, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_594_i6 j := by decide +kernel +theorem envelope_exact_594_i6 : envelope_594_i6 = + insert (5, 5) (Finset.univ.biUnion childrenD_594_i6) := by + exact envelope_eq_combination childrenD_594_i6 (5, 5) envelope_594_i6 + pivot_mem_594_i6 child_envelope_sub_594_i6 envelope_origin_594_i6 +def checked_594_i6 : CheckedCard where + required := required_594_i6 + envelope := envelope_594_i6 + height := height_594_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_594_i6 +def height_594_i5 : ℕ := 5 +def childrenH_594_i5 : Fin 2 → ℕ := ![height_375, height_594_i6] +theorem height_exact_594_i5 : height_594_i5 = 1 + Finset.univ.sup childrenH_594_i5 := by decide +kernel +theorem required_origin_594_i5 : ∀ x ∈ required_594_i5, + (∃ j, x ∈ childrenC_594_i5 j) ∨ ∀ j, x ∈ childrenD_594_i5 j := by decide +kernel +theorem required_exact_594_i5 : required_594_i5 = + ((Finset.univ.biUnion childrenC_594_i5) ∪ commonEnvelope childrenD_594_i5).erase (5, 1) := by + exact required_eq_combination childrenC_594_i5 childrenD_594_i5 (5, 1) required_594_i5 + (by decide +kernel) child_required_sub_594_i5 common_sub_594_i5 required_origin_594_i5 +theorem envelope_origin_594_i5 : ∀ x ∈ envelope_594_i5, + x = (5, 1) ∨ ∃ j, x ∈ childrenD_594_i5 j := by decide +kernel +theorem envelope_exact_594_i5 : envelope_594_i5 = + insert (5, 1) (Finset.univ.biUnion childrenD_594_i5) := by + exact envelope_eq_combination childrenD_594_i5 (5, 1) envelope_594_i5 + pivot_mem_594_i5 child_envelope_sub_594_i5 envelope_origin_594_i5 +def checked_594_i5 : CheckedCard where + required := required_594_i5 + envelope := envelope_594_i5 + height := height_594_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_594_i5 +def height_594_i4 : ℕ := 6 +def childrenH_594_i4 : Fin 2 → ℕ := ![height_4, height_594_i5] +theorem height_exact_594_i4 : height_594_i4 = 1 + Finset.univ.sup childrenH_594_i4 := by decide +kernel +theorem required_origin_594_i4 : ∀ x ∈ required_594_i4, + (∃ j, x ∈ childrenC_594_i4 j) ∨ ∀ j, x ∈ childrenD_594_i4 j := by decide +kernel +theorem required_exact_594_i4 : required_594_i4 = + ((Finset.univ.biUnion childrenC_594_i4) ∪ commonEnvelope childrenD_594_i4).erase (1, 2) := by + exact required_eq_combination childrenC_594_i4 childrenD_594_i4 (1, 2) required_594_i4 + (by decide +kernel) child_required_sub_594_i4 common_sub_594_i4 required_origin_594_i4 +theorem envelope_origin_594_i4 : ∀ x ∈ envelope_594_i4, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_594_i4 j := by decide +kernel +theorem envelope_exact_594_i4 : envelope_594_i4 = + insert (1, 2) (Finset.univ.biUnion childrenD_594_i4) := by + exact envelope_eq_combination childrenD_594_i4 (1, 2) envelope_594_i4 + pivot_mem_594_i4 child_envelope_sub_594_i4 envelope_origin_594_i4 +def checked_594_i4 : CheckedCard where + required := required_594_i4 + envelope := envelope_594_i4 + height := height_594_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_594_i4 +def height_594_i3 : ℕ := 7 +def childrenH_594_i3 : Fin 3 → ℕ := ![height_7, height_208, height_594_i4] +theorem height_exact_594_i3 : height_594_i3 = 1 + Finset.univ.sup childrenH_594_i3 := by decide +kernel +theorem required_origin_594_i3 : ∀ x ∈ required_594_i3, + (∃ j, x ∈ childrenC_594_i3 j) ∨ ∀ j, x ∈ childrenD_594_i3 j := by decide +kernel +theorem required_exact_594_i3 : required_594_i3 = + ((Finset.univ.biUnion childrenC_594_i3) ∪ commonEnvelope childrenD_594_i3).erase (2, 5) := by + exact required_eq_combination childrenC_594_i3 childrenD_594_i3 (2, 5) required_594_i3 + (by decide +kernel) child_required_sub_594_i3 common_sub_594_i3 required_origin_594_i3 +theorem envelope_origin_594_i3 : ∀ x ∈ envelope_594_i3, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_594_i3 j := by decide +kernel +theorem envelope_exact_594_i3 : envelope_594_i3 = + insert (2, 5) (Finset.univ.biUnion childrenD_594_i3) := by + exact envelope_eq_combination childrenD_594_i3 (2, 5) envelope_594_i3 + pivot_mem_594_i3 child_envelope_sub_594_i3 envelope_origin_594_i3 +def checked_594_i3 : CheckedCard where + required := required_594_i3 + envelope := envelope_594_i3 + height := height_594_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_594_i3 +def height_594_i2 : ℕ := 8 +def childrenH_594_i2 : Fin 2 → ℕ := ![height_1, height_594_i3] +theorem height_exact_594_i2 : height_594_i2 = 1 + Finset.univ.sup childrenH_594_i2 := by decide +kernel +theorem required_origin_594_i2 : ∀ x ∈ required_594_i2, + (∃ j, x ∈ childrenC_594_i2 j) ∨ ∀ j, x ∈ childrenD_594_i2 j := by decide +kernel +theorem required_exact_594_i2 : required_594_i2 = + ((Finset.univ.biUnion childrenC_594_i2) ∪ commonEnvelope childrenD_594_i2).erase (2, 3) := by + exact required_eq_combination childrenC_594_i2 childrenD_594_i2 (2, 3) required_594_i2 + (by decide +kernel) child_required_sub_594_i2 common_sub_594_i2 required_origin_594_i2 +theorem envelope_origin_594_i2 : ∀ x ∈ envelope_594_i2, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_594_i2 j := by decide +kernel +theorem envelope_exact_594_i2 : envelope_594_i2 = + insert (2, 3) (Finset.univ.biUnion childrenD_594_i2) := by + exact envelope_eq_combination childrenD_594_i2 (2, 3) envelope_594_i2 + pivot_mem_594_i2 child_envelope_sub_594_i2 envelope_origin_594_i2 +def checked_594_i2 : CheckedCard where + required := required_594_i2 + envelope := envelope_594_i2 + height := height_594_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_594_i2 +def height_594_i8 : ℕ := 5 +def childrenH_594_i8 : Fin 2 → ℕ := ![height_1, height_268] +theorem height_exact_594_i8 : height_594_i8 = 1 + Finset.univ.sup childrenH_594_i8 := by decide +kernel +theorem required_origin_594_i8 : ∀ x ∈ required_594_i8, + (∃ j, x ∈ childrenC_594_i8 j) ∨ ∀ j, x ∈ childrenD_594_i8 j := by decide +kernel +theorem required_exact_594_i8 : required_594_i8 = + ((Finset.univ.biUnion childrenC_594_i8) ∪ commonEnvelope childrenD_594_i8).erase (2, 3) := by + exact required_eq_combination childrenC_594_i8 childrenD_594_i8 (2, 3) required_594_i8 + (by decide +kernel) child_required_sub_594_i8 common_sub_594_i8 required_origin_594_i8 +theorem envelope_origin_594_i8 : ∀ x ∈ envelope_594_i8, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_594_i8 j := by decide +kernel +theorem envelope_exact_594_i8 : envelope_594_i8 = + insert (2, 3) (Finset.univ.biUnion childrenD_594_i8) := by + exact envelope_eq_combination childrenD_594_i8 (2, 3) envelope_594_i8 + pivot_mem_594_i8 child_envelope_sub_594_i8 envelope_origin_594_i8 +def checked_594_i8 : CheckedCard where + required := required_594_i8 + envelope := envelope_594_i8 + height := height_594_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_594_i8 +def height_594_i1 : ℕ := 9 +def childrenH_594_i1 : Fin 5 → ℕ := ![height_272, height_290, height_594_i2, height_594_i8, height_593] +theorem height_exact_594_i1 : height_594_i1 = 1 + Finset.univ.sup childrenH_594_i1 := by decide +kernel +theorem required_origin_594_i1 : ∀ x ∈ required_594_i1, + (∃ j, x ∈ childrenC_594_i1 j) ∨ ∀ j, x ∈ childrenD_594_i1 j := by decide +kernel +theorem required_exact_594_i1 : required_594_i1 = + ((Finset.univ.biUnion childrenC_594_i1) ∪ commonEnvelope childrenD_594_i1).erase (2, 6) := by + exact required_eq_combination childrenC_594_i1 childrenD_594_i1 (2, 6) required_594_i1 + (by decide +kernel) child_required_sub_594_i1 common_sub_594_i1 required_origin_594_i1 +theorem envelope_origin_594_i1 : ∀ x ∈ envelope_594_i1, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_594_i1 j := by decide +kernel +theorem envelope_exact_594_i1 : envelope_594_i1 = + insert (2, 6) (Finset.univ.biUnion childrenD_594_i1) := by + exact envelope_eq_combination childrenD_594_i1 (2, 6) envelope_594_i1 + pivot_mem_594_i1 child_envelope_sub_594_i1 envelope_origin_594_i1 +def checked_594_i1 : CheckedCard where + required := required_594_i1 + envelope := envelope_594_i1 + height := height_594_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_594_i1 +def height_594 : ℕ := 10 +def childrenH_594 : Fin 3 → ℕ := ![height_53, height_594_i0, height_594_i1] +theorem height_exact_594 : height_594 = 1 + Finset.univ.sup childrenH_594 := by decide +kernel +theorem required_origin_594 : ∀ x ∈ required_594, + (∃ j, x ∈ childrenC_594 j) ∨ ∀ j, x ∈ childrenD_594 j := by decide +kernel +theorem required_exact_594 : required_594 = + ((Finset.univ.biUnion childrenC_594) ∪ commonEnvelope childrenD_594).erase (6, 4) := by + exact required_eq_combination childrenC_594 childrenD_594 (6, 4) required_594 + (by decide +kernel) child_required_sub_594 common_sub_594 required_origin_594 +theorem envelope_origin_594 : ∀ x ∈ envelope_594, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_594 j := by decide +kernel +theorem envelope_exact_594 : envelope_594 = + insert (6, 4) (Finset.univ.biUnion childrenD_594) := by + exact envelope_eq_combination childrenD_594 (6, 4) envelope_594 + pivot_mem_594 child_envelope_sub_594 envelope_origin_594 +def checked_594 : CheckedCard where + required := required_594 + envelope := envelope_594 + height := height_594 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_594 +def height_608_i1 : ℕ := 5 +def childrenH_608_i1 : Fin 2 → ℕ := ![height_18, height_375] +theorem height_exact_608_i1 : height_608_i1 = 1 + Finset.univ.sup childrenH_608_i1 := by decide +kernel +theorem required_origin_608_i1 : ∀ x ∈ required_608_i1, + (∃ j, x ∈ childrenC_608_i1 j) ∨ ∀ j, x ∈ childrenD_608_i1 j := by decide +kernel +theorem required_exact_608_i1 : required_608_i1 = + ((Finset.univ.biUnion childrenC_608_i1) ∪ commonEnvelope childrenD_608_i1).erase (5, 3) := by + exact required_eq_combination childrenC_608_i1 childrenD_608_i1 (5, 3) required_608_i1 + (by decide +kernel) child_required_sub_608_i1 common_sub_608_i1 required_origin_608_i1 +theorem envelope_origin_608_i1 : ∀ x ∈ envelope_608_i1, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_608_i1 j := by decide +kernel +theorem envelope_exact_608_i1 : envelope_608_i1 = + insert (5, 3) (Finset.univ.biUnion childrenD_608_i1) := by + exact envelope_eq_combination childrenD_608_i1 (5, 3) envelope_608_i1 + pivot_mem_608_i1 child_envelope_sub_608_i1 envelope_origin_608_i1 +def checked_608_i1 : CheckedCard where + required := required_608_i1 + envelope := envelope_608_i1 + height := height_608_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_608_i1 +def height_608_i2 : ℕ := 5 +def childrenH_608_i2 : Fin 2 → ℕ := ![height_28, height_42] +theorem height_exact_608_i2 : height_608_i2 = 1 + Finset.univ.sup childrenH_608_i2 := by decide +kernel +theorem required_origin_608_i2 : ∀ x ∈ required_608_i2, + (∃ j, x ∈ childrenC_608_i2 j) ∨ ∀ j, x ∈ childrenD_608_i2 j := by decide +kernel +theorem required_exact_608_i2 : required_608_i2 = + ((Finset.univ.biUnion childrenC_608_i2) ∪ commonEnvelope childrenD_608_i2).erase (2, 5) := by + exact required_eq_combination childrenC_608_i2 childrenD_608_i2 (2, 5) required_608_i2 + (by decide +kernel) child_required_sub_608_i2 common_sub_608_i2 required_origin_608_i2 +theorem envelope_origin_608_i2 : ∀ x ∈ envelope_608_i2, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_608_i2 j := by decide +kernel +theorem envelope_exact_608_i2 : envelope_608_i2 = + insert (2, 5) (Finset.univ.biUnion childrenD_608_i2) := by + exact envelope_eq_combination childrenD_608_i2 (2, 5) envelope_608_i2 + pivot_mem_608_i2 child_envelope_sub_608_i2 envelope_origin_608_i2 +def checked_608_i2 : CheckedCard where + required := required_608_i2 + envelope := envelope_608_i2 + height := height_608_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_608_i2 +def height_608_i3 : ℕ := 5 +def childrenH_608_i3 : Fin 2 → ℕ := ![height_42, height_58] +theorem height_exact_608_i3 : height_608_i3 = 1 + Finset.univ.sup childrenH_608_i3 := by decide +kernel +theorem required_origin_608_i3 : ∀ x ∈ required_608_i3, + (∃ j, x ∈ childrenC_608_i3 j) ∨ ∀ j, x ∈ childrenD_608_i3 j := by decide +kernel +theorem required_exact_608_i3 : required_608_i3 = + ((Finset.univ.biUnion childrenC_608_i3) ∪ commonEnvelope childrenD_608_i3).erase (2, 5) := by + exact required_eq_combination childrenC_608_i3 childrenD_608_i3 (2, 5) required_608_i3 + (by decide +kernel) child_required_sub_608_i3 common_sub_608_i3 required_origin_608_i3 +theorem envelope_origin_608_i3 : ∀ x ∈ envelope_608_i3, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_608_i3 j := by decide +kernel +theorem envelope_exact_608_i3 : envelope_608_i3 = + insert (2, 5) (Finset.univ.biUnion childrenD_608_i3) := by + exact envelope_eq_combination childrenD_608_i3 (2, 5) envelope_608_i3 + pivot_mem_608_i3 child_envelope_sub_608_i3 envelope_origin_608_i3 +def checked_608_i3 : CheckedCard where + required := required_608_i3 + envelope := envelope_608_i3 + height := height_608_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_608_i3 +def height_608_i0 : ℕ := 6 +def childrenH_608_i0 : Fin 3 → ℕ := ![height_608_i1, height_608_i2, height_608_i3] +theorem height_exact_608_i0 : height_608_i0 = 1 + Finset.univ.sup childrenH_608_i0 := by decide +kernel +theorem required_origin_608_i0 : ∀ x ∈ required_608_i0, + (∃ j, x ∈ childrenC_608_i0 j) ∨ ∀ j, x ∈ childrenD_608_i0 j := by decide +kernel +theorem required_exact_608_i0 : required_608_i0 = + ((Finset.univ.biUnion childrenC_608_i0) ∪ commonEnvelope childrenD_608_i0).erase (1, 2) := by + exact required_eq_combination childrenC_608_i0 childrenD_608_i0 (1, 2) required_608_i0 + (by decide +kernel) child_required_sub_608_i0 common_sub_608_i0 required_origin_608_i0 +theorem envelope_origin_608_i0 : ∀ x ∈ envelope_608_i0, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_608_i0 j := by decide +kernel +theorem envelope_exact_608_i0 : envelope_608_i0 = + insert (1, 2) (Finset.univ.biUnion childrenD_608_i0) := by + exact envelope_eq_combination childrenD_608_i0 (1, 2) envelope_608_i0 + pivot_mem_608_i0 child_envelope_sub_608_i0 envelope_origin_608_i0 +def checked_608_i0 : CheckedCard where + required := required_608_i0 + envelope := envelope_608_i0 + height := height_608_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_608_i0 +def height_608 : ℕ := 10 +def childrenH_608 : Fin 6 → ℕ := ![height_13, height_31, height_355, height_364, height_434, height_608_i0] +theorem height_exact_608 : height_608 = 1 + Finset.univ.sup childrenH_608 := by decide +kernel +theorem required_origin_608 : ∀ x ∈ required_608, + (∃ j, x ∈ childrenC_608 j) ∨ ∀ j, x ∈ childrenD_608 j := by decide +kernel +theorem required_exact_608 : required_608 = + ((Finset.univ.biUnion childrenC_608) ∪ commonEnvelope childrenD_608).erase (4, 6) := by + exact required_eq_combination childrenC_608 childrenD_608 (4, 6) required_608 + (by decide +kernel) child_required_sub_608 common_sub_608 required_origin_608 +theorem envelope_origin_608 : ∀ x ∈ envelope_608, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_608 j := by decide +kernel +theorem envelope_exact_608 : envelope_608 = + insert (4, 6) (Finset.univ.biUnion childrenD_608) := by + exact envelope_eq_combination childrenD_608 (4, 6) envelope_608 + pivot_mem_608 child_envelope_sub_608 envelope_origin_608 +def checked_608 : CheckedCard where + required := required_608 + envelope := envelope_608 + height := height_608 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_608 +def height_616_i1 : ℕ := 3 +def childrenH_616_i1 : Fin 2 → ℕ := ![height_6, height_123] +theorem height_exact_616_i1 : height_616_i1 = 1 + Finset.univ.sup childrenH_616_i1 := by decide +kernel +theorem required_origin_616_i1 : ∀ x ∈ required_616_i1, + (∃ j, x ∈ childrenC_616_i1 j) ∨ ∀ j, x ∈ childrenD_616_i1 j := by decide +kernel +theorem required_exact_616_i1 : required_616_i1 = + ((Finset.univ.biUnion childrenC_616_i1) ∪ commonEnvelope childrenD_616_i1).erase (2, 6) := by + exact required_eq_combination childrenC_616_i1 childrenD_616_i1 (2, 6) required_616_i1 + (by decide +kernel) child_required_sub_616_i1 common_sub_616_i1 required_origin_616_i1 +theorem envelope_origin_616_i1 : ∀ x ∈ envelope_616_i1, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_616_i1 j := by decide +kernel +theorem envelope_exact_616_i1 : envelope_616_i1 = + insert (2, 6) (Finset.univ.biUnion childrenD_616_i1) := by + exact envelope_eq_combination childrenD_616_i1 (2, 6) envelope_616_i1 + pivot_mem_616_i1 child_envelope_sub_616_i1 envelope_origin_616_i1 +def checked_616_i1 : CheckedCard where + required := required_616_i1 + envelope := envelope_616_i1 + height := height_616_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_616_i1 +def height_616_i0 : ℕ := 7 +def childrenH_616_i0 : Fin 3 → ℕ := ![height_11, height_616_i1, height_521] +theorem height_exact_616_i0 : height_616_i0 = 1 + Finset.univ.sup childrenH_616_i0 := by decide +kernel +theorem required_origin_616_i0 : ∀ x ∈ required_616_i0, + (∃ j, x ∈ childrenC_616_i0 j) ∨ ∀ j, x ∈ childrenD_616_i0 j := by decide +kernel +theorem required_exact_616_i0 : required_616_i0 = + ((Finset.univ.biUnion childrenC_616_i0) ∪ commonEnvelope childrenD_616_i0).erase (2, 5) := by + exact required_eq_combination childrenC_616_i0 childrenD_616_i0 (2, 5) required_616_i0 + (by decide +kernel) child_required_sub_616_i0 common_sub_616_i0 required_origin_616_i0 +theorem envelope_origin_616_i0 : ∀ x ∈ envelope_616_i0, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_616_i0 j := by decide +kernel +theorem envelope_exact_616_i0 : envelope_616_i0 = + insert (2, 5) (Finset.univ.biUnion childrenD_616_i0) := by + exact envelope_eq_combination childrenD_616_i0 (2, 5) envelope_616_i0 + pivot_mem_616_i0 child_envelope_sub_616_i0 envelope_origin_616_i0 +def checked_616_i0 : CheckedCard where + required := required_616_i0 + envelope := envelope_616_i0 + height := height_616_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_616_i0 +def height_616 : ℕ := 10 +def childrenH_616 : Fin 7 → ℕ := ![height_345, height_421, height_522, height_530, height_533, height_534, height_616_i0] +theorem height_exact_616 : height_616 = 1 + Finset.univ.sup childrenH_616 := by decide +kernel +theorem required_origin_616 : ∀ x ∈ required_616, + (∃ j, x ∈ childrenC_616 j) ∨ ∀ j, x ∈ childrenD_616 j := by decide +kernel +theorem required_exact_616 : required_616 = + ((Finset.univ.biUnion childrenC_616) ∪ commonEnvelope childrenD_616).erase (3, 3) := by + exact required_eq_combination childrenC_616 childrenD_616 (3, 3) required_616 + (by decide +kernel) child_required_sub_616 common_sub_616 required_origin_616 +theorem envelope_origin_616 : ∀ x ∈ envelope_616, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_616 j := by decide +kernel +theorem envelope_exact_616 : envelope_616 = + insert (3, 3) (Finset.univ.biUnion childrenD_616) := by + exact envelope_eq_combination childrenD_616 (3, 3) envelope_616 + pivot_mem_616 child_envelope_sub_616 envelope_origin_616 +def checked_616 : CheckedCard where + required := required_616 + envelope := envelope_616 + height := height_616 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_616 +def height_631_i1 : ℕ := 8 +def childrenH_631_i1 : Fin 2 → ℕ := ![height_45, height_418] +theorem height_exact_631_i1 : height_631_i1 = 1 + Finset.univ.sup childrenH_631_i1 := by decide +kernel +theorem required_origin_631_i1 : ∀ x ∈ required_631_i1, + (∃ j, x ∈ childrenC_631_i1 j) ∨ ∀ j, x ∈ childrenD_631_i1 j := by decide +kernel +theorem required_exact_631_i1 : required_631_i1 = + ((Finset.univ.biUnion childrenC_631_i1) ∪ commonEnvelope childrenD_631_i1).erase (3, 2) := by + exact required_eq_combination childrenC_631_i1 childrenD_631_i1 (3, 2) required_631_i1 + (by decide +kernel) child_required_sub_631_i1 common_sub_631_i1 required_origin_631_i1 +theorem envelope_origin_631_i1 : ∀ x ∈ envelope_631_i1, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_631_i1 j := by decide +kernel +theorem envelope_exact_631_i1 : envelope_631_i1 = + insert (3, 2) (Finset.univ.biUnion childrenD_631_i1) := by + exact envelope_eq_combination childrenD_631_i1 (3, 2) envelope_631_i1 + pivot_mem_631_i1 child_envelope_sub_631_i1 envelope_origin_631_i1 +def checked_631_i1 : CheckedCard where + required := required_631_i1 + envelope := envelope_631_i1 + height := height_631_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_631_i1 +def height_631_i0 : ℕ := 9 +def childrenH_631_i0 : Fin 3 → ℕ := ![height_43, height_51, height_631_i1] +theorem height_exact_631_i0 : height_631_i0 = 1 + Finset.univ.sup childrenH_631_i0 := by decide +kernel +theorem required_origin_631_i0 : ∀ x ∈ required_631_i0, + (∃ j, x ∈ childrenC_631_i0 j) ∨ ∀ j, x ∈ childrenD_631_i0 j := by decide +kernel +theorem required_exact_631_i0 : required_631_i0 = + ((Finset.univ.biUnion childrenC_631_i0) ∪ commonEnvelope childrenD_631_i0).erase (4, 2) := by + exact required_eq_combination childrenC_631_i0 childrenD_631_i0 (4, 2) required_631_i0 + (by decide +kernel) child_required_sub_631_i0 common_sub_631_i0 required_origin_631_i0 +theorem envelope_origin_631_i0 : ∀ x ∈ envelope_631_i0, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_631_i0 j := by decide +kernel +theorem envelope_exact_631_i0 : envelope_631_i0 = + insert (4, 2) (Finset.univ.biUnion childrenD_631_i0) := by + exact envelope_eq_combination childrenD_631_i0 (4, 2) envelope_631_i0 + pivot_mem_631_i0 child_envelope_sub_631_i0 envelope_origin_631_i0 +def checked_631_i0 : CheckedCard where + required := required_631_i0 + envelope := envelope_631_i0 + height := height_631_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_631_i0 +def height_631 : ℕ := 10 +def childrenH_631 : Fin 4 → ℕ := ![height_44, height_52, height_63, height_631_i0] +theorem height_exact_631 : height_631 = 1 + Finset.univ.sup childrenH_631 := by decide +kernel +theorem required_origin_631 : ∀ x ∈ required_631, + (∃ j, x ∈ childrenC_631 j) ∨ ∀ j, x ∈ childrenD_631 j := by decide +kernel +theorem required_exact_631 : required_631 = + ((Finset.univ.biUnion childrenC_631) ∪ commonEnvelope childrenD_631).erase (3, 5) := by + exact required_eq_combination childrenC_631 childrenD_631 (3, 5) required_631 + (by decide +kernel) child_required_sub_631 common_sub_631 required_origin_631 +theorem envelope_origin_631 : ∀ x ∈ envelope_631, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_631 j := by decide +kernel +theorem envelope_exact_631 : envelope_631 = + insert (3, 5) (Finset.univ.biUnion childrenD_631) := by + exact envelope_eq_combination childrenD_631 (3, 5) envelope_631 + pivot_mem_631 child_envelope_sub_631 envelope_origin_631 +def checked_631 : CheckedCard where + required := required_631 + envelope := envelope_631 + height := height_631 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_631 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part06.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part06.lean new file mode 100644 index 0000000..7de7259 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part06.lean @@ -0,0 +1,943 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part08 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_652_i3 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (3, 3), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_652_i3 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (2, 5), (3, 2), (3, 3), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_652_i3 : Fin 2 → Finset Cell := ![(placed21 6 (5, 5) required_0), (placed21 2 (5, 2) required_245)] +def childrenD_652_i3 : Fin 2 → Finset Cell := ![(placed21 6 (5, 5) envelope_0), (placed21 2 (5, 2) envelope_245)] +theorem common_sub_652_i3 : commonEnvelope childrenD_652_i3 ⊆ insert (3, 5) required_652_i3 := by decide +kernel +theorem child_required_sub_652_i3 : ∀ j, childrenC_652_i3 j ⊆ insert (3, 5) required_652_i3 := by decide +kernel +theorem child_envelope_sub_652_i3 : ∀ j, childrenD_652_i3 j ⊆ envelope_652_i3 := by decide +kernel +theorem pivot_mem_652_i3 : (3, 5) ∈ envelope_652_i3 := by decide +kernel +theorem children_work_652_i3 : ∀ j, Template HasSnaky 3 (childrenC_652_i3 j) (childrenD_652_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_245 2 (5, 2)).mono (by decide +kernel) +theorem row_works_652_i3 : Template HasSnaky 4 required_652_i3 envelope_652_i3 := by + refine compose HasSnaky 3 childrenC_652_i3 childrenD_652_i3 children_work_652_i3 (3, 5) + required_652_i3 envelope_652_i3 pivot_mem_652_i3 child_required_sub_652_i3 child_envelope_sub_652_i3 ?_ + intro b hb + exact common_sub_652_i3 (mem_commonEnvelope childrenD_652_i3 b hb) +def required_652_i2 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (3, 3), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_652_i2 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_652_i2 : Fin 3 → Finset Cell := ![(placed21 1 (1, 4) required_36), (placed21 6 (4, 6) required_44), required_652_i3] +def childrenD_652_i2 : Fin 3 → Finset Cell := ![(placed21 1 (1, 4) envelope_36), (placed21 6 (4, 6) envelope_44), envelope_652_i3] +theorem common_sub_652_i2 : commonEnvelope childrenD_652_i2 ⊆ insert (4, 5) required_652_i2 := by decide +kernel +theorem child_required_sub_652_i2 : ∀ j, childrenC_652_i2 j ⊆ insert (4, 5) required_652_i2 := by decide +kernel +theorem child_envelope_sub_652_i2 : ∀ j, childrenD_652_i2 j ⊆ envelope_652_i2 := by decide +kernel +theorem pivot_mem_652_i2 : (4, 5) ∈ envelope_652_i2 := by decide +kernel +theorem children_work_652_i2 : ∀ j, Template HasSnaky 4 (childrenC_652_i2 j) (childrenD_652_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_36 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_44 6 (4, 6)).mono (by decide +kernel) + · exact row_works_652_i3.mono (by decide +kernel) +theorem row_works_652_i2 : Template HasSnaky 5 required_652_i2 envelope_652_i2 := by + refine compose HasSnaky 4 childrenC_652_i2 childrenD_652_i2 children_work_652_i2 (4, 5) + required_652_i2 envelope_652_i2 pivot_mem_652_i2 child_required_sub_652_i2 child_envelope_sub_652_i2 ?_ + intro b hb + exact common_sub_652_i2 (mem_commonEnvelope childrenD_652_i2 b hb) +def required_652_i1 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (2, 5), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_652_i1 : Finset Cell := ⟨(([(0, 2), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_652_i1 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) required_222), required_652_i2] +def childrenD_652_i1 : Fin 2 → Finset Cell := ![(placed21 3 (0, 5) envelope_222), envelope_652_i2] +theorem common_sub_652_i1 : commonEnvelope childrenD_652_i1 ⊆ insert (4, 4) required_652_i1 := by decide +kernel +theorem child_required_sub_652_i1 : ∀ j, childrenC_652_i1 j ⊆ insert (4, 4) required_652_i1 := by decide +kernel +theorem child_envelope_sub_652_i1 : ∀ j, childrenD_652_i1 j ⊆ envelope_652_i1 := by decide +kernel +theorem pivot_mem_652_i1 : (4, 4) ∈ envelope_652_i1 := by decide +kernel +theorem children_work_652_i1 : ∀ j, Template HasSnaky 5 (childrenC_652_i1 j) (childrenD_652_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_222 3 (0, 5)).mono (by decide +kernel) + · exact row_works_652_i2.mono (by decide +kernel) +theorem row_works_652_i1 : Template HasSnaky 6 required_652_i1 envelope_652_i1 := by + refine compose HasSnaky 5 childrenC_652_i1 childrenD_652_i1 children_work_652_i1 (4, 4) + required_652_i1 envelope_652_i1 pivot_mem_652_i1 child_required_sub_652_i1 child_envelope_sub_652_i1 ?_ + intro b hb + exact common_sub_652_i1 (mem_commonEnvelope childrenD_652_i1 b hb) +def required_652_i0 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_652_i0 : Finset Cell := ⟨(([(0, 2), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_652_i0 : Fin 3 → Finset Cell := ![(placed21 2 (3, 2) required_10), (placed21 1 (0, 3) required_558), required_652_i1] +def childrenD_652_i0 : Fin 3 → Finset Cell := ![(placed21 2 (3, 2) envelope_10), (placed21 1 (0, 3) envelope_558), envelope_652_i1] +theorem common_sub_652_i0 : commonEnvelope childrenD_652_i0 ⊆ insert (2, 5) required_652_i0 := by decide +kernel +theorem child_required_sub_652_i0 : ∀ j, childrenC_652_i0 j ⊆ insert (2, 5) required_652_i0 := by decide +kernel +theorem child_envelope_sub_652_i0 : ∀ j, childrenD_652_i0 j ⊆ envelope_652_i0 := by decide +kernel +theorem pivot_mem_652_i0 : (2, 5) ∈ envelope_652_i0 := by decide +kernel +theorem children_work_652_i0 : ∀ j, Template HasSnaky 8 (childrenC_652_i0 j) (childrenD_652_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 2 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_558 1 (0, 3)).mono (by decide +kernel) + · exact row_works_652_i1.mono (by decide +kernel) +theorem row_works_652_i0 : Template HasSnaky 9 required_652_i0 envelope_652_i0 := by + refine compose HasSnaky 8 childrenC_652_i0 childrenD_652_i0 children_work_652_i0 (2, 5) + required_652_i0 envelope_652_i0 pivot_mem_652_i0 child_required_sub_652_i0 child_envelope_sub_652_i0 ?_ + intro b hb + exact common_sub_652_i0 (mem_commonEnvelope childrenD_652_i0 b hb) +def required_652 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_652 : Finset Cell := ⟨(([(0, 2), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_652 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) required_0), required_652_i0] +def childrenD_652 : Fin 2 → Finset Cell := ![(placed21 2 (5, 3) envelope_0), envelope_652_i0] +theorem common_sub_652 : commonEnvelope childrenD_652 ⊆ insert (4, 3) required_652 := by decide +kernel +theorem child_required_sub_652 : ∀ j, childrenC_652 j ⊆ insert (4, 3) required_652 := by decide +kernel +theorem child_envelope_sub_652 : ∀ j, childrenD_652 j ⊆ envelope_652 := by decide +kernel +theorem pivot_mem_652 : (4, 3) ∈ envelope_652 := by decide +kernel +theorem children_work_652 : ∀ j, Template HasSnaky 9 (childrenC_652 j) (childrenD_652 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (5, 3)).mono (by decide +kernel) + · exact row_works_652_i0.mono (by decide +kernel) +theorem row_works_652 : Template HasSnaky 10 required_652 envelope_652 := by + refine compose HasSnaky 9 childrenC_652 childrenD_652 children_work_652 (4, 3) + required_652 envelope_652 pivot_mem_652 child_required_sub_652 child_envelope_sub_652 ?_ + intro b hb + exact common_sub_652 (mem_commonEnvelope childrenD_652 b hb) +def required_674 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_674 : Finset Cell := ⟨(([(0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 4), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_674 : Fin 3 → Finset Cell := ![(placed21 2 (2, 2) required_34), (placed21 0 (1, 2) required_149), required_673] +def childrenD_674 : Fin 3 → Finset Cell := ![(placed21 2 (2, 2) envelope_34), (placed21 0 (1, 2) envelope_149), envelope_673] +theorem common_sub_674 : commonEnvelope childrenD_674 ⊆ insert (2, 4) required_674 := by decide +kernel +theorem child_required_sub_674 : ∀ j, childrenC_674 j ⊆ insert (2, 4) required_674 := by decide +kernel +theorem child_envelope_sub_674 : ∀ j, childrenD_674 j ⊆ envelope_674 := by decide +kernel +theorem pivot_mem_674 : (2, 4) ∈ envelope_674 := by decide +kernel +theorem children_work_674 : ∀ j, Template HasSnaky 9 (childrenC_674 j) (childrenD_674 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_34 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_149 0 (1, 2)).mono (by decide +kernel) + · exact row_works_673.mono (by decide +kernel) +theorem row_works_674 : Template HasSnaky 10 required_674 envelope_674 := by + refine compose HasSnaky 9 childrenC_674 childrenD_674 children_work_674 (2, 4) + required_674 envelope_674 pivot_mem_674 child_required_sub_674 child_envelope_sub_674 ?_ + intro b hb + exact common_sub_674 (mem_commonEnvelope childrenD_674 b hb) +def required_702_i1 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 2), (2, 3), (4, 2), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_702_i1 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (4, 2), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_702_i1 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) required_15), (placed21 1 (0, 1) required_40)] +def childrenD_702_i1 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) envelope_15), (placed21 1 (0, 1) envelope_40)] +theorem common_sub_702_i1 : commonEnvelope childrenD_702_i1 ⊆ insert (1, 1) required_702_i1 := by decide +kernel +theorem child_required_sub_702_i1 : ∀ j, childrenC_702_i1 j ⊆ insert (1, 1) required_702_i1 := by decide +kernel +theorem child_envelope_sub_702_i1 : ∀ j, childrenD_702_i1 j ⊆ envelope_702_i1 := by decide +kernel +theorem pivot_mem_702_i1 : (1, 1) ∈ envelope_702_i1 := by decide +kernel +theorem children_work_702_i1 : ∀ j, Template HasSnaky 2 (childrenC_702_i1 j) (childrenD_702_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_40 1 (0, 1)).mono (by decide +kernel) +theorem row_works_702_i1 : Template HasSnaky 3 required_702_i1 envelope_702_i1 := by + refine compose HasSnaky 2 childrenC_702_i1 childrenD_702_i1 children_work_702_i1 (1, 1) + required_702_i1 envelope_702_i1 pivot_mem_702_i1 child_required_sub_702_i1 child_envelope_sub_702_i1 ?_ + intro b hb + exact common_sub_702_i1 (mem_commonEnvelope childrenD_702_i1 b hb) +def required_702_i0 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 2), (2, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_702_i0 : Finset Cell := ⟨(([(0, 1), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_702_i0 : Fin 4 → Finset Cell := ![(placed21 1 (1, 2) required_30), required_108, required_702_i1, (placed21 0 (1, 0) required_511)] +def childrenD_702_i0 : Fin 4 → Finset Cell := ![(placed21 1 (1, 2) envelope_30), envelope_108, envelope_702_i1, (placed21 0 (1, 0) envelope_511)] +theorem common_sub_702_i0 : commonEnvelope childrenD_702_i0 ⊆ insert (4, 2) required_702_i0 := by decide +kernel +theorem child_required_sub_702_i0 : ∀ j, childrenC_702_i0 j ⊆ insert (4, 2) required_702_i0 := by decide +kernel +theorem child_envelope_sub_702_i0 : ∀ j, childrenD_702_i0 j ⊆ envelope_702_i0 := by decide +kernel +theorem pivot_mem_702_i0 : (4, 2) ∈ envelope_702_i0 := by decide +kernel +theorem children_work_702_i0 : ∀ j, Template HasSnaky 7 (childrenC_702_i0 j) (childrenD_702_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_30 1 (1, 2)).mono (by decide +kernel) + · exact row_works_108.mono (by decide +kernel) + · exact row_works_702_i1.mono (by decide +kernel) + · exact (placed21_template row_works_511 0 (1, 0)).mono (by decide +kernel) +theorem row_works_702_i0 : Template HasSnaky 8 required_702_i0 envelope_702_i0 := by + refine compose HasSnaky 7 childrenC_702_i0 childrenD_702_i0 children_work_702_i0 (4, 2) + required_702_i0 envelope_702_i0 pivot_mem_702_i0 child_required_sub_702_i0 child_envelope_sub_702_i0 ?_ + intro b hb + exact common_sub_702_i0 (mem_commonEnvelope childrenD_702_i0 b hb) +def required_702 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 2), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_702 : Finset Cell := ⟨(([(0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_702 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) required_22), (placed21 0 (0, 1) required_400), required_702_i0] +def childrenD_702 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) envelope_22), (placed21 0 (0, 1) envelope_400), envelope_702_i0] +theorem common_sub_702 : commonEnvelope childrenD_702 ⊆ insert (4, 3) required_702 := by decide +kernel +theorem child_required_sub_702 : ∀ j, childrenC_702 j ⊆ insert (4, 3) required_702 := by decide +kernel +theorem child_envelope_sub_702 : ∀ j, childrenD_702 j ⊆ envelope_702 := by decide +kernel +theorem pivot_mem_702 : (4, 3) ∈ envelope_702 := by decide +kernel +theorem children_work_702 : ∀ j, Template HasSnaky 9 (childrenC_702 j) (childrenD_702 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_400 0 (0, 1)).mono (by decide +kernel) + · exact row_works_702_i0.mono (by decide +kernel) +theorem row_works_702 : Template HasSnaky 10 required_702 envelope_702 := by + refine compose HasSnaky 9 childrenC_702 childrenD_702 children_work_702 (4, 3) + required_702 envelope_702 pivot_mem_702 child_required_sub_702 child_envelope_sub_702 ?_ + intro b hb + exact common_sub_702 (mem_commonEnvelope childrenD_702 b hb) +def required_704_i1 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (2, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_704_i1 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 5), (3, 7), (3, 8), (3, 9), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_704_i1 : Fin 3 → Finset Cell := ![(placed21 5 (5, 4) required_28), (placed21 0 (1, 3) required_58), (placed21 0 (1, 2) required_306)] +def childrenD_704_i1 : Fin 3 → Finset Cell := ![(placed21 5 (5, 4) envelope_28), (placed21 0 (1, 3) envelope_58), (placed21 0 (1, 2) envelope_306)] +theorem common_sub_704_i1 : commonEnvelope childrenD_704_i1 ⊆ insert (4, 6) required_704_i1 := by decide +kernel +theorem child_required_sub_704_i1 : ∀ j, childrenC_704_i1 j ⊆ insert (4, 6) required_704_i1 := by decide +kernel +theorem child_envelope_sub_704_i1 : ∀ j, childrenD_704_i1 j ⊆ envelope_704_i1 := by decide +kernel +theorem pivot_mem_704_i1 : (4, 6) ∈ envelope_704_i1 := by decide +kernel +theorem children_work_704_i1 : ∀ j, Template HasSnaky 5 (childrenC_704_i1 j) (childrenD_704_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_28 5 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_58 0 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_306 0 (1, 2)).mono (by decide +kernel) +theorem row_works_704_i1 : Template HasSnaky 6 required_704_i1 envelope_704_i1 := by + refine compose HasSnaky 5 childrenC_704_i1 childrenD_704_i1 children_work_704_i1 (4, 6) + required_704_i1 envelope_704_i1 pivot_mem_704_i1 child_required_sub_704_i1 child_envelope_sub_704_i1 ?_ + intro b hb + exact common_sub_704_i1 (mem_commonEnvelope childrenD_704_i1 b hb) +def required_704_i3 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_704_i3 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_704_i3 : Fin 2 → Finset Cell := ![(placed21 6 (5, 5) required_2), (placed21 0 (4, 2) required_52)] +def childrenD_704_i3 : Fin 2 → Finset Cell := ![(placed21 6 (5, 5) envelope_2), (placed21 0 (4, 2) envelope_52)] +theorem common_sub_704_i3 : commonEnvelope childrenD_704_i3 ⊆ insert (5, 5) required_704_i3 := by decide +kernel +theorem child_required_sub_704_i3 : ∀ j, childrenC_704_i3 j ⊆ insert (5, 5) required_704_i3 := by decide +kernel +theorem child_envelope_sub_704_i3 : ∀ j, childrenD_704_i3 j ⊆ envelope_704_i3 := by decide +kernel +theorem pivot_mem_704_i3 : (5, 5) ∈ envelope_704_i3 := by decide +kernel +theorem children_work_704_i3 : ∀ j, Template HasSnaky 3 (childrenC_704_i3 j) (childrenD_704_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 6 (5, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (4, 2)).mono (by decide +kernel) +theorem row_works_704_i3 : Template HasSnaky 4 required_704_i3 envelope_704_i3 := by + refine compose HasSnaky 3 childrenC_704_i3 childrenD_704_i3 children_work_704_i3 (5, 5) + required_704_i3 envelope_704_i3 pivot_mem_704_i3 child_required_sub_704_i3 child_envelope_sub_704_i3 ?_ + intro b hb + exact common_sub_704_i3 (mem_commonEnvelope childrenD_704_i3 b hb) +def required_704_i4 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_704_i4 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_704_i4 : Fin 2 → Finset Cell := ![(placed21 6 (5, 5) required_2), (placed21 6 (5, 6) required_10)] +def childrenD_704_i4 : Fin 2 → Finset Cell := ![(placed21 6 (5, 5) envelope_2), (placed21 6 (5, 6) envelope_10)] +theorem common_sub_704_i4 : commonEnvelope childrenD_704_i4 ⊆ insert (5, 5) required_704_i4 := by decide +kernel +theorem child_required_sub_704_i4 : ∀ j, childrenC_704_i4 j ⊆ insert (5, 5) required_704_i4 := by decide +kernel +theorem child_envelope_sub_704_i4 : ∀ j, childrenD_704_i4 j ⊆ envelope_704_i4 := by decide +kernel +theorem pivot_mem_704_i4 : (5, 5) ∈ envelope_704_i4 := by decide +kernel +theorem children_work_704_i4 : ∀ j, Template HasSnaky 4 (childrenC_704_i4 j) (childrenD_704_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 6 (5, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_10 6 (5, 6)).mono (by decide +kernel) +theorem row_works_704_i4 : Template HasSnaky 5 required_704_i4 envelope_704_i4 := by + refine compose HasSnaky 4 childrenC_704_i4 childrenD_704_i4 children_work_704_i4 (5, 5) + required_704_i4 envelope_704_i4 pivot_mem_704_i4 child_required_sub_704_i4 child_envelope_sub_704_i4 ?_ + intro b hb + exact common_sub_704_i4 (mem_commonEnvelope childrenD_704_i4 b hb) +def required_704_i5 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (2, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_704_i5 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_704_i5 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) required_25), (placed21 7 (5, 6) required_78)] +def childrenD_704_i5 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) envelope_25), (placed21 7 (5, 6) envelope_78)] +theorem common_sub_704_i5 : commonEnvelope childrenD_704_i5 ⊆ insert (4, 6) required_704_i5 := by decide +kernel +theorem child_required_sub_704_i5 : ∀ j, childrenC_704_i5 j ⊆ insert (4, 6) required_704_i5 := by decide +kernel +theorem child_envelope_sub_704_i5 : ∀ j, childrenD_704_i5 j ⊆ envelope_704_i5 := by decide +kernel +theorem pivot_mem_704_i5 : (4, 6) ∈ envelope_704_i5 := by decide +kernel +theorem children_work_704_i5 : ∀ j, Template HasSnaky 3 (childrenC_704_i5 j) (childrenD_704_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_25 5 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_78 7 (5, 6)).mono (by decide +kernel) +theorem row_works_704_i5 : Template HasSnaky 4 required_704_i5 envelope_704_i5 := by + refine compose HasSnaky 3 childrenC_704_i5 childrenD_704_i5 children_work_704_i5 (4, 6) + required_704_i5 envelope_704_i5 pivot_mem_704_i5 child_required_sub_704_i5 child_envelope_sub_704_i5 ?_ + intro b hb + exact common_sub_704_i5 (mem_commonEnvelope childrenD_704_i5 b hb) +def required_704_i2 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (2, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_704_i2 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_704_i2 : Fin 4 → Finset Cell := ![(placed21 4 (1, 6) required_516), required_704_i3, required_704_i4, required_704_i5] +def childrenD_704_i2 : Fin 4 → Finset Cell := ![(placed21 4 (1, 6) envelope_516), envelope_704_i3, envelope_704_i4, envelope_704_i5] +theorem common_sub_704_i2 : commonEnvelope childrenD_704_i2 ⊆ insert (4, 3) required_704_i2 := by decide +kernel +theorem child_required_sub_704_i2 : ∀ j, childrenC_704_i2 j ⊆ insert (4, 3) required_704_i2 := by decide +kernel +theorem child_envelope_sub_704_i2 : ∀ j, childrenD_704_i2 j ⊆ envelope_704_i2 := by decide +kernel +theorem pivot_mem_704_i2 : (4, 3) ∈ envelope_704_i2 := by decide +kernel +theorem children_work_704_i2 : ∀ j, Template HasSnaky 6 (childrenC_704_i2 j) (childrenD_704_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_516 4 (1, 6)).mono (by decide +kernel) + · exact row_works_704_i3.mono (by decide +kernel) + · exact row_works_704_i4.mono (by decide +kernel) + · exact row_works_704_i5.mono (by decide +kernel) +theorem row_works_704_i2 : Template HasSnaky 7 required_704_i2 envelope_704_i2 := by + refine compose HasSnaky 6 childrenC_704_i2 childrenD_704_i2 children_work_704_i2 (4, 3) + required_704_i2 envelope_704_i2 pivot_mem_704_i2 child_required_sub_704_i2 child_envelope_sub_704_i2 ?_ + intro b hb + exact common_sub_704_i2 (mem_commonEnvelope childrenD_704_i2 b hb) +def required_704_i0 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (2, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_704_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 2), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 5), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_704_i0 : Fin 4 → Finset Cell := ![(placed21 3 (1, 5) required_30), required_704_i1, required_703, required_704_i2] +def childrenD_704_i0 : Fin 4 → Finset Cell := ![(placed21 3 (1, 5) envelope_30), envelope_704_i1, envelope_703, envelope_704_i2] +theorem common_sub_704_i0 : commonEnvelope childrenD_704_i0 ⊆ insert (4, 5) required_704_i0 := by decide +kernel +theorem child_required_sub_704_i0 : ∀ j, childrenC_704_i0 j ⊆ insert (4, 5) required_704_i0 := by decide +kernel +theorem child_envelope_sub_704_i0 : ∀ j, childrenD_704_i0 j ⊆ envelope_704_i0 := by decide +kernel +theorem pivot_mem_704_i0 : (4, 5) ∈ envelope_704_i0 := by decide +kernel +theorem children_work_704_i0 : ∀ j, Template HasSnaky 8 (childrenC_704_i0 j) (childrenD_704_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_30 3 (1, 5)).mono (by decide +kernel) + · exact row_works_704_i1.mono (by decide +kernel) + · exact row_works_703.mono (by decide +kernel) + · exact row_works_704_i2.mono (by decide +kernel) +theorem row_works_704_i0 : Template HasSnaky 9 required_704_i0 envelope_704_i0 := by + refine compose HasSnaky 8 childrenC_704_i0 childrenD_704_i0 children_work_704_i0 (4, 5) + required_704_i0 envelope_704_i0 pivot_mem_704_i0 child_required_sub_704_i0 child_envelope_sub_704_i0 ?_ + intro b hb + exact common_sub_704_i0 (mem_commonEnvelope childrenD_704_i0 b hb) +def required_704 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_704 : Finset Cell := ⟨(([(0, 1), (0, 5), (1, 1), (1, 2), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_704 : Fin 3 → Finset Cell := ![(placed21 1 (0, 4) required_22), (placed21 4 (0, 6) required_400), required_704_i0] +def childrenD_704 : Fin 3 → Finset Cell := ![(placed21 1 (0, 4) envelope_22), (placed21 4 (0, 6) envelope_400), envelope_704_i0] +theorem common_sub_704 : commonEnvelope childrenD_704 ⊆ insert (4, 4) required_704 := by decide +kernel +theorem child_required_sub_704 : ∀ j, childrenC_704 j ⊆ insert (4, 4) required_704 := by decide +kernel +theorem child_envelope_sub_704 : ∀ j, childrenD_704 j ⊆ envelope_704 := by decide +kernel +theorem pivot_mem_704 : (4, 4) ∈ envelope_704 := by decide +kernel +theorem children_work_704 : ∀ j, Template HasSnaky 9 (childrenC_704 j) (childrenD_704 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_400 4 (0, 6)).mono (by decide +kernel) + · exact row_works_704_i0.mono (by decide +kernel) +theorem row_works_704 : Template HasSnaky 10 required_704 envelope_704 := by + refine compose HasSnaky 9 childrenC_704 childrenD_704 children_work_704 (4, 4) + required_704 envelope_704 pivot_mem_704 child_required_sub_704 child_envelope_sub_704 ?_ + intro b hb + exact common_sub_704 (mem_commonEnvelope childrenD_704 b hb) +def required_721_i4 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 6), (4, 6), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_721_i4 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 6), (4, 6), (5, 5), (5, 6), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_721_i4 : Fin 2 → Finset Cell := ![(placed21 4 (2, 6) required_5), (placed21 6 (5, 7) required_208)] +def childrenD_721_i4 : Fin 2 → Finset Cell := ![(placed21 4 (2, 6) envelope_5), (placed21 6 (5, 7) envelope_208)] +theorem common_sub_721_i4 : commonEnvelope childrenD_721_i4 ⊆ insert (2, 6) required_721_i4 := by decide +kernel +theorem child_required_sub_721_i4 : ∀ j, childrenC_721_i4 j ⊆ insert (2, 6) required_721_i4 := by decide +kernel +theorem child_envelope_sub_721_i4 : ∀ j, childrenD_721_i4 j ⊆ envelope_721_i4 := by decide +kernel +theorem pivot_mem_721_i4 : (2, 6) ∈ envelope_721_i4 := by decide +kernel +theorem children_work_721_i4 : ∀ j, Template HasSnaky 4 (childrenC_721_i4 j) (childrenD_721_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_208 6 (5, 7)).mono (by decide +kernel) +theorem row_works_721_i4 : Template HasSnaky 5 required_721_i4 envelope_721_i4 := by + refine compose HasSnaky 4 childrenC_721_i4 childrenD_721_i4 children_work_721_i4 (2, 6) + required_721_i4 envelope_721_i4 pivot_mem_721_i4 child_required_sub_721_i4 child_envelope_sub_721_i4 ?_ + intro b hb + exact common_sub_721_i4 (mem_commonEnvelope childrenD_721_i4 b hb) +def required_721_i3 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 6), (5, 3), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_721_i3 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 6), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_721_i3 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) required_5), required_721_i4] +def childrenD_721_i3 : Fin 2 → Finset Cell := ![(placed21 5 (5, 3) envelope_5), envelope_721_i4] +theorem common_sub_721_i3 : commonEnvelope childrenD_721_i3 ⊆ insert (4, 6) required_721_i3 := by decide +kernel +theorem child_required_sub_721_i3 : ∀ j, childrenC_721_i3 j ⊆ insert (4, 6) required_721_i3 := by decide +kernel +theorem child_envelope_sub_721_i3 : ∀ j, childrenD_721_i3 j ⊆ envelope_721_i3 := by decide +kernel +theorem pivot_mem_721_i3 : (4, 6) ∈ envelope_721_i3 := by decide +kernel +theorem children_work_721_i3 : ∀ j, Template HasSnaky 5 (childrenC_721_i3 j) (childrenD_721_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (5, 3)).mono (by decide +kernel) + · exact row_works_721_i4.mono (by decide +kernel) +theorem row_works_721_i3 : Template HasSnaky 6 required_721_i3 envelope_721_i3 := by + refine compose HasSnaky 5 childrenC_721_i3 childrenD_721_i3 children_work_721_i3 (4, 6) + required_721_i3 envelope_721_i3 pivot_mem_721_i3 child_required_sub_721_i3 child_envelope_sub_721_i3 ?_ + intro b hb + exact common_sub_721_i3 (mem_commonEnvelope childrenD_721_i3 b hb) +def required_721_i2 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 3), (3, 4), (5, 3), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_721_i2 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_721_i2 : Fin 2 → Finset Cell := ![(placed21 2 (3, 2) required_22), required_721_i3] +def childrenD_721_i2 : Fin 2 → Finset Cell := ![(placed21 2 (3, 2) envelope_22), envelope_721_i3] +theorem common_sub_721_i2 : commonEnvelope childrenD_721_i2 ⊆ insert (3, 6) required_721_i2 := by decide +kernel +theorem child_required_sub_721_i2 : ∀ j, childrenC_721_i2 j ⊆ insert (3, 6) required_721_i2 := by decide +kernel +theorem child_envelope_sub_721_i2 : ∀ j, childrenD_721_i2 j ⊆ envelope_721_i2 := by decide +kernel +theorem pivot_mem_721_i2 : (3, 6) ∈ envelope_721_i2 := by decide +kernel +theorem children_work_721_i2 : ∀ j, Template HasSnaky 6 (childrenC_721_i2 j) (childrenD_721_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 2 (3, 2)).mono (by decide +kernel) + · exact row_works_721_i3.mono (by decide +kernel) +theorem row_works_721_i2 : Template HasSnaky 7 required_721_i2 envelope_721_i2 := by + refine compose HasSnaky 6 childrenC_721_i2 childrenD_721_i2 children_work_721_i2 (3, 6) + required_721_i2 envelope_721_i2 pivot_mem_721_i2 child_required_sub_721_i2 child_envelope_sub_721_i2 ?_ + intro b hb + exact common_sub_721_i2 (mem_commonEnvelope childrenD_721_i2 b hb) +def required_721_i1 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (5, 3), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_721_i1 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_721_i1 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) required_25), required_721_i2] +def childrenD_721_i1 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) envelope_25), envelope_721_i2] +theorem common_sub_721_i1 : commonEnvelope childrenD_721_i1 ⊆ insert (2, 4) required_721_i1 := by decide +kernel +theorem child_required_sub_721_i1 : ∀ j, childrenC_721_i1 j ⊆ insert (2, 4) required_721_i1 := by decide +kernel +theorem child_envelope_sub_721_i1 : ∀ j, childrenD_721_i1 j ⊆ envelope_721_i1 := by decide +kernel +theorem pivot_mem_721_i1 : (2, 4) ∈ envelope_721_i1 := by decide +kernel +theorem children_work_721_i1 : ∀ j, Template HasSnaky 7 (childrenC_721_i1 j) (childrenD_721_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_25 7 (6, 6)).mono (by decide +kernel) + · exact row_works_721_i2.mono (by decide +kernel) +theorem row_works_721_i1 : Template HasSnaky 8 required_721_i1 envelope_721_i1 := by + refine compose HasSnaky 7 childrenC_721_i1 childrenD_721_i1 children_work_721_i1 (2, 4) + required_721_i1 envelope_721_i1 pivot_mem_721_i1 child_required_sub_721_i1 child_envelope_sub_721_i1 ?_ + intro b hb + exact common_sub_721_i1 (mem_commonEnvelope childrenD_721_i1 b hb) +def required_721_i0 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_721_i0 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_721_i0 : Fin 3 → Finset Cell := ![(placed21 4 (5, 7) required_7), (placed21 5 (6, 3) required_8), required_721_i1] +def childrenD_721_i0 : Fin 3 → Finset Cell := ![(placed21 4 (5, 7) envelope_7), (placed21 5 (6, 3) envelope_8), envelope_721_i1] +theorem common_sub_721_i0 : commonEnvelope childrenD_721_i0 ⊆ insert (5, 6) required_721_i0 := by decide +kernel +theorem child_required_sub_721_i0 : ∀ j, childrenC_721_i0 j ⊆ insert (5, 6) required_721_i0 := by decide +kernel +theorem child_envelope_sub_721_i0 : ∀ j, childrenD_721_i0 j ⊆ envelope_721_i0 := by decide +kernel +theorem pivot_mem_721_i0 : (5, 6) ∈ envelope_721_i0 := by decide +kernel +theorem children_work_721_i0 : ∀ j, Template HasSnaky 8 (childrenC_721_i0 j) (childrenD_721_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_8 5 (6, 3)).mono (by decide +kernel) + · exact row_works_721_i1.mono (by decide +kernel) +theorem row_works_721_i0 : Template HasSnaky 9 required_721_i0 envelope_721_i0 := by + refine compose HasSnaky 8 childrenC_721_i0 childrenD_721_i0 children_work_721_i0 (5, 6) + required_721_i0 envelope_721_i0 pivot_mem_721_i0 child_required_sub_721_i0 child_envelope_sub_721_i0 ?_ + intro b hb + exact common_sub_721_i0 (mem_commonEnvelope childrenD_721_i0 b hb) +def required_721 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_721 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 5), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_721 : Fin 5 → Finset Cell := ![(placed21 2 (6, 1) required_14), (placed21 4 (2, 6) required_176), (placed21 0 (2, 2) required_216), (placed21 1 (2, 3) required_218), required_721_i0] +def childrenD_721 : Fin 5 → Finset Cell := ![(placed21 2 (6, 1) envelope_14), (placed21 4 (2, 6) envelope_176), (placed21 0 (2, 2) envelope_216), (placed21 1 (2, 3) envelope_218), envelope_721_i0] +theorem common_sub_721 : commonEnvelope childrenD_721 ⊆ insert (5, 4) required_721 := by decide +kernel +theorem child_required_sub_721 : ∀ j, childrenC_721 j ⊆ insert (5, 4) required_721 := by decide +kernel +theorem child_envelope_sub_721 : ∀ j, childrenD_721 j ⊆ envelope_721 := by decide +kernel +theorem pivot_mem_721 : (5, 4) ∈ envelope_721 := by decide +kernel +theorem children_work_721 : ∀ j, Template HasSnaky 9 (childrenC_721 j) (childrenD_721 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 2 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_176 4 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_216 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_218 1 (2, 3)).mono (by decide +kernel) + · exact row_works_721_i0.mono (by decide +kernel) +theorem row_works_721 : Template HasSnaky 10 required_721 envelope_721 := by + refine compose HasSnaky 9 childrenC_721 childrenD_721 children_work_721 (5, 4) + required_721 envelope_721 pivot_mem_721 child_required_sub_721 child_envelope_sub_721 ?_ + intro b hb + exact common_sub_721 (mem_commonEnvelope childrenD_721 b hb) +def height_652_i3 : ℕ := 4 +def childrenH_652_i3 : Fin 2 → ℕ := ![height_0, height_245] +theorem height_exact_652_i3 : height_652_i3 = 1 + Finset.univ.sup childrenH_652_i3 := by decide +kernel +theorem required_origin_652_i3 : ∀ x ∈ required_652_i3, + (∃ j, x ∈ childrenC_652_i3 j) ∨ ∀ j, x ∈ childrenD_652_i3 j := by decide +kernel +theorem required_exact_652_i3 : required_652_i3 = + ((Finset.univ.biUnion childrenC_652_i3) ∪ commonEnvelope childrenD_652_i3).erase (3, 5) := by + exact required_eq_combination childrenC_652_i3 childrenD_652_i3 (3, 5) required_652_i3 + (by decide +kernel) child_required_sub_652_i3 common_sub_652_i3 required_origin_652_i3 +theorem envelope_origin_652_i3 : ∀ x ∈ envelope_652_i3, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_652_i3 j := by decide +kernel +theorem envelope_exact_652_i3 : envelope_652_i3 = + insert (3, 5) (Finset.univ.biUnion childrenD_652_i3) := by + exact envelope_eq_combination childrenD_652_i3 (3, 5) envelope_652_i3 + pivot_mem_652_i3 child_envelope_sub_652_i3 envelope_origin_652_i3 +def checked_652_i3 : CheckedCard where + required := required_652_i3 + envelope := envelope_652_i3 + height := height_652_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_652_i3 +def height_652_i2 : ℕ := 5 +def childrenH_652_i2 : Fin 3 → ℕ := ![height_36, height_44, height_652_i3] +theorem height_exact_652_i2 : height_652_i2 = 1 + Finset.univ.sup childrenH_652_i2 := by decide +kernel +theorem required_origin_652_i2 : ∀ x ∈ required_652_i2, + (∃ j, x ∈ childrenC_652_i2 j) ∨ ∀ j, x ∈ childrenD_652_i2 j := by decide +kernel +theorem required_exact_652_i2 : required_652_i2 = + ((Finset.univ.biUnion childrenC_652_i2) ∪ commonEnvelope childrenD_652_i2).erase (4, 5) := by + exact required_eq_combination childrenC_652_i2 childrenD_652_i2 (4, 5) required_652_i2 + (by decide +kernel) child_required_sub_652_i2 common_sub_652_i2 required_origin_652_i2 +theorem envelope_origin_652_i2 : ∀ x ∈ envelope_652_i2, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_652_i2 j := by decide +kernel +theorem envelope_exact_652_i2 : envelope_652_i2 = + insert (4, 5) (Finset.univ.biUnion childrenD_652_i2) := by + exact envelope_eq_combination childrenD_652_i2 (4, 5) envelope_652_i2 + pivot_mem_652_i2 child_envelope_sub_652_i2 envelope_origin_652_i2 +def checked_652_i2 : CheckedCard where + required := required_652_i2 + envelope := envelope_652_i2 + height := height_652_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_652_i2 +def height_652_i1 : ℕ := 6 +def childrenH_652_i1 : Fin 2 → ℕ := ![height_222, height_652_i2] +theorem height_exact_652_i1 : height_652_i1 = 1 + Finset.univ.sup childrenH_652_i1 := by decide +kernel +theorem required_origin_652_i1 : ∀ x ∈ required_652_i1, + (∃ j, x ∈ childrenC_652_i1 j) ∨ ∀ j, x ∈ childrenD_652_i1 j := by decide +kernel +theorem required_exact_652_i1 : required_652_i1 = + ((Finset.univ.biUnion childrenC_652_i1) ∪ commonEnvelope childrenD_652_i1).erase (4, 4) := by + exact required_eq_combination childrenC_652_i1 childrenD_652_i1 (4, 4) required_652_i1 + (by decide +kernel) child_required_sub_652_i1 common_sub_652_i1 required_origin_652_i1 +theorem envelope_origin_652_i1 : ∀ x ∈ envelope_652_i1, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_652_i1 j := by decide +kernel +theorem envelope_exact_652_i1 : envelope_652_i1 = + insert (4, 4) (Finset.univ.biUnion childrenD_652_i1) := by + exact envelope_eq_combination childrenD_652_i1 (4, 4) envelope_652_i1 + pivot_mem_652_i1 child_envelope_sub_652_i1 envelope_origin_652_i1 +def checked_652_i1 : CheckedCard where + required := required_652_i1 + envelope := envelope_652_i1 + height := height_652_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_652_i1 +def height_652_i0 : ℕ := 9 +def childrenH_652_i0 : Fin 3 → ℕ := ![height_10, height_558, height_652_i1] +theorem height_exact_652_i0 : height_652_i0 = 1 + Finset.univ.sup childrenH_652_i0 := by decide +kernel +theorem required_origin_652_i0 : ∀ x ∈ required_652_i0, + (∃ j, x ∈ childrenC_652_i0 j) ∨ ∀ j, x ∈ childrenD_652_i0 j := by decide +kernel +theorem required_exact_652_i0 : required_652_i0 = + ((Finset.univ.biUnion childrenC_652_i0) ∪ commonEnvelope childrenD_652_i0).erase (2, 5) := by + exact required_eq_combination childrenC_652_i0 childrenD_652_i0 (2, 5) required_652_i0 + (by decide +kernel) child_required_sub_652_i0 common_sub_652_i0 required_origin_652_i0 +theorem envelope_origin_652_i0 : ∀ x ∈ envelope_652_i0, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_652_i0 j := by decide +kernel +theorem envelope_exact_652_i0 : envelope_652_i0 = + insert (2, 5) (Finset.univ.biUnion childrenD_652_i0) := by + exact envelope_eq_combination childrenD_652_i0 (2, 5) envelope_652_i0 + pivot_mem_652_i0 child_envelope_sub_652_i0 envelope_origin_652_i0 +def checked_652_i0 : CheckedCard where + required := required_652_i0 + envelope := envelope_652_i0 + height := height_652_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_652_i0 +def height_652 : ℕ := 10 +def childrenH_652 : Fin 2 → ℕ := ![height_0, height_652_i0] +theorem height_exact_652 : height_652 = 1 + Finset.univ.sup childrenH_652 := by decide +kernel +theorem required_origin_652 : ∀ x ∈ required_652, + (∃ j, x ∈ childrenC_652 j) ∨ ∀ j, x ∈ childrenD_652 j := by decide +kernel +theorem required_exact_652 : required_652 = + ((Finset.univ.biUnion childrenC_652) ∪ commonEnvelope childrenD_652).erase (4, 3) := by + exact required_eq_combination childrenC_652 childrenD_652 (4, 3) required_652 + (by decide +kernel) child_required_sub_652 common_sub_652 required_origin_652 +theorem envelope_origin_652 : ∀ x ∈ envelope_652, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_652 j := by decide +kernel +theorem envelope_exact_652 : envelope_652 = + insert (4, 3) (Finset.univ.biUnion childrenD_652) := by + exact envelope_eq_combination childrenD_652 (4, 3) envelope_652 + pivot_mem_652 child_envelope_sub_652 envelope_origin_652 +def checked_652 : CheckedCard where + required := required_652 + envelope := envelope_652 + height := height_652 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_652 +def height_674 : ℕ := 10 +def childrenH_674 : Fin 3 → ℕ := ![height_34, height_149, height_673] +theorem height_exact_674 : height_674 = 1 + Finset.univ.sup childrenH_674 := by decide +kernel +theorem required_origin_674 : ∀ x ∈ required_674, + (∃ j, x ∈ childrenC_674 j) ∨ ∀ j, x ∈ childrenD_674 j := by decide +kernel +theorem required_exact_674 : required_674 = + ((Finset.univ.biUnion childrenC_674) ∪ commonEnvelope childrenD_674).erase (2, 4) := by + exact required_eq_combination childrenC_674 childrenD_674 (2, 4) required_674 + (by decide +kernel) child_required_sub_674 common_sub_674 required_origin_674 +theorem envelope_origin_674 : ∀ x ∈ envelope_674, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_674 j := by decide +kernel +theorem envelope_exact_674 : envelope_674 = + insert (2, 4) (Finset.univ.biUnion childrenD_674) := by + exact envelope_eq_combination childrenD_674 (2, 4) envelope_674 + pivot_mem_674 child_envelope_sub_674 envelope_origin_674 +def checked_674 : CheckedCard where + required := required_674 + envelope := envelope_674 + height := height_674 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_674 +def height_702_i1 : ℕ := 3 +def childrenH_702_i1 : Fin 2 → ℕ := ![height_15, height_40] +theorem height_exact_702_i1 : height_702_i1 = 1 + Finset.univ.sup childrenH_702_i1 := by decide +kernel +theorem required_origin_702_i1 : ∀ x ∈ required_702_i1, + (∃ j, x ∈ childrenC_702_i1 j) ∨ ∀ j, x ∈ childrenD_702_i1 j := by decide +kernel +theorem required_exact_702_i1 : required_702_i1 = + ((Finset.univ.biUnion childrenC_702_i1) ∪ commonEnvelope childrenD_702_i1).erase (1, 1) := by + exact required_eq_combination childrenC_702_i1 childrenD_702_i1 (1, 1) required_702_i1 + (by decide +kernel) child_required_sub_702_i1 common_sub_702_i1 required_origin_702_i1 +theorem envelope_origin_702_i1 : ∀ x ∈ envelope_702_i1, + x = (1, 1) ∨ ∃ j, x ∈ childrenD_702_i1 j := by decide +kernel +theorem envelope_exact_702_i1 : envelope_702_i1 = + insert (1, 1) (Finset.univ.biUnion childrenD_702_i1) := by + exact envelope_eq_combination childrenD_702_i1 (1, 1) envelope_702_i1 + pivot_mem_702_i1 child_envelope_sub_702_i1 envelope_origin_702_i1 +def checked_702_i1 : CheckedCard where + required := required_702_i1 + envelope := envelope_702_i1 + height := height_702_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_702_i1 +def height_702_i0 : ℕ := 8 +def childrenH_702_i0 : Fin 4 → ℕ := ![height_30, height_108, height_702_i1, height_511] +theorem height_exact_702_i0 : height_702_i0 = 1 + Finset.univ.sup childrenH_702_i0 := by decide +kernel +theorem required_origin_702_i0 : ∀ x ∈ required_702_i0, + (∃ j, x ∈ childrenC_702_i0 j) ∨ ∀ j, x ∈ childrenD_702_i0 j := by decide +kernel +theorem required_exact_702_i0 : required_702_i0 = + ((Finset.univ.biUnion childrenC_702_i0) ∪ commonEnvelope childrenD_702_i0).erase (4, 2) := by + exact required_eq_combination childrenC_702_i0 childrenD_702_i0 (4, 2) required_702_i0 + (by decide +kernel) child_required_sub_702_i0 common_sub_702_i0 required_origin_702_i0 +theorem envelope_origin_702_i0 : ∀ x ∈ envelope_702_i0, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_702_i0 j := by decide +kernel +theorem envelope_exact_702_i0 : envelope_702_i0 = + insert (4, 2) (Finset.univ.biUnion childrenD_702_i0) := by + exact envelope_eq_combination childrenD_702_i0 (4, 2) envelope_702_i0 + pivot_mem_702_i0 child_envelope_sub_702_i0 envelope_origin_702_i0 +def checked_702_i0 : CheckedCard where + required := required_702_i0 + envelope := envelope_702_i0 + height := height_702_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_702_i0 +def height_702 : ℕ := 10 +def childrenH_702 : Fin 3 → ℕ := ![height_22, height_400, height_702_i0] +theorem height_exact_702 : height_702 = 1 + Finset.univ.sup childrenH_702 := by decide +kernel +theorem required_origin_702 : ∀ x ∈ required_702, + (∃ j, x ∈ childrenC_702 j) ∨ ∀ j, x ∈ childrenD_702 j := by decide +kernel +theorem required_exact_702 : required_702 = + ((Finset.univ.biUnion childrenC_702) ∪ commonEnvelope childrenD_702).erase (4, 3) := by + exact required_eq_combination childrenC_702 childrenD_702 (4, 3) required_702 + (by decide +kernel) child_required_sub_702 common_sub_702 required_origin_702 +theorem envelope_origin_702 : ∀ x ∈ envelope_702, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_702 j := by decide +kernel +theorem envelope_exact_702 : envelope_702 = + insert (4, 3) (Finset.univ.biUnion childrenD_702) := by + exact envelope_eq_combination childrenD_702 (4, 3) envelope_702 + pivot_mem_702 child_envelope_sub_702 envelope_origin_702 +def checked_702 : CheckedCard where + required := required_702 + envelope := envelope_702 + height := height_702 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_702 +def height_704_i1 : ℕ := 6 +def childrenH_704_i1 : Fin 3 → ℕ := ![height_28, height_58, height_306] +theorem height_exact_704_i1 : height_704_i1 = 1 + Finset.univ.sup childrenH_704_i1 := by decide +kernel +theorem required_origin_704_i1 : ∀ x ∈ required_704_i1, + (∃ j, x ∈ childrenC_704_i1 j) ∨ ∀ j, x ∈ childrenD_704_i1 j := by decide +kernel +theorem required_exact_704_i1 : required_704_i1 = + ((Finset.univ.biUnion childrenC_704_i1) ∪ commonEnvelope childrenD_704_i1).erase (4, 6) := by + exact required_eq_combination childrenC_704_i1 childrenD_704_i1 (4, 6) required_704_i1 + (by decide +kernel) child_required_sub_704_i1 common_sub_704_i1 required_origin_704_i1 +theorem envelope_origin_704_i1 : ∀ x ∈ envelope_704_i1, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_704_i1 j := by decide +kernel +theorem envelope_exact_704_i1 : envelope_704_i1 = + insert (4, 6) (Finset.univ.biUnion childrenD_704_i1) := by + exact envelope_eq_combination childrenD_704_i1 (4, 6) envelope_704_i1 + pivot_mem_704_i1 child_envelope_sub_704_i1 envelope_origin_704_i1 +def checked_704_i1 : CheckedCard where + required := required_704_i1 + envelope := envelope_704_i1 + height := height_704_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_704_i1 +def height_704_i3 : ℕ := 4 +def childrenH_704_i3 : Fin 2 → ℕ := ![height_2, height_52] +theorem height_exact_704_i3 : height_704_i3 = 1 + Finset.univ.sup childrenH_704_i3 := by decide +kernel +theorem required_origin_704_i3 : ∀ x ∈ required_704_i3, + (∃ j, x ∈ childrenC_704_i3 j) ∨ ∀ j, x ∈ childrenD_704_i3 j := by decide +kernel +theorem required_exact_704_i3 : required_704_i3 = + ((Finset.univ.biUnion childrenC_704_i3) ∪ commonEnvelope childrenD_704_i3).erase (5, 5) := by + exact required_eq_combination childrenC_704_i3 childrenD_704_i3 (5, 5) required_704_i3 + (by decide +kernel) child_required_sub_704_i3 common_sub_704_i3 required_origin_704_i3 +theorem envelope_origin_704_i3 : ∀ x ∈ envelope_704_i3, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_704_i3 j := by decide +kernel +theorem envelope_exact_704_i3 : envelope_704_i3 = + insert (5, 5) (Finset.univ.biUnion childrenD_704_i3) := by + exact envelope_eq_combination childrenD_704_i3 (5, 5) envelope_704_i3 + pivot_mem_704_i3 child_envelope_sub_704_i3 envelope_origin_704_i3 +def checked_704_i3 : CheckedCard where + required := required_704_i3 + envelope := envelope_704_i3 + height := height_704_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_704_i3 +def height_704_i4 : ℕ := 5 +def childrenH_704_i4 : Fin 2 → ℕ := ![height_2, height_10] +theorem height_exact_704_i4 : height_704_i4 = 1 + Finset.univ.sup childrenH_704_i4 := by decide +kernel +theorem required_origin_704_i4 : ∀ x ∈ required_704_i4, + (∃ j, x ∈ childrenC_704_i4 j) ∨ ∀ j, x ∈ childrenD_704_i4 j := by decide +kernel +theorem required_exact_704_i4 : required_704_i4 = + ((Finset.univ.biUnion childrenC_704_i4) ∪ commonEnvelope childrenD_704_i4).erase (5, 5) := by + exact required_eq_combination childrenC_704_i4 childrenD_704_i4 (5, 5) required_704_i4 + (by decide +kernel) child_required_sub_704_i4 common_sub_704_i4 required_origin_704_i4 +theorem envelope_origin_704_i4 : ∀ x ∈ envelope_704_i4, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_704_i4 j := by decide +kernel +theorem envelope_exact_704_i4 : envelope_704_i4 = + insert (5, 5) (Finset.univ.biUnion childrenD_704_i4) := by + exact envelope_eq_combination childrenD_704_i4 (5, 5) envelope_704_i4 + pivot_mem_704_i4 child_envelope_sub_704_i4 envelope_origin_704_i4 +def checked_704_i4 : CheckedCard where + required := required_704_i4 + envelope := envelope_704_i4 + height := height_704_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_704_i4 +def height_704_i5 : ℕ := 4 +def childrenH_704_i5 : Fin 2 → ℕ := ![height_25, height_78] +theorem height_exact_704_i5 : height_704_i5 = 1 + Finset.univ.sup childrenH_704_i5 := by decide +kernel +theorem required_origin_704_i5 : ∀ x ∈ required_704_i5, + (∃ j, x ∈ childrenC_704_i5 j) ∨ ∀ j, x ∈ childrenD_704_i5 j := by decide +kernel +theorem required_exact_704_i5 : required_704_i5 = + ((Finset.univ.biUnion childrenC_704_i5) ∪ commonEnvelope childrenD_704_i5).erase (4, 6) := by + exact required_eq_combination childrenC_704_i5 childrenD_704_i5 (4, 6) required_704_i5 + (by decide +kernel) child_required_sub_704_i5 common_sub_704_i5 required_origin_704_i5 +theorem envelope_origin_704_i5 : ∀ x ∈ envelope_704_i5, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_704_i5 j := by decide +kernel +theorem envelope_exact_704_i5 : envelope_704_i5 = + insert (4, 6) (Finset.univ.biUnion childrenD_704_i5) := by + exact envelope_eq_combination childrenD_704_i5 (4, 6) envelope_704_i5 + pivot_mem_704_i5 child_envelope_sub_704_i5 envelope_origin_704_i5 +def checked_704_i5 : CheckedCard where + required := required_704_i5 + envelope := envelope_704_i5 + height := height_704_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_704_i5 +def height_704_i2 : ℕ := 7 +def childrenH_704_i2 : Fin 4 → ℕ := ![height_516, height_704_i3, height_704_i4, height_704_i5] +theorem height_exact_704_i2 : height_704_i2 = 1 + Finset.univ.sup childrenH_704_i2 := by decide +kernel +theorem required_origin_704_i2 : ∀ x ∈ required_704_i2, + (∃ j, x ∈ childrenC_704_i2 j) ∨ ∀ j, x ∈ childrenD_704_i2 j := by decide +kernel +theorem required_exact_704_i2 : required_704_i2 = + ((Finset.univ.biUnion childrenC_704_i2) ∪ commonEnvelope childrenD_704_i2).erase (4, 3) := by + exact required_eq_combination childrenC_704_i2 childrenD_704_i2 (4, 3) required_704_i2 + (by decide +kernel) child_required_sub_704_i2 common_sub_704_i2 required_origin_704_i2 +theorem envelope_origin_704_i2 : ∀ x ∈ envelope_704_i2, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_704_i2 j := by decide +kernel +theorem envelope_exact_704_i2 : envelope_704_i2 = + insert (4, 3) (Finset.univ.biUnion childrenD_704_i2) := by + exact envelope_eq_combination childrenD_704_i2 (4, 3) envelope_704_i2 + pivot_mem_704_i2 child_envelope_sub_704_i2 envelope_origin_704_i2 +def checked_704_i2 : CheckedCard where + required := required_704_i2 + envelope := envelope_704_i2 + height := height_704_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_704_i2 +def height_704_i0 : ℕ := 9 +def childrenH_704_i0 : Fin 4 → ℕ := ![height_30, height_704_i1, height_703, height_704_i2] +theorem height_exact_704_i0 : height_704_i0 = 1 + Finset.univ.sup childrenH_704_i0 := by decide +kernel +theorem required_origin_704_i0 : ∀ x ∈ required_704_i0, + (∃ j, x ∈ childrenC_704_i0 j) ∨ ∀ j, x ∈ childrenD_704_i0 j := by decide +kernel +theorem required_exact_704_i0 : required_704_i0 = + ((Finset.univ.biUnion childrenC_704_i0) ∪ commonEnvelope childrenD_704_i0).erase (4, 5) := by + exact required_eq_combination childrenC_704_i0 childrenD_704_i0 (4, 5) required_704_i0 + (by decide +kernel) child_required_sub_704_i0 common_sub_704_i0 required_origin_704_i0 +theorem envelope_origin_704_i0 : ∀ x ∈ envelope_704_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_704_i0 j := by decide +kernel +theorem envelope_exact_704_i0 : envelope_704_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_704_i0) := by + exact envelope_eq_combination childrenD_704_i0 (4, 5) envelope_704_i0 + pivot_mem_704_i0 child_envelope_sub_704_i0 envelope_origin_704_i0 +def checked_704_i0 : CheckedCard where + required := required_704_i0 + envelope := envelope_704_i0 + height := height_704_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_704_i0 +def height_704 : ℕ := 10 +def childrenH_704 : Fin 3 → ℕ := ![height_22, height_400, height_704_i0] +theorem height_exact_704 : height_704 = 1 + Finset.univ.sup childrenH_704 := by decide +kernel +theorem required_origin_704 : ∀ x ∈ required_704, + (∃ j, x ∈ childrenC_704 j) ∨ ∀ j, x ∈ childrenD_704 j := by decide +kernel +theorem required_exact_704 : required_704 = + ((Finset.univ.biUnion childrenC_704) ∪ commonEnvelope childrenD_704).erase (4, 4) := by + exact required_eq_combination childrenC_704 childrenD_704 (4, 4) required_704 + (by decide +kernel) child_required_sub_704 common_sub_704 required_origin_704 +theorem envelope_origin_704 : ∀ x ∈ envelope_704, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_704 j := by decide +kernel +theorem envelope_exact_704 : envelope_704 = + insert (4, 4) (Finset.univ.biUnion childrenD_704) := by + exact envelope_eq_combination childrenD_704 (4, 4) envelope_704 + pivot_mem_704 child_envelope_sub_704 envelope_origin_704 +def checked_704 : CheckedCard where + required := required_704 + envelope := envelope_704 + height := height_704 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_704 +def height_721_i4 : ℕ := 5 +def childrenH_721_i4 : Fin 2 → ℕ := ![height_5, height_208] +theorem height_exact_721_i4 : height_721_i4 = 1 + Finset.univ.sup childrenH_721_i4 := by decide +kernel +theorem required_origin_721_i4 : ∀ x ∈ required_721_i4, + (∃ j, x ∈ childrenC_721_i4 j) ∨ ∀ j, x ∈ childrenD_721_i4 j := by decide +kernel +theorem required_exact_721_i4 : required_721_i4 = + ((Finset.univ.biUnion childrenC_721_i4) ∪ commonEnvelope childrenD_721_i4).erase (2, 6) := by + exact required_eq_combination childrenC_721_i4 childrenD_721_i4 (2, 6) required_721_i4 + (by decide +kernel) child_required_sub_721_i4 common_sub_721_i4 required_origin_721_i4 +theorem envelope_origin_721_i4 : ∀ x ∈ envelope_721_i4, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_721_i4 j := by decide +kernel +theorem envelope_exact_721_i4 : envelope_721_i4 = + insert (2, 6) (Finset.univ.biUnion childrenD_721_i4) := by + exact envelope_eq_combination childrenD_721_i4 (2, 6) envelope_721_i4 + pivot_mem_721_i4 child_envelope_sub_721_i4 envelope_origin_721_i4 +def checked_721_i4 : CheckedCard where + required := required_721_i4 + envelope := envelope_721_i4 + height := height_721_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_721_i4 +def height_721_i3 : ℕ := 6 +def childrenH_721_i3 : Fin 2 → ℕ := ![height_5, height_721_i4] +theorem height_exact_721_i3 : height_721_i3 = 1 + Finset.univ.sup childrenH_721_i3 := by decide +kernel +theorem required_origin_721_i3 : ∀ x ∈ required_721_i3, + (∃ j, x ∈ childrenC_721_i3 j) ∨ ∀ j, x ∈ childrenD_721_i3 j := by decide +kernel +theorem required_exact_721_i3 : required_721_i3 = + ((Finset.univ.biUnion childrenC_721_i3) ∪ commonEnvelope childrenD_721_i3).erase (4, 6) := by + exact required_eq_combination childrenC_721_i3 childrenD_721_i3 (4, 6) required_721_i3 + (by decide +kernel) child_required_sub_721_i3 common_sub_721_i3 required_origin_721_i3 +theorem envelope_origin_721_i3 : ∀ x ∈ envelope_721_i3, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_721_i3 j := by decide +kernel +theorem envelope_exact_721_i3 : envelope_721_i3 = + insert (4, 6) (Finset.univ.biUnion childrenD_721_i3) := by + exact envelope_eq_combination childrenD_721_i3 (4, 6) envelope_721_i3 + pivot_mem_721_i3 child_envelope_sub_721_i3 envelope_origin_721_i3 +def checked_721_i3 : CheckedCard where + required := required_721_i3 + envelope := envelope_721_i3 + height := height_721_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_721_i3 +def height_721_i2 : ℕ := 7 +def childrenH_721_i2 : Fin 2 → ℕ := ![height_22, height_721_i3] +theorem height_exact_721_i2 : height_721_i2 = 1 + Finset.univ.sup childrenH_721_i2 := by decide +kernel +theorem required_origin_721_i2 : ∀ x ∈ required_721_i2, + (∃ j, x ∈ childrenC_721_i2 j) ∨ ∀ j, x ∈ childrenD_721_i2 j := by decide +kernel +theorem required_exact_721_i2 : required_721_i2 = + ((Finset.univ.biUnion childrenC_721_i2) ∪ commonEnvelope childrenD_721_i2).erase (3, 6) := by + exact required_eq_combination childrenC_721_i2 childrenD_721_i2 (3, 6) required_721_i2 + (by decide +kernel) child_required_sub_721_i2 common_sub_721_i2 required_origin_721_i2 +theorem envelope_origin_721_i2 : ∀ x ∈ envelope_721_i2, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_721_i2 j := by decide +kernel +theorem envelope_exact_721_i2 : envelope_721_i2 = + insert (3, 6) (Finset.univ.biUnion childrenD_721_i2) := by + exact envelope_eq_combination childrenD_721_i2 (3, 6) envelope_721_i2 + pivot_mem_721_i2 child_envelope_sub_721_i2 envelope_origin_721_i2 +def checked_721_i2 : CheckedCard where + required := required_721_i2 + envelope := envelope_721_i2 + height := height_721_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_721_i2 +def height_721_i1 : ℕ := 8 +def childrenH_721_i1 : Fin 2 → ℕ := ![height_25, height_721_i2] +theorem height_exact_721_i1 : height_721_i1 = 1 + Finset.univ.sup childrenH_721_i1 := by decide +kernel +theorem required_origin_721_i1 : ∀ x ∈ required_721_i1, + (∃ j, x ∈ childrenC_721_i1 j) ∨ ∀ j, x ∈ childrenD_721_i1 j := by decide +kernel +theorem required_exact_721_i1 : required_721_i1 = + ((Finset.univ.biUnion childrenC_721_i1) ∪ commonEnvelope childrenD_721_i1).erase (2, 4) := by + exact required_eq_combination childrenC_721_i1 childrenD_721_i1 (2, 4) required_721_i1 + (by decide +kernel) child_required_sub_721_i1 common_sub_721_i1 required_origin_721_i1 +theorem envelope_origin_721_i1 : ∀ x ∈ envelope_721_i1, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_721_i1 j := by decide +kernel +theorem envelope_exact_721_i1 : envelope_721_i1 = + insert (2, 4) (Finset.univ.biUnion childrenD_721_i1) := by + exact envelope_eq_combination childrenD_721_i1 (2, 4) envelope_721_i1 + pivot_mem_721_i1 child_envelope_sub_721_i1 envelope_origin_721_i1 +def checked_721_i1 : CheckedCard where + required := required_721_i1 + envelope := envelope_721_i1 + height := height_721_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_721_i1 +def height_721_i0 : ℕ := 9 +def childrenH_721_i0 : Fin 3 → ℕ := ![height_7, height_8, height_721_i1] +theorem height_exact_721_i0 : height_721_i0 = 1 + Finset.univ.sup childrenH_721_i0 := by decide +kernel +theorem required_origin_721_i0 : ∀ x ∈ required_721_i0, + (∃ j, x ∈ childrenC_721_i0 j) ∨ ∀ j, x ∈ childrenD_721_i0 j := by decide +kernel +theorem required_exact_721_i0 : required_721_i0 = + ((Finset.univ.biUnion childrenC_721_i0) ∪ commonEnvelope childrenD_721_i0).erase (5, 6) := by + exact required_eq_combination childrenC_721_i0 childrenD_721_i0 (5, 6) required_721_i0 + (by decide +kernel) child_required_sub_721_i0 common_sub_721_i0 required_origin_721_i0 +theorem envelope_origin_721_i0 : ∀ x ∈ envelope_721_i0, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_721_i0 j := by decide +kernel +theorem envelope_exact_721_i0 : envelope_721_i0 = + insert (5, 6) (Finset.univ.biUnion childrenD_721_i0) := by + exact envelope_eq_combination childrenD_721_i0 (5, 6) envelope_721_i0 + pivot_mem_721_i0 child_envelope_sub_721_i0 envelope_origin_721_i0 +def checked_721_i0 : CheckedCard where + required := required_721_i0 + envelope := envelope_721_i0 + height := height_721_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_721_i0 +def height_721 : ℕ := 10 +def childrenH_721 : Fin 5 → ℕ := ![height_14, height_176, height_216, height_218, height_721_i0] +theorem height_exact_721 : height_721 = 1 + Finset.univ.sup childrenH_721 := by decide +kernel +theorem required_origin_721 : ∀ x ∈ required_721, + (∃ j, x ∈ childrenC_721 j) ∨ ∀ j, x ∈ childrenD_721 j := by decide +kernel +theorem required_exact_721 : required_721 = + ((Finset.univ.biUnion childrenC_721) ∪ commonEnvelope childrenD_721).erase (5, 4) := by + exact required_eq_combination childrenC_721 childrenD_721 (5, 4) required_721 + (by decide +kernel) child_required_sub_721 common_sub_721 required_origin_721 +theorem envelope_origin_721 : ∀ x ∈ envelope_721, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_721 j := by decide +kernel +theorem envelope_exact_721 : envelope_721 = + insert (5, 4) (Finset.univ.biUnion childrenD_721) := by + exact envelope_eq_combination childrenD_721 (5, 4) envelope_721 + pivot_mem_721 child_envelope_sub_721 envelope_origin_721 +def checked_721 : CheckedCard where + required := required_721 + envelope := envelope_721 + height := height_721 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_721 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part07.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part07.lean new file mode 100644 index 0000000..d8c5ad2 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part07.lean @@ -0,0 +1,271 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_722_i1 : Finset Cell := ⟨(([(2, 4), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_722_i1 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_722_i1 : Fin 2 → Finset Cell := ![(placed21 0 (3, 3) required_17), (placed21 7 (5, 6) required_32)] +def childrenD_722_i1 : Fin 2 → Finset Cell := ![(placed21 0 (3, 3) envelope_17), (placed21 7 (5, 6) envelope_32)] +theorem common_sub_722_i1 : commonEnvelope childrenD_722_i1 ⊆ insert (3, 4) required_722_i1 := by decide +kernel +theorem child_required_sub_722_i1 : ∀ j, childrenC_722_i1 j ⊆ insert (3, 4) required_722_i1 := by decide +kernel +theorem child_envelope_sub_722_i1 : ∀ j, childrenD_722_i1 j ⊆ envelope_722_i1 := by decide +kernel +theorem pivot_mem_722_i1 : (3, 4) ∈ envelope_722_i1 := by decide +kernel +theorem children_work_722_i1 : ∀ j, Template HasSnaky 4 (childrenC_722_i1 j) (childrenD_722_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_17 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_32 7 (5, 6)).mono (by decide +kernel) +theorem row_works_722_i1 : Template HasSnaky 5 required_722_i1 envelope_722_i1 := by + refine compose HasSnaky 4 childrenC_722_i1 childrenD_722_i1 children_work_722_i1 (3, 4) + required_722_i1 envelope_722_i1 pivot_mem_722_i1 child_required_sub_722_i1 child_envelope_sub_722_i1 ?_ + intro b hb + exact common_sub_722_i1 (mem_commonEnvelope childrenD_722_i1 b hb) +def required_722_i0 : Finset Cell := ⟨(([(2, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_722_i0 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_722_i0 : Fin 4 → Finset Cell := ![(placed21 5 (5, 3) required_8), (placed21 4 (3, 7) required_9), (placed21 6 (5, 8) required_366), required_722_i1] +def childrenD_722_i0 : Fin 4 → Finset Cell := ![(placed21 5 (5, 3) envelope_8), (placed21 4 (3, 7) envelope_9), (placed21 6 (5, 8) envelope_366), envelope_722_i1] +theorem common_sub_722_i0 : commonEnvelope childrenD_722_i0 ⊆ insert (4, 6) required_722_i0 := by decide +kernel +theorem child_required_sub_722_i0 : ∀ j, childrenC_722_i0 j ⊆ insert (4, 6) required_722_i0 := by decide +kernel +theorem child_envelope_sub_722_i0 : ∀ j, childrenD_722_i0 j ⊆ envelope_722_i0 := by decide +kernel +theorem pivot_mem_722_i0 : (4, 6) ∈ envelope_722_i0 := by decide +kernel +theorem children_work_722_i0 : ∀ j, Template HasSnaky 5 (childrenC_722_i0 j) (childrenD_722_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 5 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_366 6 (5, 8)).mono (by decide +kernel) + · exact row_works_722_i1.mono (by decide +kernel) +theorem row_works_722_i0 : Template HasSnaky 6 required_722_i0 envelope_722_i0 := by + refine compose HasSnaky 5 childrenC_722_i0 childrenD_722_i0 children_work_722_i0 (4, 6) + required_722_i0 envelope_722_i0 pivot_mem_722_i0 child_required_sub_722_i0 child_envelope_sub_722_i0 ?_ + intro b hb + exact common_sub_722_i0 (mem_commonEnvelope childrenD_722_i0 b hb) +def required_722_i2 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_722_i2 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_722_i2 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) required_2), (placed21 1 (2, 2) required_345)] +def childrenD_722_i2 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) envelope_2), (placed21 1 (2, 2) envelope_345)] +theorem common_sub_722_i2 : commonEnvelope childrenD_722_i2 ⊆ insert (5, 4) required_722_i2 := by decide +kernel +theorem child_required_sub_722_i2 : ∀ j, childrenC_722_i2 j ⊆ insert (5, 4) required_722_i2 := by decide +kernel +theorem child_envelope_sub_722_i2 : ∀ j, childrenD_722_i2 j ⊆ envelope_722_i2 := by decide +kernel +theorem pivot_mem_722_i2 : (5, 4) ∈ envelope_722_i2 := by decide +kernel +theorem children_work_722_i2 : ∀ j, Template HasSnaky 8 (childrenC_722_i2 j) (childrenD_722_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 6 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_345 1 (2, 2)).mono (by decide +kernel) +theorem row_works_722_i2 : Template HasSnaky 9 required_722_i2 envelope_722_i2 := by + refine compose HasSnaky 8 childrenC_722_i2 childrenD_722_i2 children_work_722_i2 (5, 4) + required_722_i2 envelope_722_i2 pivot_mem_722_i2 child_required_sub_722_i2 child_envelope_sub_722_i2 ?_ + intro b hb + exact common_sub_722_i2 (mem_commonEnvelope childrenD_722_i2 b hb) +def required_722_i3 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_722_i3 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_722_i3 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) required_0), (placed21 2 (5, 2) required_307)] +def childrenD_722_i3 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) envelope_0), (placed21 2 (5, 2) envelope_307)] +theorem common_sub_722_i3 : commonEnvelope childrenD_722_i3 ⊆ insert (3, 4) required_722_i3 := by decide +kernel +theorem child_required_sub_722_i3 : ∀ j, childrenC_722_i3 j ⊆ insert (3, 4) required_722_i3 := by decide +kernel +theorem child_envelope_sub_722_i3 : ∀ j, childrenD_722_i3 j ⊆ envelope_722_i3 := by decide +kernel +theorem pivot_mem_722_i3 : (3, 4) ∈ envelope_722_i3 := by decide +kernel +theorem children_work_722_i3 : ∀ j, Template HasSnaky 4 (childrenC_722_i3 j) (childrenD_722_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_307 2 (5, 2)).mono (by decide +kernel) +theorem row_works_722_i3 : Template HasSnaky 5 required_722_i3 envelope_722_i3 := by + refine compose HasSnaky 4 childrenC_722_i3 childrenD_722_i3 children_work_722_i3 (3, 4) + required_722_i3 envelope_722_i3 pivot_mem_722_i3 child_required_sub_722_i3 child_envelope_sub_722_i3 ?_ + intro b hb + exact common_sub_722_i3 (mem_commonEnvelope childrenD_722_i3 b hb) +def required_722_i4 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_722_i4 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 6), (5, 7), (5, 8), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_722_i4 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) required_0), (placed21 0 (2, 1) required_267)] +def childrenD_722_i4 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) envelope_0), (placed21 0 (2, 1) envelope_267)] +theorem common_sub_722_i4 : commonEnvelope childrenD_722_i4 ⊆ insert (3, 4) required_722_i4 := by decide +kernel +theorem child_required_sub_722_i4 : ∀ j, childrenC_722_i4 j ⊆ insert (3, 4) required_722_i4 := by decide +kernel +theorem child_envelope_sub_722_i4 : ∀ j, childrenD_722_i4 j ⊆ envelope_722_i4 := by decide +kernel +theorem pivot_mem_722_i4 : (3, 4) ∈ envelope_722_i4 := by decide +kernel +theorem children_work_722_i4 : ∀ j, Template HasSnaky 6 (childrenC_722_i4 j) (childrenD_722_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_267 0 (2, 1)).mono (by decide +kernel) +theorem row_works_722_i4 : Template HasSnaky 7 required_722_i4 envelope_722_i4 := by + refine compose HasSnaky 6 childrenC_722_i4 childrenD_722_i4 children_work_722_i4 (3, 4) + required_722_i4 envelope_722_i4 pivot_mem_722_i4 child_required_sub_722_i4 child_envelope_sub_722_i4 ?_ + intro b hb + exact common_sub_722_i4 (mem_commonEnvelope childrenD_722_i4 b hb) +def required_722 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_722 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_722 : Fin 6 → Finset Cell := ![(placed21 2 (5, 1) required_13), (placed21 4 (1, 6) required_176), required_722_i0, required_722_i2, required_722_i3, required_722_i4] +def childrenD_722 : Fin 6 → Finset Cell := ![(placed21 2 (5, 1) envelope_13), (placed21 4 (1, 6) envelope_176), envelope_722_i0, envelope_722_i2, envelope_722_i3, envelope_722_i4] +theorem common_sub_722 : commonEnvelope childrenD_722 ⊆ insert (4, 4) required_722 := by decide +kernel +theorem child_required_sub_722 : ∀ j, childrenC_722 j ⊆ insert (4, 4) required_722 := by decide +kernel +theorem child_envelope_sub_722 : ∀ j, childrenD_722 j ⊆ envelope_722 := by decide +kernel +theorem pivot_mem_722 : (4, 4) ∈ envelope_722 := by decide +kernel +theorem children_work_722 : ∀ j, Template HasSnaky 9 (childrenC_722 j) (childrenD_722 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 2 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_176 4 (1, 6)).mono (by decide +kernel) + · exact row_works_722_i0.mono (by decide +kernel) + · exact row_works_722_i2.mono (by decide +kernel) + · exact row_works_722_i3.mono (by decide +kernel) + · exact row_works_722_i4.mono (by decide +kernel) +theorem row_works_722 : Template HasSnaky 10 required_722 envelope_722 := by + refine compose HasSnaky 9 childrenC_722 childrenD_722 children_work_722 (4, 4) + required_722 envelope_722 pivot_mem_722 child_required_sub_722 child_envelope_sub_722 ?_ + intro b hb + exact common_sub_722 (mem_commonEnvelope childrenD_722 b hb) +def height_722_i1 : ℕ := 5 +def childrenH_722_i1 : Fin 2 → ℕ := ![height_17, height_32] +theorem height_exact_722_i1 : height_722_i1 = 1 + Finset.univ.sup childrenH_722_i1 := by decide +kernel +theorem required_origin_722_i1 : ∀ x ∈ required_722_i1, + (∃ j, x ∈ childrenC_722_i1 j) ∨ ∀ j, x ∈ childrenD_722_i1 j := by decide +kernel +theorem required_exact_722_i1 : required_722_i1 = + ((Finset.univ.biUnion childrenC_722_i1) ∪ commonEnvelope childrenD_722_i1).erase (3, 4) := by + exact required_eq_combination childrenC_722_i1 childrenD_722_i1 (3, 4) required_722_i1 + (by decide +kernel) child_required_sub_722_i1 common_sub_722_i1 required_origin_722_i1 +theorem envelope_origin_722_i1 : ∀ x ∈ envelope_722_i1, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_722_i1 j := by decide +kernel +theorem envelope_exact_722_i1 : envelope_722_i1 = + insert (3, 4) (Finset.univ.biUnion childrenD_722_i1) := by + exact envelope_eq_combination childrenD_722_i1 (3, 4) envelope_722_i1 + pivot_mem_722_i1 child_envelope_sub_722_i1 envelope_origin_722_i1 +def checked_722_i1 : CheckedCard where + required := required_722_i1 + envelope := envelope_722_i1 + height := height_722_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_722_i1 +def height_722_i0 : ℕ := 6 +def childrenH_722_i0 : Fin 4 → ℕ := ![height_8, height_9, height_366, height_722_i1] +theorem height_exact_722_i0 : height_722_i0 = 1 + Finset.univ.sup childrenH_722_i0 := by decide +kernel +theorem required_origin_722_i0 : ∀ x ∈ required_722_i0, + (∃ j, x ∈ childrenC_722_i0 j) ∨ ∀ j, x ∈ childrenD_722_i0 j := by decide +kernel +theorem required_exact_722_i0 : required_722_i0 = + ((Finset.univ.biUnion childrenC_722_i0) ∪ commonEnvelope childrenD_722_i0).erase (4, 6) := by + exact required_eq_combination childrenC_722_i0 childrenD_722_i0 (4, 6) required_722_i0 + (by decide +kernel) child_required_sub_722_i0 common_sub_722_i0 required_origin_722_i0 +theorem envelope_origin_722_i0 : ∀ x ∈ envelope_722_i0, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_722_i0 j := by decide +kernel +theorem envelope_exact_722_i0 : envelope_722_i0 = + insert (4, 6) (Finset.univ.biUnion childrenD_722_i0) := by + exact envelope_eq_combination childrenD_722_i0 (4, 6) envelope_722_i0 + pivot_mem_722_i0 child_envelope_sub_722_i0 envelope_origin_722_i0 +def checked_722_i0 : CheckedCard where + required := required_722_i0 + envelope := envelope_722_i0 + height := height_722_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_722_i0 +def height_722_i2 : ℕ := 9 +def childrenH_722_i2 : Fin 2 → ℕ := ![height_2, height_345] +theorem height_exact_722_i2 : height_722_i2 = 1 + Finset.univ.sup childrenH_722_i2 := by decide +kernel +theorem required_origin_722_i2 : ∀ x ∈ required_722_i2, + (∃ j, x ∈ childrenC_722_i2 j) ∨ ∀ j, x ∈ childrenD_722_i2 j := by decide +kernel +theorem required_exact_722_i2 : required_722_i2 = + ((Finset.univ.biUnion childrenC_722_i2) ∪ commonEnvelope childrenD_722_i2).erase (5, 4) := by + exact required_eq_combination childrenC_722_i2 childrenD_722_i2 (5, 4) required_722_i2 + (by decide +kernel) child_required_sub_722_i2 common_sub_722_i2 required_origin_722_i2 +theorem envelope_origin_722_i2 : ∀ x ∈ envelope_722_i2, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_722_i2 j := by decide +kernel +theorem envelope_exact_722_i2 : envelope_722_i2 = + insert (5, 4) (Finset.univ.biUnion childrenD_722_i2) := by + exact envelope_eq_combination childrenD_722_i2 (5, 4) envelope_722_i2 + pivot_mem_722_i2 child_envelope_sub_722_i2 envelope_origin_722_i2 +def checked_722_i2 : CheckedCard where + required := required_722_i2 + envelope := envelope_722_i2 + height := height_722_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_722_i2 +def height_722_i3 : ℕ := 5 +def childrenH_722_i3 : Fin 2 → ℕ := ![height_0, height_307] +theorem height_exact_722_i3 : height_722_i3 = 1 + Finset.univ.sup childrenH_722_i3 := by decide +kernel +theorem required_origin_722_i3 : ∀ x ∈ required_722_i3, + (∃ j, x ∈ childrenC_722_i3 j) ∨ ∀ j, x ∈ childrenD_722_i3 j := by decide +kernel +theorem required_exact_722_i3 : required_722_i3 = + ((Finset.univ.biUnion childrenC_722_i3) ∪ commonEnvelope childrenD_722_i3).erase (3, 4) := by + exact required_eq_combination childrenC_722_i3 childrenD_722_i3 (3, 4) required_722_i3 + (by decide +kernel) child_required_sub_722_i3 common_sub_722_i3 required_origin_722_i3 +theorem envelope_origin_722_i3 : ∀ x ∈ envelope_722_i3, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_722_i3 j := by decide +kernel +theorem envelope_exact_722_i3 : envelope_722_i3 = + insert (3, 4) (Finset.univ.biUnion childrenD_722_i3) := by + exact envelope_eq_combination childrenD_722_i3 (3, 4) envelope_722_i3 + pivot_mem_722_i3 child_envelope_sub_722_i3 envelope_origin_722_i3 +def checked_722_i3 : CheckedCard where + required := required_722_i3 + envelope := envelope_722_i3 + height := height_722_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_722_i3 +def height_722_i4 : ℕ := 7 +def childrenH_722_i4 : Fin 2 → ℕ := ![height_0, height_267] +theorem height_exact_722_i4 : height_722_i4 = 1 + Finset.univ.sup childrenH_722_i4 := by decide +kernel +theorem required_origin_722_i4 : ∀ x ∈ required_722_i4, + (∃ j, x ∈ childrenC_722_i4 j) ∨ ∀ j, x ∈ childrenD_722_i4 j := by decide +kernel +theorem required_exact_722_i4 : required_722_i4 = + ((Finset.univ.biUnion childrenC_722_i4) ∪ commonEnvelope childrenD_722_i4).erase (3, 4) := by + exact required_eq_combination childrenC_722_i4 childrenD_722_i4 (3, 4) required_722_i4 + (by decide +kernel) child_required_sub_722_i4 common_sub_722_i4 required_origin_722_i4 +theorem envelope_origin_722_i4 : ∀ x ∈ envelope_722_i4, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_722_i4 j := by decide +kernel +theorem envelope_exact_722_i4 : envelope_722_i4 = + insert (3, 4) (Finset.univ.biUnion childrenD_722_i4) := by + exact envelope_eq_combination childrenD_722_i4 (3, 4) envelope_722_i4 + pivot_mem_722_i4 child_envelope_sub_722_i4 envelope_origin_722_i4 +def checked_722_i4 : CheckedCard where + required := required_722_i4 + envelope := envelope_722_i4 + height := height_722_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_722_i4 +def height_722 : ℕ := 10 +def childrenH_722 : Fin 6 → ℕ := ![height_13, height_176, height_722_i0, height_722_i2, height_722_i3, height_722_i4] +theorem height_exact_722 : height_722 = 1 + Finset.univ.sup childrenH_722 := by decide +kernel +theorem required_origin_722 : ∀ x ∈ required_722, + (∃ j, x ∈ childrenC_722 j) ∨ ∀ j, x ∈ childrenD_722 j := by decide +kernel +theorem required_exact_722 : required_722 = + ((Finset.univ.biUnion childrenC_722) ∪ commonEnvelope childrenD_722).erase (4, 4) := by + exact required_eq_combination childrenC_722 childrenD_722 (4, 4) required_722 + (by decide +kernel) child_required_sub_722 common_sub_722 required_origin_722 +theorem envelope_origin_722 : ∀ x ∈ envelope_722, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_722 j := by decide +kernel +theorem envelope_exact_722 : envelope_722 = + insert (4, 4) (Finset.univ.biUnion childrenD_722) := by + exact envelope_eq_combination childrenD_722 (4, 4) envelope_722 + pivot_mem_722 child_envelope_sub_722 envelope_origin_722 +def checked_722 : CheckedCard where + required := required_722 + envelope := envelope_722 + height := height_722 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_722 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part01.lean new file mode 100644 index 0000000..aa1c4e0 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part01.lean @@ -0,0 +1,823 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_427_i6 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (2, 1), (2, 4), (3, 1), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427_i6 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427_i6 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_70), (placed21 0 (1, 0) required_226)] +def childrenD_427_i6 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_70), (placed21 0 (1, 0) envelope_226)] +theorem common_sub_427_i6 : commonEnvelope childrenD_427_i6 ⊆ insert (4, 3) required_427_i6 := by decide +kernel +theorem child_required_sub_427_i6 : ∀ j, childrenC_427_i6 j ⊆ insert (4, 3) required_427_i6 := by decide +kernel +theorem child_envelope_sub_427_i6 : ∀ j, childrenD_427_i6 j ⊆ envelope_427_i6 := by decide +kernel +theorem pivot_mem_427_i6 : (4, 3) ∈ envelope_427_i6 := by decide +kernel +theorem children_work_427_i6 : ∀ j, Template HasSnaky 3 (childrenC_427_i6 j) (childrenD_427_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_70 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_226 0 (1, 0)).mono (by decide +kernel) +theorem row_works_427_i6 : Template HasSnaky 4 required_427_i6 envelope_427_i6 := by + refine compose HasSnaky 3 childrenC_427_i6 childrenD_427_i6 children_work_427_i6 (4, 3) + required_427_i6 envelope_427_i6 pivot_mem_427_i6 child_required_sub_427_i6 child_envelope_sub_427_i6 ?_ + intro b hb + exact common_sub_427_i6 (mem_commonEnvelope childrenD_427_i6 b hb) +def required_427_i5 : Finset Cell := ⟨(([(0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 4), (3, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427_i5 : Finset Cell := ⟨(([(0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427_i5 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) required_5), required_427_i6] +def childrenD_427_i5 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) envelope_5), envelope_427_i6] +theorem common_sub_427_i5 : commonEnvelope childrenD_427_i5 ⊆ insert (4, 1) required_427_i5 := by decide +kernel +theorem child_required_sub_427_i5 : ∀ j, childrenC_427_i5 j ⊆ insert (4, 1) required_427_i5 := by decide +kernel +theorem child_envelope_sub_427_i5 : ∀ j, childrenD_427_i5 j ⊆ envelope_427_i5 := by decide +kernel +theorem pivot_mem_427_i5 : (4, 1) ∈ envelope_427_i5 := by decide +kernel +theorem children_work_427_i5 : ∀ j, Template HasSnaky 4 (childrenC_427_i5 j) (childrenD_427_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 1)).mono (by decide +kernel) + · exact row_works_427_i6.mono (by decide +kernel) +theorem row_works_427_i5 : Template HasSnaky 5 required_427_i5 envelope_427_i5 := by + refine compose HasSnaky 4 childrenC_427_i5 childrenD_427_i5 children_work_427_i5 (4, 1) + required_427_i5 envelope_427_i5 pivot_mem_427_i5 child_required_sub_427_i5 child_envelope_sub_427_i5 ?_ + intro b hb + exact common_sub_427_i5 (mem_commonEnvelope childrenD_427_i5 b hb) +def required_427_i4 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 4), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427_i4 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427_i4 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_4), required_427_i5] +def childrenD_427_i4 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_4), envelope_427_i5] +theorem common_sub_427_i4 : commonEnvelope childrenD_427_i4 ⊆ insert (4, 2) required_427_i4 := by decide +kernel +theorem child_required_sub_427_i4 : ∀ j, childrenC_427_i4 j ⊆ insert (4, 2) required_427_i4 := by decide +kernel +theorem child_envelope_sub_427_i4 : ∀ j, childrenD_427_i4 j ⊆ envelope_427_i4 := by decide +kernel +theorem pivot_mem_427_i4 : (4, 2) ∈ envelope_427_i4 := by decide +kernel +theorem children_work_427_i4 : ∀ j, Template HasSnaky 5 (childrenC_427_i4 j) (childrenD_427_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 0 (0, 1)).mono (by decide +kernel) + · exact row_works_427_i5.mono (by decide +kernel) +theorem row_works_427_i4 : Template HasSnaky 6 required_427_i4 envelope_427_i4 := by + refine compose HasSnaky 5 childrenC_427_i4 childrenD_427_i4 children_work_427_i4 (4, 2) + required_427_i4 envelope_427_i4 pivot_mem_427_i4 child_required_sub_427_i4 child_envelope_sub_427_i4 ?_ + intro b hb + exact common_sub_427_i4 (mem_commonEnvelope childrenD_427_i4 b hb) +def required_427_i9 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (3, 0), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427_i9 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427_i9 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) required_0), (placed21 5 (3, 0) required_2)] +def childrenD_427_i9 : Fin 2 → Finset Cell := ![(placed21 2 (4, 3) envelope_0), (placed21 5 (3, 0) envelope_2)] +theorem common_sub_427_i9 : commonEnvelope childrenD_427_i9 ⊆ insert (3, 3) required_427_i9 := by decide +kernel +theorem child_required_sub_427_i9 : ∀ j, childrenC_427_i9 j ⊆ insert (3, 3) required_427_i9 := by decide +kernel +theorem child_envelope_sub_427_i9 : ∀ j, childrenD_427_i9 j ⊆ envelope_427_i9 := by decide +kernel +theorem pivot_mem_427_i9 : (3, 3) ∈ envelope_427_i9 := by decide +kernel +theorem children_work_427_i9 : ∀ j, Template HasSnaky 1 (childrenC_427_i9 j) (childrenD_427_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 2 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_2 5 (3, 0)).mono (by decide +kernel) +theorem row_works_427_i9 : Template HasSnaky 2 required_427_i9 envelope_427_i9 := by + refine compose HasSnaky 1 childrenC_427_i9 childrenD_427_i9 children_work_427_i9 (3, 3) + required_427_i9 envelope_427_i9 pivot_mem_427_i9 child_required_sub_427_i9 child_envelope_sub_427_i9 ?_ + intro b hb + exact common_sub_427_i9 (mem_commonEnvelope childrenD_427_i9 b hb) +def required_427_i8 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 1), (2, 4), (3, 0), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427_i8 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427_i8 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) required_2), required_427_i9] +def childrenD_427_i8 : Fin 2 → Finset Cell := ![(placed21 3 (2, 4) envelope_2), envelope_427_i9] +theorem common_sub_427_i8 : commonEnvelope childrenD_427_i8 ⊆ insert (2, 3) required_427_i8 := by decide +kernel +theorem child_required_sub_427_i8 : ∀ j, childrenC_427_i8 j ⊆ insert (2, 3) required_427_i8 := by decide +kernel +theorem child_envelope_sub_427_i8 : ∀ j, childrenD_427_i8 j ⊆ envelope_427_i8 := by decide +kernel +theorem pivot_mem_427_i8 : (2, 3) ∈ envelope_427_i8 := by decide +kernel +theorem children_work_427_i8 : ∀ j, Template HasSnaky 2 (childrenC_427_i8 j) (childrenD_427_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 3 (2, 4)).mono (by decide +kernel) + · exact row_works_427_i9.mono (by decide +kernel) +theorem row_works_427_i8 : Template HasSnaky 3 required_427_i8 envelope_427_i8 := by + refine compose HasSnaky 2 childrenC_427_i8 childrenD_427_i8 children_work_427_i8 (2, 3) + required_427_i8 envelope_427_i8 pivot_mem_427_i8 child_required_sub_427_i8 child_envelope_sub_427_i8 ?_ + intro b hb + exact common_sub_427_i8 (mem_commonEnvelope childrenD_427_i8 b hb) +def required_427_i7 : Finset Cell := ⟨(([(0, 4), (1, 1), (1, 3), (1, 4), (2, 1), (2, 4), (3, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427_i7 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 3), (5, 0), (6, 0)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427_i7 : Fin 2 → Finset Cell := ![(placed21 3 (0, 1) required_52), required_427_i8] +def childrenD_427_i7 : Fin 2 → Finset Cell := ![(placed21 3 (0, 1) envelope_52), envelope_427_i8] +theorem common_sub_427_i7 : commonEnvelope childrenD_427_i7 ⊆ insert (3, 0) required_427_i7 := by decide +kernel +theorem child_required_sub_427_i7 : ∀ j, childrenC_427_i7 j ⊆ insert (3, 0) required_427_i7 := by decide +kernel +theorem child_envelope_sub_427_i7 : ∀ j, childrenD_427_i7 j ⊆ envelope_427_i7 := by decide +kernel +theorem pivot_mem_427_i7 : (3, 0) ∈ envelope_427_i7 := by decide +kernel +theorem children_work_427_i7 : ∀ j, Template HasSnaky 3 (childrenC_427_i7 j) (childrenD_427_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 3 (0, 1)).mono (by decide +kernel) + · exact row_works_427_i8.mono (by decide +kernel) +theorem row_works_427_i7 : Template HasSnaky 4 required_427_i7 envelope_427_i7 := by + refine compose HasSnaky 3 childrenC_427_i7 childrenD_427_i7 children_work_427_i7 (3, 0) + required_427_i7 envelope_427_i7 pivot_mem_427_i7 child_required_sub_427_i7 child_envelope_sub_427_i7 ?_ + intro b hb + exact common_sub_427_i7 (mem_commonEnvelope childrenD_427_i7 b hb) +def required_427_i3 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427_i3 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (6, 0), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427_i3 : Fin 4 → Finset Cell := ![(placed21 3 (0, 2) required_17), (placed21 3 (0, 4) required_357), required_427_i4, required_427_i7] +def childrenD_427_i3 : Fin 4 → Finset Cell := ![(placed21 3 (0, 2) envelope_17), (placed21 3 (0, 4) envelope_357), envelope_427_i4, envelope_427_i7] +theorem common_sub_427_i3 : commonEnvelope childrenD_427_i3 ⊆ insert (3, 1) required_427_i3 := by decide +kernel +theorem child_required_sub_427_i3 : ∀ j, childrenC_427_i3 j ⊆ insert (3, 1) required_427_i3 := by decide +kernel +theorem child_envelope_sub_427_i3 : ∀ j, childrenD_427_i3 j ⊆ envelope_427_i3 := by decide +kernel +theorem pivot_mem_427_i3 : (3, 1) ∈ envelope_427_i3 := by decide +kernel +theorem children_work_427_i3 : ∀ j, Template HasSnaky 6 (childrenC_427_i3 j) (childrenD_427_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_17 3 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_357 3 (0, 4)).mono (by decide +kernel) + · exact row_works_427_i4.mono (by decide +kernel) + · exact row_works_427_i7.mono (by decide +kernel) +theorem row_works_427_i3 : Template HasSnaky 7 required_427_i3 envelope_427_i3 := by + refine compose HasSnaky 6 childrenC_427_i3 childrenD_427_i3 children_work_427_i3 (3, 1) + required_427_i3 envelope_427_i3 pivot_mem_427_i3 child_required_sub_427_i3 child_envelope_sub_427_i3 ?_ + intro b hb + exact common_sub_427_i3 (mem_commonEnvelope childrenD_427_i3 b hb) +def required_427_i2 : Finset Cell := ⟨(([(0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427_i2 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (6, 0), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427_i2 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) required_5), required_427_i3] +def childrenD_427_i2 : Fin 2 → Finset Cell := ![(placed21 7 (1, 4) envelope_5), envelope_427_i3] +theorem common_sub_427_i2 : commonEnvelope childrenD_427_i2 ⊆ insert (0, 1) required_427_i2 := by decide +kernel +theorem child_required_sub_427_i2 : ∀ j, childrenC_427_i2 j ⊆ insert (0, 1) required_427_i2 := by decide +kernel +theorem child_envelope_sub_427_i2 : ∀ j, childrenD_427_i2 j ⊆ envelope_427_i2 := by decide +kernel +theorem pivot_mem_427_i2 : (0, 1) ∈ envelope_427_i2 := by decide +kernel +theorem children_work_427_i2 : ∀ j, Template HasSnaky 7 (childrenC_427_i2 j) (childrenD_427_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (1, 4)).mono (by decide +kernel) + · exact row_works_427_i3.mono (by decide +kernel) +theorem row_works_427_i2 : Template HasSnaky 8 required_427_i2 envelope_427_i2 := by + refine compose HasSnaky 7 childrenC_427_i2 childrenD_427_i2 children_work_427_i2 (0, 1) + required_427_i2 envelope_427_i2 pivot_mem_427_i2 child_required_sub_427_i2 child_envelope_sub_427_i2 ?_ + intro b hb + exact common_sub_427_i2 (mem_commonEnvelope childrenD_427_i2 b hb) +def required_427_i1 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427_i1 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (6, 0), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427_i1 : Fin 2 → Finset Cell := ![(placed21 5 (1, 1) required_5), required_427_i2] +def childrenD_427_i1 : Fin 2 → Finset Cell := ![(placed21 5 (1, 1) envelope_5), envelope_427_i2] +theorem common_sub_427_i1 : commonEnvelope childrenD_427_i1 ⊆ insert (0, 4) required_427_i1 := by decide +kernel +theorem child_required_sub_427_i1 : ∀ j, childrenC_427_i1 j ⊆ insert (0, 4) required_427_i1 := by decide +kernel +theorem child_envelope_sub_427_i1 : ∀ j, childrenD_427_i1 j ⊆ envelope_427_i1 := by decide +kernel +theorem pivot_mem_427_i1 : (0, 4) ∈ envelope_427_i1 := by decide +kernel +theorem children_work_427_i1 : ∀ j, Template HasSnaky 8 (childrenC_427_i1 j) (childrenD_427_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (1, 1)).mono (by decide +kernel) + · exact row_works_427_i2.mono (by decide +kernel) +theorem row_works_427_i1 : Template HasSnaky 9 required_427_i1 envelope_427_i1 := by + refine compose HasSnaky 8 childrenC_427_i1 childrenD_427_i1 children_work_427_i1 (0, 4) + required_427_i1 envelope_427_i1 pivot_mem_427_i1 child_required_sub_427_i1 child_envelope_sub_427_i1 ?_ + intro b hb + exact common_sub_427_i1 (mem_commonEnvelope childrenD_427_i1 b hb) +def required_427_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4), (2, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (6, 0), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) required_5), required_427_i1] +def childrenD_427_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 1) envelope_5), envelope_427_i1] +theorem common_sub_427_i0 : commonEnvelope childrenD_427_i0 ⊆ insert (2, 4) required_427_i0 := by decide +kernel +theorem child_required_sub_427_i0 : ∀ j, childrenC_427_i0 j ⊆ insert (2, 4) required_427_i0 := by decide +kernel +theorem child_envelope_sub_427_i0 : ∀ j, childrenD_427_i0 j ⊆ envelope_427_i0 := by decide +kernel +theorem pivot_mem_427_i0 : (2, 4) ∈ envelope_427_i0 := by decide +kernel +theorem children_work_427_i0 : ∀ j, Template HasSnaky 9 (childrenC_427_i0 j) (childrenD_427_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (1, 1)).mono (by decide +kernel) + · exact row_works_427_i1.mono (by decide +kernel) +theorem row_works_427_i0 : Template HasSnaky 10 required_427_i0 envelope_427_i0 := by + refine compose HasSnaky 9 childrenC_427_i0 childrenD_427_i0 children_work_427_i0 (2, 4) + required_427_i0 envelope_427_i0 pivot_mem_427_i0 child_required_sub_427_i0 child_envelope_sub_427_i0 ?_ + intro b hb + exact common_sub_427_i0 (mem_commonEnvelope childrenD_427_i0 b hb) +def required_427 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_427 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (6, 0), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_427 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_5), required_427_i0] +def childrenD_427 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_5), envelope_427_i0] +theorem common_sub_427 : commonEnvelope childrenD_427 ⊆ insert (2, 1) required_427 := by decide +kernel +theorem child_required_sub_427 : ∀ j, childrenC_427 j ⊆ insert (2, 1) required_427 := by decide +kernel +theorem child_envelope_sub_427 : ∀ j, childrenD_427 j ⊆ envelope_427 := by decide +kernel +theorem pivot_mem_427 : (2, 1) ∈ envelope_427 := by decide +kernel +theorem children_work_427 : ∀ j, Template HasSnaky 10 (childrenC_427 j) (childrenD_427 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (1, 4)).mono (by decide +kernel) + · exact row_works_427_i0.mono (by decide +kernel) +theorem row_works_427 : Template HasSnaky 11 required_427 envelope_427 := by + refine compose HasSnaky 10 childrenC_427 childrenD_427 children_work_427 (2, 1) + required_427 envelope_427 pivot_mem_427 child_required_sub_427 child_envelope_sub_427 ?_ + intro b hb + exact common_sub_427 (mem_commonEnvelope childrenD_427 b hb) +def required_463_i0 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_463_i0 : Finset Cell := ⟨(([(0, 6), (0, 7), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 5), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_463_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) required_4), (placed21 1 (0, 3) required_348)] +def childrenD_463_i0 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) envelope_4), (placed21 1 (0, 3) envelope_348)] +theorem common_sub_463_i0 : commonEnvelope childrenD_463_i0 ⊆ insert (2, 6) required_463_i0 := by decide +kernel +theorem child_required_sub_463_i0 : ∀ j, childrenC_463_i0 j ⊆ insert (2, 6) required_463_i0 := by decide +kernel +theorem child_envelope_sub_463_i0 : ∀ j, childrenD_463_i0 j ⊆ envelope_463_i0 := by decide +kernel +theorem pivot_mem_463_i0 : (2, 6) ∈ envelope_463_i0 := by decide +kernel +theorem children_work_463_i0 : ∀ j, Template HasSnaky 6 (childrenC_463_i0 j) (childrenD_463_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_348 1 (0, 3)).mono (by decide +kernel) +theorem row_works_463_i0 : Template HasSnaky 7 required_463_i0 envelope_463_i0 := by + refine compose HasSnaky 6 childrenC_463_i0 childrenD_463_i0 children_work_463_i0 (2, 6) + required_463_i0 envelope_463_i0 pivot_mem_463_i0 child_required_sub_463_i0 child_envelope_sub_463_i0 ?_ + intro b hb + exact common_sub_463_i0 (mem_commonEnvelope childrenD_463_i0 b hb) +def required_463 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_463 : Finset Cell := ⟨(([(0, 4), (0, 6), (0, 7), (0, 8), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4), (7, 5), (7, 6), (7, 7), (8, 4), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_463 : Fin 5 → Finset Cell := ![(placed21 1 (0, 2) required_147), (placed21 1 (0, 2) required_167), required_463_i0, required_353, (placed21 4 (3, 8) required_460)] +def childrenD_463 : Fin 5 → Finset Cell := ![(placed21 1 (0, 2) envelope_147), (placed21 1 (0, 2) envelope_167), envelope_463_i0, envelope_353, (placed21 4 (3, 8) envelope_460)] +theorem common_sub_463 : commonEnvelope childrenD_463 ⊆ insert (4, 5) required_463 := by decide +kernel +theorem child_required_sub_463 : ∀ j, childrenC_463 j ⊆ insert (4, 5) required_463 := by decide +kernel +theorem child_envelope_sub_463 : ∀ j, childrenD_463 j ⊆ envelope_463 := by decide +kernel +theorem pivot_mem_463 : (4, 5) ∈ envelope_463 := by decide +kernel +theorem children_work_463 : ∀ j, Template HasSnaky 10 (childrenC_463 j) (childrenD_463 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_147 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_167 1 (0, 2)).mono (by decide +kernel) + · exact row_works_463_i0.mono (by decide +kernel) + · exact row_works_353.mono (by decide +kernel) + · exact (placed21_template row_works_460 4 (3, 8)).mono (by decide +kernel) +theorem row_works_463 : Template HasSnaky 11 required_463 envelope_463 := by + refine compose HasSnaky 10 childrenC_463 childrenD_463 children_work_463 (4, 5) + required_463 envelope_463 pivot_mem_463 child_required_sub_463 child_envelope_sub_463 ?_ + intro b hb + exact common_sub_463 (mem_commonEnvelope childrenD_463 b hb) +def required_467 : Finset Cell := ⟨(([(1, 4), (1, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_467 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (7, 8), (8, 5), (8, 6), (8, 7), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_467 : Fin 4 → Finset Cell := ![(placed21 6 (5, 8) required_31), (placed21 1 (1, 4) required_398), (placed21 6 (5, 7) required_444), (placed21 6 (5, 7) required_466)] +def childrenD_467 : Fin 4 → Finset Cell := ![(placed21 6 (5, 8) envelope_31), (placed21 1 (1, 4) envelope_398), (placed21 6 (5, 7) envelope_444), (placed21 6 (5, 7) envelope_466)] +theorem common_sub_467 : commonEnvelope childrenD_467 ⊆ insert (4, 6) required_467 := by decide +kernel +theorem child_required_sub_467 : ∀ j, childrenC_467 j ⊆ insert (4, 6) required_467 := by decide +kernel +theorem child_envelope_sub_467 : ∀ j, childrenD_467 j ⊆ envelope_467 := by decide +kernel +theorem pivot_mem_467 : (4, 6) ∈ envelope_467 := by decide +kernel +theorem children_work_467 : ∀ j, Template HasSnaky 10 (childrenC_467 j) (childrenD_467 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_31 6 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_398 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_444 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_466 6 (5, 7)).mono (by decide +kernel) +theorem row_works_467 : Template HasSnaky 11 required_467 envelope_467 := by + refine compose HasSnaky 10 childrenC_467 childrenD_467 children_work_467 (4, 6) + required_467 envelope_467 pivot_mem_467 child_required_sub_467 child_envelope_sub_467 ?_ + intro b hb + exact common_sub_467 (mem_commonEnvelope childrenD_467 b hb) +def required_468_i1 : Finset Cell := ⟨(([(1, 3), (1, 5), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_468_i1 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 4), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_468_i1 : Fin 4 → Finset Cell := ![(placed21 6 (4, 6) required_71), (placed21 2 (4, 2) required_71), (placed21 6 (4, 6) required_73), (placed21 2 (4, 2) required_73)] +def childrenD_468_i1 : Fin 4 → Finset Cell := ![(placed21 6 (4, 6) envelope_71), (placed21 2 (4, 2) envelope_71), (placed21 6 (4, 6) envelope_73), (placed21 2 (4, 2) envelope_73)] +theorem common_sub_468_i1 : commonEnvelope childrenD_468_i1 ⊆ insert (3, 3) required_468_i1 := by decide +kernel +theorem child_required_sub_468_i1 : ∀ j, childrenC_468_i1 j ⊆ insert (3, 3) required_468_i1 := by decide +kernel +theorem child_envelope_sub_468_i1 : ∀ j, childrenD_468_i1 j ⊆ envelope_468_i1 := by decide +kernel +theorem pivot_mem_468_i1 : (3, 3) ∈ envelope_468_i1 := by decide +kernel +theorem children_work_468_i1 : ∀ j, Template HasSnaky 5 (childrenC_468_i1 j) (childrenD_468_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_71 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_71 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_73 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_73 2 (4, 2)).mono (by decide +kernel) +theorem row_works_468_i1 : Template HasSnaky 6 required_468_i1 envelope_468_i1 := by + refine compose HasSnaky 5 childrenC_468_i1 childrenD_468_i1 children_work_468_i1 (3, 3) + required_468_i1 envelope_468_i1 pivot_mem_468_i1 child_required_sub_468_i1 child_envelope_sub_468_i1 ?_ + intro b hb + exact common_sub_468_i1 (mem_commonEnvelope childrenD_468_i1 b hb) +def required_468_i3 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_468_i3 : Finset Cell := ⟨(([(2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 6), (5, 7), (5, 8), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_468_i3 : Fin 5 → Finset Cell := ![(placed21 1 (2, 3) required_8), (placed21 2 (4, 3) required_17), (placed21 2 (4, 1) required_75), (placed21 0 (3, 1) required_266), (placed21 0 (2, 2) required_447)] +def childrenD_468_i3 : Fin 5 → Finset Cell := ![(placed21 1 (2, 3) envelope_8), (placed21 2 (4, 3) envelope_17), (placed21 2 (4, 1) envelope_75), (placed21 0 (3, 1) envelope_266), (placed21 0 (2, 2) envelope_447)] +theorem common_sub_468_i3 : commonEnvelope childrenD_468_i3 ⊆ insert (3, 6) required_468_i3 := by decide +kernel +theorem child_required_sub_468_i3 : ∀ j, childrenC_468_i3 j ⊆ insert (3, 6) required_468_i3 := by decide +kernel +theorem child_envelope_sub_468_i3 : ∀ j, childrenD_468_i3 j ⊆ envelope_468_i3 := by decide +kernel +theorem pivot_mem_468_i3 : (3, 6) ∈ envelope_468_i3 := by decide +kernel +theorem children_work_468_i3 : ∀ j, Template HasSnaky 7 (childrenC_468_i3 j) (childrenD_468_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_17 2 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_75 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_266 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_447 0 (2, 2)).mono (by decide +kernel) +theorem row_works_468_i3 : Template HasSnaky 8 required_468_i3 envelope_468_i3 := by + refine compose HasSnaky 7 childrenC_468_i3 childrenD_468_i3 children_work_468_i3 (3, 6) + required_468_i3 envelope_468_i3 pivot_mem_468_i3 child_required_sub_468_i3 child_envelope_sub_468_i3 ?_ + intro b hb + exact common_sub_468_i3 (mem_commonEnvelope childrenD_468_i3 b hb) +def required_468_i2 : Finset Cell := ⟨(([(1, 3), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_468_i2 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 5), (5, 6), (5, 7), (5, 8), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_468_i2 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) required_71), (placed21 6 (4, 6) required_73), (placed21 6 (5, 6) required_426), required_468_i3] +def childrenD_468_i2 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) envelope_71), (placed21 6 (4, 6) envelope_73), (placed21 6 (5, 6) envelope_426), envelope_468_i3] +theorem common_sub_468_i2 : commonEnvelope childrenD_468_i2 ⊆ insert (3, 3) required_468_i2 := by decide +kernel +theorem child_required_sub_468_i2 : ∀ j, childrenC_468_i2 j ⊆ insert (3, 3) required_468_i2 := by decide +kernel +theorem child_envelope_sub_468_i2 : ∀ j, childrenD_468_i2 j ⊆ envelope_468_i2 := by decide +kernel +theorem pivot_mem_468_i2 : (3, 3) ∈ envelope_468_i2 := by decide +kernel +theorem children_work_468_i2 : ∀ j, Template HasSnaky 8 (childrenC_468_i2 j) (childrenD_468_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_71 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_73 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_426 6 (5, 6)).mono (by decide +kernel) + · exact row_works_468_i3.mono (by decide +kernel) +theorem row_works_468_i2 : Template HasSnaky 9 required_468_i2 envelope_468_i2 := by + refine compose HasSnaky 8 childrenC_468_i2 childrenD_468_i2 children_work_468_i2 (3, 3) + required_468_i2 envelope_468_i2 pivot_mem_468_i2 child_required_sub_468_i2 child_envelope_sub_468_i2 ?_ + intro b hb + exact common_sub_468_i2 (mem_commonEnvelope childrenD_468_i2 b hb) +def required_468_i0 : Finset Cell := ⟨(([(1, 3), (1, 5), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_468_i0 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_468_i0 : Fin 3 → Finset Cell := ![(placed21 3 (0, 5) required_54), required_468_i1, required_468_i2] +def childrenD_468_i0 : Fin 3 → Finset Cell := ![(placed21 3 (0, 5) envelope_54), envelope_468_i1, envelope_468_i2] +theorem common_sub_468_i0 : commonEnvelope childrenD_468_i0 ⊆ insert (3, 5) required_468_i0 := by decide +kernel +theorem child_required_sub_468_i0 : ∀ j, childrenC_468_i0 j ⊆ insert (3, 5) required_468_i0 := by decide +kernel +theorem child_envelope_sub_468_i0 : ∀ j, childrenD_468_i0 j ⊆ envelope_468_i0 := by decide +kernel +theorem pivot_mem_468_i0 : (3, 5) ∈ envelope_468_i0 := by decide +kernel +theorem children_work_468_i0 : ∀ j, Template HasSnaky 9 (childrenC_468_i0 j) (childrenD_468_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 3 (0, 5)).mono (by decide +kernel) + · exact row_works_468_i1.mono (by decide +kernel) + · exact row_works_468_i2.mono (by decide +kernel) +theorem row_works_468_i0 : Template HasSnaky 10 required_468_i0 envelope_468_i0 := by + refine compose HasSnaky 9 childrenC_468_i0 childrenD_468_i0 children_work_468_i0 (3, 5) + required_468_i0 envelope_468_i0 pivot_mem_468_i0 child_required_sub_468_i0 child_envelope_sub_468_i0 ?_ + intro b hb + exact common_sub_468_i0 (mem_commonEnvelope childrenD_468_i0 b hb) +def required_468 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_468 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_468 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) required_28), (placed21 1 (0, 3) required_126), (placed21 3 (0, 5) required_126), required_468_i0] +def childrenD_468 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) envelope_28), (placed21 1 (0, 3) envelope_126), (placed21 3 (0, 5) envelope_126), envelope_468_i0] +theorem common_sub_468 : commonEnvelope childrenD_468 ⊆ insert (3, 4) required_468 := by decide +kernel +theorem child_required_sub_468 : ∀ j, childrenC_468 j ⊆ insert (3, 4) required_468 := by decide +kernel +theorem child_envelope_sub_468 : ∀ j, childrenD_468 j ⊆ envelope_468 := by decide +kernel +theorem pivot_mem_468 : (3, 4) ∈ envelope_468 := by decide +kernel +theorem children_work_468 : ∀ j, Template HasSnaky 10 (childrenC_468 j) (childrenD_468 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_28 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_126 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_126 3 (0, 5)).mono (by decide +kernel) + · exact row_works_468_i0.mono (by decide +kernel) +theorem row_works_468 : Template HasSnaky 11 required_468 envelope_468 := by + refine compose HasSnaky 10 childrenC_468 childrenD_468 children_work_468 (3, 4) + required_468 envelope_468 pivot_mem_468 child_required_sub_468 child_envelope_sub_468 ?_ + intro b hb + exact common_sub_468 (mem_commonEnvelope childrenD_468 b hb) +def height_427_i6 : ℕ := 4 +def childrenH_427_i6 : Fin 2 → ℕ := ![height_70, height_226] +theorem height_exact_427_i6 : height_427_i6 = 1 + Finset.univ.sup childrenH_427_i6 := by decide +kernel +theorem required_origin_427_i6 : ∀ x ∈ required_427_i6, + (∃ j, x ∈ childrenC_427_i6 j) ∨ ∀ j, x ∈ childrenD_427_i6 j := by decide +kernel +theorem required_exact_427_i6 : required_427_i6 = + ((Finset.univ.biUnion childrenC_427_i6) ∪ commonEnvelope childrenD_427_i6).erase (4, 3) := by + exact required_eq_combination childrenC_427_i6 childrenD_427_i6 (4, 3) required_427_i6 + (by decide +kernel) child_required_sub_427_i6 common_sub_427_i6 required_origin_427_i6 +theorem envelope_origin_427_i6 : ∀ x ∈ envelope_427_i6, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_427_i6 j := by decide +kernel +theorem envelope_exact_427_i6 : envelope_427_i6 = + insert (4, 3) (Finset.univ.biUnion childrenD_427_i6) := by + exact envelope_eq_combination childrenD_427_i6 (4, 3) envelope_427_i6 + pivot_mem_427_i6 child_envelope_sub_427_i6 envelope_origin_427_i6 +def checked_427_i6 : CheckedCard where + required := required_427_i6 + envelope := envelope_427_i6 + height := height_427_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427_i6 +def height_427_i5 : ℕ := 5 +def childrenH_427_i5 : Fin 2 → ℕ := ![height_5, height_427_i6] +theorem height_exact_427_i5 : height_427_i5 = 1 + Finset.univ.sup childrenH_427_i5 := by decide +kernel +theorem required_origin_427_i5 : ∀ x ∈ required_427_i5, + (∃ j, x ∈ childrenC_427_i5 j) ∨ ∀ j, x ∈ childrenD_427_i5 j := by decide +kernel +theorem required_exact_427_i5 : required_427_i5 = + ((Finset.univ.biUnion childrenC_427_i5) ∪ commonEnvelope childrenD_427_i5).erase (4, 1) := by + exact required_eq_combination childrenC_427_i5 childrenD_427_i5 (4, 1) required_427_i5 + (by decide +kernel) child_required_sub_427_i5 common_sub_427_i5 required_origin_427_i5 +theorem envelope_origin_427_i5 : ∀ x ∈ envelope_427_i5, + x = (4, 1) ∨ ∃ j, x ∈ childrenD_427_i5 j := by decide +kernel +theorem envelope_exact_427_i5 : envelope_427_i5 = + insert (4, 1) (Finset.univ.biUnion childrenD_427_i5) := by + exact envelope_eq_combination childrenD_427_i5 (4, 1) envelope_427_i5 + pivot_mem_427_i5 child_envelope_sub_427_i5 envelope_origin_427_i5 +def checked_427_i5 : CheckedCard where + required := required_427_i5 + envelope := envelope_427_i5 + height := height_427_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427_i5 +def height_427_i4 : ℕ := 6 +def childrenH_427_i4 : Fin 2 → ℕ := ![height_4, height_427_i5] +theorem height_exact_427_i4 : height_427_i4 = 1 + Finset.univ.sup childrenH_427_i4 := by decide +kernel +theorem required_origin_427_i4 : ∀ x ∈ required_427_i4, + (∃ j, x ∈ childrenC_427_i4 j) ∨ ∀ j, x ∈ childrenD_427_i4 j := by decide +kernel +theorem required_exact_427_i4 : required_427_i4 = + ((Finset.univ.biUnion childrenC_427_i4) ∪ commonEnvelope childrenD_427_i4).erase (4, 2) := by + exact required_eq_combination childrenC_427_i4 childrenD_427_i4 (4, 2) required_427_i4 + (by decide +kernel) child_required_sub_427_i4 common_sub_427_i4 required_origin_427_i4 +theorem envelope_origin_427_i4 : ∀ x ∈ envelope_427_i4, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_427_i4 j := by decide +kernel +theorem envelope_exact_427_i4 : envelope_427_i4 = + insert (4, 2) (Finset.univ.biUnion childrenD_427_i4) := by + exact envelope_eq_combination childrenD_427_i4 (4, 2) envelope_427_i4 + pivot_mem_427_i4 child_envelope_sub_427_i4 envelope_origin_427_i4 +def checked_427_i4 : CheckedCard where + required := required_427_i4 + envelope := envelope_427_i4 + height := height_427_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427_i4 +def height_427_i9 : ℕ := 2 +def childrenH_427_i9 : Fin 2 → ℕ := ![height_0, height_2] +theorem height_exact_427_i9 : height_427_i9 = 1 + Finset.univ.sup childrenH_427_i9 := by decide +kernel +theorem required_origin_427_i9 : ∀ x ∈ required_427_i9, + (∃ j, x ∈ childrenC_427_i9 j) ∨ ∀ j, x ∈ childrenD_427_i9 j := by decide +kernel +theorem required_exact_427_i9 : required_427_i9 = + ((Finset.univ.biUnion childrenC_427_i9) ∪ commonEnvelope childrenD_427_i9).erase (3, 3) := by + exact required_eq_combination childrenC_427_i9 childrenD_427_i9 (3, 3) required_427_i9 + (by decide +kernel) child_required_sub_427_i9 common_sub_427_i9 required_origin_427_i9 +theorem envelope_origin_427_i9 : ∀ x ∈ envelope_427_i9, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_427_i9 j := by decide +kernel +theorem envelope_exact_427_i9 : envelope_427_i9 = + insert (3, 3) (Finset.univ.biUnion childrenD_427_i9) := by + exact envelope_eq_combination childrenD_427_i9 (3, 3) envelope_427_i9 + pivot_mem_427_i9 child_envelope_sub_427_i9 envelope_origin_427_i9 +def checked_427_i9 : CheckedCard where + required := required_427_i9 + envelope := envelope_427_i9 + height := height_427_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427_i9 +def height_427_i8 : ℕ := 3 +def childrenH_427_i8 : Fin 2 → ℕ := ![height_2, height_427_i9] +theorem height_exact_427_i8 : height_427_i8 = 1 + Finset.univ.sup childrenH_427_i8 := by decide +kernel +theorem required_origin_427_i8 : ∀ x ∈ required_427_i8, + (∃ j, x ∈ childrenC_427_i8 j) ∨ ∀ j, x ∈ childrenD_427_i8 j := by decide +kernel +theorem required_exact_427_i8 : required_427_i8 = + ((Finset.univ.biUnion childrenC_427_i8) ∪ commonEnvelope childrenD_427_i8).erase (2, 3) := by + exact required_eq_combination childrenC_427_i8 childrenD_427_i8 (2, 3) required_427_i8 + (by decide +kernel) child_required_sub_427_i8 common_sub_427_i8 required_origin_427_i8 +theorem envelope_origin_427_i8 : ∀ x ∈ envelope_427_i8, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_427_i8 j := by decide +kernel +theorem envelope_exact_427_i8 : envelope_427_i8 = + insert (2, 3) (Finset.univ.biUnion childrenD_427_i8) := by + exact envelope_eq_combination childrenD_427_i8 (2, 3) envelope_427_i8 + pivot_mem_427_i8 child_envelope_sub_427_i8 envelope_origin_427_i8 +def checked_427_i8 : CheckedCard where + required := required_427_i8 + envelope := envelope_427_i8 + height := height_427_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427_i8 +def height_427_i7 : ℕ := 4 +def childrenH_427_i7 : Fin 2 → ℕ := ![height_52, height_427_i8] +theorem height_exact_427_i7 : height_427_i7 = 1 + Finset.univ.sup childrenH_427_i7 := by decide +kernel +theorem required_origin_427_i7 : ∀ x ∈ required_427_i7, + (∃ j, x ∈ childrenC_427_i7 j) ∨ ∀ j, x ∈ childrenD_427_i7 j := by decide +kernel +theorem required_exact_427_i7 : required_427_i7 = + ((Finset.univ.biUnion childrenC_427_i7) ∪ commonEnvelope childrenD_427_i7).erase (3, 0) := by + exact required_eq_combination childrenC_427_i7 childrenD_427_i7 (3, 0) required_427_i7 + (by decide +kernel) child_required_sub_427_i7 common_sub_427_i7 required_origin_427_i7 +theorem envelope_origin_427_i7 : ∀ x ∈ envelope_427_i7, + x = (3, 0) ∨ ∃ j, x ∈ childrenD_427_i7 j := by decide +kernel +theorem envelope_exact_427_i7 : envelope_427_i7 = + insert (3, 0) (Finset.univ.biUnion childrenD_427_i7) := by + exact envelope_eq_combination childrenD_427_i7 (3, 0) envelope_427_i7 + pivot_mem_427_i7 child_envelope_sub_427_i7 envelope_origin_427_i7 +def checked_427_i7 : CheckedCard where + required := required_427_i7 + envelope := envelope_427_i7 + height := height_427_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427_i7 +def height_427_i3 : ℕ := 7 +def childrenH_427_i3 : Fin 4 → ℕ := ![height_17, height_357, height_427_i4, height_427_i7] +theorem height_exact_427_i3 : height_427_i3 = 1 + Finset.univ.sup childrenH_427_i3 := by decide +kernel +theorem required_origin_427_i3 : ∀ x ∈ required_427_i3, + (∃ j, x ∈ childrenC_427_i3 j) ∨ ∀ j, x ∈ childrenD_427_i3 j := by decide +kernel +theorem required_exact_427_i3 : required_427_i3 = + ((Finset.univ.biUnion childrenC_427_i3) ∪ commonEnvelope childrenD_427_i3).erase (3, 1) := by + exact required_eq_combination childrenC_427_i3 childrenD_427_i3 (3, 1) required_427_i3 + (by decide +kernel) child_required_sub_427_i3 common_sub_427_i3 required_origin_427_i3 +theorem envelope_origin_427_i3 : ∀ x ∈ envelope_427_i3, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_427_i3 j := by decide +kernel +theorem envelope_exact_427_i3 : envelope_427_i3 = + insert (3, 1) (Finset.univ.biUnion childrenD_427_i3) := by + exact envelope_eq_combination childrenD_427_i3 (3, 1) envelope_427_i3 + pivot_mem_427_i3 child_envelope_sub_427_i3 envelope_origin_427_i3 +def checked_427_i3 : CheckedCard where + required := required_427_i3 + envelope := envelope_427_i3 + height := height_427_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427_i3 +def height_427_i2 : ℕ := 8 +def childrenH_427_i2 : Fin 2 → ℕ := ![height_5, height_427_i3] +theorem height_exact_427_i2 : height_427_i2 = 1 + Finset.univ.sup childrenH_427_i2 := by decide +kernel +theorem required_origin_427_i2 : ∀ x ∈ required_427_i2, + (∃ j, x ∈ childrenC_427_i2 j) ∨ ∀ j, x ∈ childrenD_427_i2 j := by decide +kernel +theorem required_exact_427_i2 : required_427_i2 = + ((Finset.univ.biUnion childrenC_427_i2) ∪ commonEnvelope childrenD_427_i2).erase (0, 1) := by + exact required_eq_combination childrenC_427_i2 childrenD_427_i2 (0, 1) required_427_i2 + (by decide +kernel) child_required_sub_427_i2 common_sub_427_i2 required_origin_427_i2 +theorem envelope_origin_427_i2 : ∀ x ∈ envelope_427_i2, + x = (0, 1) ∨ ∃ j, x ∈ childrenD_427_i2 j := by decide +kernel +theorem envelope_exact_427_i2 : envelope_427_i2 = + insert (0, 1) (Finset.univ.biUnion childrenD_427_i2) := by + exact envelope_eq_combination childrenD_427_i2 (0, 1) envelope_427_i2 + pivot_mem_427_i2 child_envelope_sub_427_i2 envelope_origin_427_i2 +def checked_427_i2 : CheckedCard where + required := required_427_i2 + envelope := envelope_427_i2 + height := height_427_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427_i2 +def height_427_i1 : ℕ := 9 +def childrenH_427_i1 : Fin 2 → ℕ := ![height_5, height_427_i2] +theorem height_exact_427_i1 : height_427_i1 = 1 + Finset.univ.sup childrenH_427_i1 := by decide +kernel +theorem required_origin_427_i1 : ∀ x ∈ required_427_i1, + (∃ j, x ∈ childrenC_427_i1 j) ∨ ∀ j, x ∈ childrenD_427_i1 j := by decide +kernel +theorem required_exact_427_i1 : required_427_i1 = + ((Finset.univ.biUnion childrenC_427_i1) ∪ commonEnvelope childrenD_427_i1).erase (0, 4) := by + exact required_eq_combination childrenC_427_i1 childrenD_427_i1 (0, 4) required_427_i1 + (by decide +kernel) child_required_sub_427_i1 common_sub_427_i1 required_origin_427_i1 +theorem envelope_origin_427_i1 : ∀ x ∈ envelope_427_i1, + x = (0, 4) ∨ ∃ j, x ∈ childrenD_427_i1 j := by decide +kernel +theorem envelope_exact_427_i1 : envelope_427_i1 = + insert (0, 4) (Finset.univ.biUnion childrenD_427_i1) := by + exact envelope_eq_combination childrenD_427_i1 (0, 4) envelope_427_i1 + pivot_mem_427_i1 child_envelope_sub_427_i1 envelope_origin_427_i1 +def checked_427_i1 : CheckedCard where + required := required_427_i1 + envelope := envelope_427_i1 + height := height_427_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427_i1 +def height_427_i0 : ℕ := 10 +def childrenH_427_i0 : Fin 2 → ℕ := ![height_5, height_427_i1] +theorem height_exact_427_i0 : height_427_i0 = 1 + Finset.univ.sup childrenH_427_i0 := by decide +kernel +theorem required_origin_427_i0 : ∀ x ∈ required_427_i0, + (∃ j, x ∈ childrenC_427_i0 j) ∨ ∀ j, x ∈ childrenD_427_i0 j := by decide +kernel +theorem required_exact_427_i0 : required_427_i0 = + ((Finset.univ.biUnion childrenC_427_i0) ∪ commonEnvelope childrenD_427_i0).erase (2, 4) := by + exact required_eq_combination childrenC_427_i0 childrenD_427_i0 (2, 4) required_427_i0 + (by decide +kernel) child_required_sub_427_i0 common_sub_427_i0 required_origin_427_i0 +theorem envelope_origin_427_i0 : ∀ x ∈ envelope_427_i0, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_427_i0 j := by decide +kernel +theorem envelope_exact_427_i0 : envelope_427_i0 = + insert (2, 4) (Finset.univ.biUnion childrenD_427_i0) := by + exact envelope_eq_combination childrenD_427_i0 (2, 4) envelope_427_i0 + pivot_mem_427_i0 child_envelope_sub_427_i0 envelope_origin_427_i0 +def checked_427_i0 : CheckedCard where + required := required_427_i0 + envelope := envelope_427_i0 + height := height_427_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427_i0 +def height_427 : ℕ := 11 +def childrenH_427 : Fin 2 → ℕ := ![height_5, height_427_i0] +theorem height_exact_427 : height_427 = 1 + Finset.univ.sup childrenH_427 := by decide +kernel +theorem required_origin_427 : ∀ x ∈ required_427, + (∃ j, x ∈ childrenC_427 j) ∨ ∀ j, x ∈ childrenD_427 j := by decide +kernel +theorem required_exact_427 : required_427 = + ((Finset.univ.biUnion childrenC_427) ∪ commonEnvelope childrenD_427).erase (2, 1) := by + exact required_eq_combination childrenC_427 childrenD_427 (2, 1) required_427 + (by decide +kernel) child_required_sub_427 common_sub_427 required_origin_427 +theorem envelope_origin_427 : ∀ x ∈ envelope_427, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_427 j := by decide +kernel +theorem envelope_exact_427 : envelope_427 = + insert (2, 1) (Finset.univ.biUnion childrenD_427) := by + exact envelope_eq_combination childrenD_427 (2, 1) envelope_427 + pivot_mem_427 child_envelope_sub_427 envelope_origin_427 +def checked_427 : CheckedCard where + required := required_427 + envelope := envelope_427 + height := height_427 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_427 +def height_463_i0 : ℕ := 7 +def childrenH_463_i0 : Fin 2 → ℕ := ![height_4, height_348] +theorem height_exact_463_i0 : height_463_i0 = 1 + Finset.univ.sup childrenH_463_i0 := by decide +kernel +theorem required_origin_463_i0 : ∀ x ∈ required_463_i0, + (∃ j, x ∈ childrenC_463_i0 j) ∨ ∀ j, x ∈ childrenD_463_i0 j := by decide +kernel +theorem required_exact_463_i0 : required_463_i0 = + ((Finset.univ.biUnion childrenC_463_i0) ∪ commonEnvelope childrenD_463_i0).erase (2, 6) := by + exact required_eq_combination childrenC_463_i0 childrenD_463_i0 (2, 6) required_463_i0 + (by decide +kernel) child_required_sub_463_i0 common_sub_463_i0 required_origin_463_i0 +theorem envelope_origin_463_i0 : ∀ x ∈ envelope_463_i0, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_463_i0 j := by decide +kernel +theorem envelope_exact_463_i0 : envelope_463_i0 = + insert (2, 6) (Finset.univ.biUnion childrenD_463_i0) := by + exact envelope_eq_combination childrenD_463_i0 (2, 6) envelope_463_i0 + pivot_mem_463_i0 child_envelope_sub_463_i0 envelope_origin_463_i0 +def checked_463_i0 : CheckedCard where + required := required_463_i0 + envelope := envelope_463_i0 + height := height_463_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_463_i0 +def height_463 : ℕ := 11 +def childrenH_463 : Fin 5 → ℕ := ![height_147, height_167, height_463_i0, height_353, height_460] +theorem height_exact_463 : height_463 = 1 + Finset.univ.sup childrenH_463 := by decide +kernel +theorem required_origin_463 : ∀ x ∈ required_463, + (∃ j, x ∈ childrenC_463 j) ∨ ∀ j, x ∈ childrenD_463 j := by decide +kernel +theorem required_exact_463 : required_463 = + ((Finset.univ.biUnion childrenC_463) ∪ commonEnvelope childrenD_463).erase (4, 5) := by + exact required_eq_combination childrenC_463 childrenD_463 (4, 5) required_463 + (by decide +kernel) child_required_sub_463 common_sub_463 required_origin_463 +theorem envelope_origin_463 : ∀ x ∈ envelope_463, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_463 j := by decide +kernel +theorem envelope_exact_463 : envelope_463 = + insert (4, 5) (Finset.univ.biUnion childrenD_463) := by + exact envelope_eq_combination childrenD_463 (4, 5) envelope_463 + pivot_mem_463 child_envelope_sub_463 envelope_origin_463 +def checked_463 : CheckedCard where + required := required_463 + envelope := envelope_463 + height := height_463 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_463 +def height_467 : ℕ := 11 +def childrenH_467 : Fin 4 → ℕ := ![height_31, height_398, height_444, height_466] +theorem height_exact_467 : height_467 = 1 + Finset.univ.sup childrenH_467 := by decide +kernel +theorem required_origin_467 : ∀ x ∈ required_467, + (∃ j, x ∈ childrenC_467 j) ∨ ∀ j, x ∈ childrenD_467 j := by decide +kernel +theorem required_exact_467 : required_467 = + ((Finset.univ.biUnion childrenC_467) ∪ commonEnvelope childrenD_467).erase (4, 6) := by + exact required_eq_combination childrenC_467 childrenD_467 (4, 6) required_467 + (by decide +kernel) child_required_sub_467 common_sub_467 required_origin_467 +theorem envelope_origin_467 : ∀ x ∈ envelope_467, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_467 j := by decide +kernel +theorem envelope_exact_467 : envelope_467 = + insert (4, 6) (Finset.univ.biUnion childrenD_467) := by + exact envelope_eq_combination childrenD_467 (4, 6) envelope_467 + pivot_mem_467 child_envelope_sub_467 envelope_origin_467 +def checked_467 : CheckedCard where + required := required_467 + envelope := envelope_467 + height := height_467 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_467 +def height_468_i1 : ℕ := 6 +def childrenH_468_i1 : Fin 4 → ℕ := ![height_71, height_71, height_73, height_73] +theorem height_exact_468_i1 : height_468_i1 = 1 + Finset.univ.sup childrenH_468_i1 := by decide +kernel +theorem required_origin_468_i1 : ∀ x ∈ required_468_i1, + (∃ j, x ∈ childrenC_468_i1 j) ∨ ∀ j, x ∈ childrenD_468_i1 j := by decide +kernel +theorem required_exact_468_i1 : required_468_i1 = + ((Finset.univ.biUnion childrenC_468_i1) ∪ commonEnvelope childrenD_468_i1).erase (3, 3) := by + exact required_eq_combination childrenC_468_i1 childrenD_468_i1 (3, 3) required_468_i1 + (by decide +kernel) child_required_sub_468_i1 common_sub_468_i1 required_origin_468_i1 +theorem envelope_origin_468_i1 : ∀ x ∈ envelope_468_i1, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_468_i1 j := by decide +kernel +theorem envelope_exact_468_i1 : envelope_468_i1 = + insert (3, 3) (Finset.univ.biUnion childrenD_468_i1) := by + exact envelope_eq_combination childrenD_468_i1 (3, 3) envelope_468_i1 + pivot_mem_468_i1 child_envelope_sub_468_i1 envelope_origin_468_i1 +def checked_468_i1 : CheckedCard where + required := required_468_i1 + envelope := envelope_468_i1 + height := height_468_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_468_i1 +def height_468_i3 : ℕ := 8 +def childrenH_468_i3 : Fin 5 → ℕ := ![height_8, height_17, height_75, height_266, height_447] +theorem height_exact_468_i3 : height_468_i3 = 1 + Finset.univ.sup childrenH_468_i3 := by decide +kernel +theorem required_origin_468_i3 : ∀ x ∈ required_468_i3, + (∃ j, x ∈ childrenC_468_i3 j) ∨ ∀ j, x ∈ childrenD_468_i3 j := by decide +kernel +theorem required_exact_468_i3 : required_468_i3 = + ((Finset.univ.biUnion childrenC_468_i3) ∪ commonEnvelope childrenD_468_i3).erase (3, 6) := by + exact required_eq_combination childrenC_468_i3 childrenD_468_i3 (3, 6) required_468_i3 + (by decide +kernel) child_required_sub_468_i3 common_sub_468_i3 required_origin_468_i3 +theorem envelope_origin_468_i3 : ∀ x ∈ envelope_468_i3, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_468_i3 j := by decide +kernel +theorem envelope_exact_468_i3 : envelope_468_i3 = + insert (3, 6) (Finset.univ.biUnion childrenD_468_i3) := by + exact envelope_eq_combination childrenD_468_i3 (3, 6) envelope_468_i3 + pivot_mem_468_i3 child_envelope_sub_468_i3 envelope_origin_468_i3 +def checked_468_i3 : CheckedCard where + required := required_468_i3 + envelope := envelope_468_i3 + height := height_468_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_468_i3 +def height_468_i2 : ℕ := 9 +def childrenH_468_i2 : Fin 4 → ℕ := ![height_71, height_73, height_426, height_468_i3] +theorem height_exact_468_i2 : height_468_i2 = 1 + Finset.univ.sup childrenH_468_i2 := by decide +kernel +theorem required_origin_468_i2 : ∀ x ∈ required_468_i2, + (∃ j, x ∈ childrenC_468_i2 j) ∨ ∀ j, x ∈ childrenD_468_i2 j := by decide +kernel +theorem required_exact_468_i2 : required_468_i2 = + ((Finset.univ.biUnion childrenC_468_i2) ∪ commonEnvelope childrenD_468_i2).erase (3, 3) := by + exact required_eq_combination childrenC_468_i2 childrenD_468_i2 (3, 3) required_468_i2 + (by decide +kernel) child_required_sub_468_i2 common_sub_468_i2 required_origin_468_i2 +theorem envelope_origin_468_i2 : ∀ x ∈ envelope_468_i2, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_468_i2 j := by decide +kernel +theorem envelope_exact_468_i2 : envelope_468_i2 = + insert (3, 3) (Finset.univ.biUnion childrenD_468_i2) := by + exact envelope_eq_combination childrenD_468_i2 (3, 3) envelope_468_i2 + pivot_mem_468_i2 child_envelope_sub_468_i2 envelope_origin_468_i2 +def checked_468_i2 : CheckedCard where + required := required_468_i2 + envelope := envelope_468_i2 + height := height_468_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_468_i2 +def height_468_i0 : ℕ := 10 +def childrenH_468_i0 : Fin 3 → ℕ := ![height_54, height_468_i1, height_468_i2] +theorem height_exact_468_i0 : height_468_i0 = 1 + Finset.univ.sup childrenH_468_i0 := by decide +kernel +theorem required_origin_468_i0 : ∀ x ∈ required_468_i0, + (∃ j, x ∈ childrenC_468_i0 j) ∨ ∀ j, x ∈ childrenD_468_i0 j := by decide +kernel +theorem required_exact_468_i0 : required_468_i0 = + ((Finset.univ.biUnion childrenC_468_i0) ∪ commonEnvelope childrenD_468_i0).erase (3, 5) := by + exact required_eq_combination childrenC_468_i0 childrenD_468_i0 (3, 5) required_468_i0 + (by decide +kernel) child_required_sub_468_i0 common_sub_468_i0 required_origin_468_i0 +theorem envelope_origin_468_i0 : ∀ x ∈ envelope_468_i0, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_468_i0 j := by decide +kernel +theorem envelope_exact_468_i0 : envelope_468_i0 = + insert (3, 5) (Finset.univ.biUnion childrenD_468_i0) := by + exact envelope_eq_combination childrenD_468_i0 (3, 5) envelope_468_i0 + pivot_mem_468_i0 child_envelope_sub_468_i0 envelope_origin_468_i0 +def checked_468_i0 : CheckedCard where + required := required_468_i0 + envelope := envelope_468_i0 + height := height_468_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_468_i0 +def height_468 : ℕ := 11 +def childrenH_468 : Fin 4 → ℕ := ![height_28, height_126, height_126, height_468_i0] +theorem height_exact_468 : height_468 = 1 + Finset.univ.sup childrenH_468 := by decide +kernel +theorem required_origin_468 : ∀ x ∈ required_468, + (∃ j, x ∈ childrenC_468 j) ∨ ∀ j, x ∈ childrenD_468 j := by decide +kernel +theorem required_exact_468 : required_468 = + ((Finset.univ.biUnion childrenC_468) ∪ commonEnvelope childrenD_468).erase (3, 4) := by + exact required_eq_combination childrenC_468 childrenD_468 (3, 4) required_468 + (by decide +kernel) child_required_sub_468 common_sub_468 required_origin_468 +theorem envelope_origin_468 : ∀ x ∈ envelope_468, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_468 j := by decide +kernel +theorem envelope_exact_468 : envelope_468 = + insert (3, 4) (Finset.univ.biUnion childrenD_468) := by + exact envelope_eq_combination childrenD_468 (3, 4) envelope_468 + pivot_mem_468 child_envelope_sub_468 envelope_origin_468 +def checked_468 : CheckedCard where + required := required_468 + envelope := envelope_468 + height := height_468 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_468 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part02.lean new file mode 100644 index 0000000..a0eeb99 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part02.lean @@ -0,0 +1,942 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_517_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_517_i0 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (4, 4), (4, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_517_i0 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) required_0), (placed21 1 (0, 3) required_404)] +def childrenD_517_i0 : Fin 2 → Finset Cell := ![(placed21 6 (5, 4) envelope_0), (placed21 1 (0, 3) envelope_404)] +theorem common_sub_517_i0 : commonEnvelope childrenD_517_i0 ⊆ insert (3, 4) required_517_i0 := by decide +kernel +theorem child_required_sub_517_i0 : ∀ j, childrenC_517_i0 j ⊆ insert (3, 4) required_517_i0 := by decide +kernel +theorem child_envelope_sub_517_i0 : ∀ j, childrenD_517_i0 j ⊆ envelope_517_i0 := by decide +kernel +theorem pivot_mem_517_i0 : (3, 4) ∈ envelope_517_i0 := by decide +kernel +theorem children_work_517_i0 : ∀ j, Template HasSnaky 7 (childrenC_517_i0 j) (childrenD_517_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_404 1 (0, 3)).mono (by decide +kernel) +theorem row_works_517_i0 : Template HasSnaky 8 required_517_i0 envelope_517_i0 := by + refine compose HasSnaky 7 childrenC_517_i0 childrenD_517_i0 children_work_517_i0 (3, 4) + required_517_i0 envelope_517_i0 pivot_mem_517_i0 child_required_sub_517_i0 child_envelope_sub_517_i0 ?_ + intro b hb + exact common_sub_517_i0 (mem_commonEnvelope childrenD_517_i0 b hb) +def required_517_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_517_i2 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_517_i2 : Fin 5 → Finset Cell := ![(placed21 6 (5, 7) required_14), (placed21 4 (1, 6) required_79), (placed21 4 (3, 7) required_367), (placed21 2 (5, 2) required_513), (placed21 0 (1, 2) required_516)] +def childrenD_517_i2 : Fin 5 → Finset Cell := ![(placed21 6 (5, 7) envelope_14), (placed21 4 (1, 6) envelope_79), (placed21 4 (3, 7) envelope_367), (placed21 2 (5, 2) envelope_513), (placed21 0 (1, 2) envelope_516)] +theorem common_sub_517_i2 : commonEnvelope childrenD_517_i2 ⊆ insert (4, 5) required_517_i2 := by decide +kernel +theorem child_required_sub_517_i2 : ∀ j, childrenC_517_i2 j ⊆ insert (4, 5) required_517_i2 := by decide +kernel +theorem child_envelope_sub_517_i2 : ∀ j, childrenD_517_i2 j ⊆ envelope_517_i2 := by decide +kernel +theorem pivot_mem_517_i2 : (4, 5) ∈ envelope_517_i2 := by decide +kernel +theorem children_work_517_i2 : ∀ j, Template HasSnaky 8 (childrenC_517_i2 j) (childrenD_517_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_79 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_367 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_513 2 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_516 0 (1, 2)).mono (by decide +kernel) +theorem row_works_517_i2 : Template HasSnaky 9 required_517_i2 envelope_517_i2 := by + refine compose HasSnaky 8 childrenC_517_i2 childrenD_517_i2 children_work_517_i2 (4, 5) + required_517_i2 envelope_517_i2 pivot_mem_517_i2 child_required_sub_517_i2 child_envelope_sub_517_i2 ?_ + intro b hb + exact common_sub_517_i2 (mem_commonEnvelope childrenD_517_i2 b hb) +def required_517_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_517_i1 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_517_i1 : Fin 4 → Finset Cell := ![(placed21 1 (1, 3) required_30), (placed21 0 (1, 0) required_59), (placed21 4 (1, 6) required_346), required_517_i2] +def childrenD_517_i1 : Fin 4 → Finset Cell := ![(placed21 1 (1, 3) envelope_30), (placed21 0 (1, 0) envelope_59), (placed21 4 (1, 6) envelope_346), envelope_517_i2] +theorem common_sub_517_i1 : commonEnvelope childrenD_517_i1 ⊆ insert (4, 3) required_517_i1 := by decide +kernel +theorem child_required_sub_517_i1 : ∀ j, childrenC_517_i1 j ⊆ insert (4, 3) required_517_i1 := by decide +kernel +theorem child_envelope_sub_517_i1 : ∀ j, childrenD_517_i1 j ⊆ envelope_517_i1 := by decide +kernel +theorem pivot_mem_517_i1 : (4, 3) ∈ envelope_517_i1 := by decide +kernel +theorem children_work_517_i1 : ∀ j, Template HasSnaky 9 (childrenC_517_i1 j) (childrenD_517_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_30 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_59 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_346 4 (1, 6)).mono (by decide +kernel) + · exact row_works_517_i2.mono (by decide +kernel) +theorem row_works_517_i1 : Template HasSnaky 10 required_517_i1 envelope_517_i1 := by + refine compose HasSnaky 9 childrenC_517_i1 childrenD_517_i1 children_work_517_i1 (4, 3) + required_517_i1 envelope_517_i1 pivot_mem_517_i1 child_required_sub_517_i1 child_envelope_sub_517_i1 ?_ + intro b hb + exact common_sub_517_i1 (mem_commonEnvelope childrenD_517_i1 b hb) +def required_517_i4 : Finset Cell := ⟨(([(1, 4), (2, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_517_i4 : Finset Cell := ⟨(([(1, 4), (1, 6), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 5), (5, 6), (5, 7), (5, 8), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_517_i4 : Fin 4 → Finset Cell := ![(placed21 4 (3, 7) required_14), (placed21 0 (1, 2) required_58), (placed21 4 (1, 6) required_79), (placed21 0 (1, 2) required_429)] +def childrenD_517_i4 : Fin 4 → Finset Cell := ![(placed21 4 (3, 7) envelope_14), (placed21 0 (1, 2) envelope_58), (placed21 4 (1, 6) envelope_79), (placed21 0 (1, 2) envelope_429)] +theorem common_sub_517_i4 : commonEnvelope childrenD_517_i4 ⊆ insert (4, 5) required_517_i4 := by decide +kernel +theorem child_required_sub_517_i4 : ∀ j, childrenC_517_i4 j ⊆ insert (4, 5) required_517_i4 := by decide +kernel +theorem child_envelope_sub_517_i4 : ∀ j, childrenD_517_i4 j ⊆ envelope_517_i4 := by decide +kernel +theorem pivot_mem_517_i4 : (4, 5) ∈ envelope_517_i4 := by decide +kernel +theorem children_work_517_i4 : ∀ j, Template HasSnaky 6 (childrenC_517_i4 j) (childrenD_517_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_58 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_79 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_429 0 (1, 2)).mono (by decide +kernel) +theorem row_works_517_i4 : Template HasSnaky 7 required_517_i4 envelope_517_i4 := by + refine compose HasSnaky 6 childrenC_517_i4 childrenD_517_i4 children_work_517_i4 (4, 5) + required_517_i4 envelope_517_i4 pivot_mem_517_i4 child_required_sub_517_i4 child_envelope_sub_517_i4 ?_ + intro b hb + exact common_sub_517_i4 (mem_commonEnvelope childrenD_517_i4 b hb) +def required_517_i3 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_517_i3 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_517_i3 : Fin 4 → Finset Cell := ![(placed21 3 (1, 4) required_36), (placed21 4 (1, 7) required_59), (placed21 4 (1, 6) required_346), required_517_i4] +def childrenD_517_i3 : Fin 4 → Finset Cell := ![(placed21 3 (1, 4) envelope_36), (placed21 4 (1, 7) envelope_59), (placed21 4 (1, 6) envelope_346), envelope_517_i4] +theorem common_sub_517_i3 : commonEnvelope childrenD_517_i3 ⊆ insert (4, 3) required_517_i3 := by decide +kernel +theorem child_required_sub_517_i3 : ∀ j, childrenC_517_i3 j ⊆ insert (4, 3) required_517_i3 := by decide +kernel +theorem child_envelope_sub_517_i3 : ∀ j, childrenD_517_i3 j ⊆ envelope_517_i3 := by decide +kernel +theorem pivot_mem_517_i3 : (4, 3) ∈ envelope_517_i3 := by decide +kernel +theorem children_work_517_i3 : ∀ j, Template HasSnaky 7 (childrenC_517_i3 j) (childrenD_517_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_36 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_59 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_346 4 (1, 6)).mono (by decide +kernel) + · exact row_works_517_i4.mono (by decide +kernel) +theorem row_works_517_i3 : Template HasSnaky 8 required_517_i3 envelope_517_i3 := by + refine compose HasSnaky 7 childrenC_517_i3 childrenD_517_i3 children_work_517_i3 (4, 3) + required_517_i3 envelope_517_i3 pivot_mem_517_i3 child_required_sub_517_i3 child_envelope_sub_517_i3 ?_ + intro b hb + exact common_sub_517_i3 (mem_commonEnvelope childrenD_517_i3 b hb) +def required_517 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_517 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_517 : Fin 4 → Finset Cell := ![(placed21 3 (1, 4) required_74), required_517_i0, required_517_i1, required_517_i3] +def childrenD_517 : Fin 4 → Finset Cell := ![(placed21 3 (1, 4) envelope_74), envelope_517_i0, envelope_517_i1, envelope_517_i3] +theorem common_sub_517 : commonEnvelope childrenD_517 ⊆ insert (4, 4) required_517 := by decide +kernel +theorem child_required_sub_517 : ∀ j, childrenC_517 j ⊆ insert (4, 4) required_517 := by decide +kernel +theorem child_envelope_sub_517 : ∀ j, childrenD_517 j ⊆ envelope_517 := by decide +kernel +theorem pivot_mem_517 : (4, 4) ∈ envelope_517 := by decide +kernel +theorem children_work_517 : ∀ j, Template HasSnaky 10 (childrenC_517 j) (childrenD_517 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_74 3 (1, 4)).mono (by decide +kernel) + · exact row_works_517_i0.mono (by decide +kernel) + · exact row_works_517_i1.mono (by decide +kernel) + · exact row_works_517_i3.mono (by decide +kernel) +theorem row_works_517 : Template HasSnaky 11 required_517 envelope_517 := by + refine compose HasSnaky 10 childrenC_517 childrenD_517 children_work_517 (4, 4) + required_517 envelope_517 pivot_mem_517 child_required_sub_517 child_envelope_sub_517 ?_ + intro b hb + exact common_sub_517 (mem_commonEnvelope childrenD_517 b hb) +def required_527_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_527_i0 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_527_i0 : Fin 2 → Finset Cell := ![(placed21 2 (2, 2) required_23), (placed21 4 (1, 6) required_198)] +def childrenD_527_i0 : Fin 2 → Finset Cell := ![(placed21 2 (2, 2) envelope_23), (placed21 4 (1, 6) envelope_198)] +theorem common_sub_527_i0 : commonEnvelope childrenD_527_i0 ⊆ insert (2, 5) required_527_i0 := by decide +kernel +theorem child_required_sub_527_i0 : ∀ j, childrenC_527_i0 j ⊆ insert (2, 5) required_527_i0 := by decide +kernel +theorem child_envelope_sub_527_i0 : ∀ j, childrenD_527_i0 j ⊆ envelope_527_i0 := by decide +kernel +theorem pivot_mem_527_i0 : (2, 5) ∈ envelope_527_i0 := by decide +kernel +theorem children_work_527_i0 : ∀ j, Template HasSnaky 3 (childrenC_527_i0 j) (childrenD_527_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_23 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_198 4 (1, 6)).mono (by decide +kernel) +theorem row_works_527_i0 : Template HasSnaky 4 required_527_i0 envelope_527_i0 := by + refine compose HasSnaky 3 childrenC_527_i0 childrenD_527_i0 children_work_527_i0 (2, 5) + required_527_i0 envelope_527_i0 pivot_mem_527_i0 child_required_sub_527_i0 child_envelope_sub_527_i0 ?_ + intro b hb + exact common_sub_527_i0 (mem_commonEnvelope childrenD_527_i0 b hb) +def required_527_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_527_i2 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_527_i2 : Fin 6 → Finset Cell := ![(placed21 4 (1, 6) required_392), (placed21 0 (1, 1) required_417), (placed21 0 (1, 2) required_420), (placed21 0 (1, 1) required_521), (placed21 4 (0, 5) required_522), (placed21 0 (1, 2) required_526)] +def childrenD_527_i2 : Fin 6 → Finset Cell := ![(placed21 4 (1, 6) envelope_392), (placed21 0 (1, 1) envelope_417), (placed21 0 (1, 2) envelope_420), (placed21 0 (1, 1) envelope_521), (placed21 4 (0, 5) envelope_522), (placed21 0 (1, 2) envelope_526)] +theorem common_sub_527_i2 : commonEnvelope childrenD_527_i2 ⊆ insert (3, 3) required_527_i2 := by decide +kernel +theorem child_required_sub_527_i2 : ∀ j, childrenC_527_i2 j ⊆ insert (3, 3) required_527_i2 := by decide +kernel +theorem child_envelope_sub_527_i2 : ∀ j, childrenD_527_i2 j ⊆ envelope_527_i2 := by decide +kernel +theorem pivot_mem_527_i2 : (3, 3) ∈ envelope_527_i2 := by decide +kernel +theorem children_work_527_i2 : ∀ j, Template HasSnaky 8 (childrenC_527_i2 j) (childrenD_527_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_392 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_417 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_420 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_521 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_522 4 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_526 0 (1, 2)).mono (by decide +kernel) +theorem row_works_527_i2 : Template HasSnaky 9 required_527_i2 envelope_527_i2 := by + refine compose HasSnaky 8 childrenC_527_i2 childrenD_527_i2 children_work_527_i2 (3, 3) + required_527_i2 envelope_527_i2 pivot_mem_527_i2 child_required_sub_527_i2 child_envelope_sub_527_i2 ?_ + intro b hb + exact common_sub_527_i2 (mem_commonEnvelope childrenD_527_i2 b hb) +def required_527_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 2), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_527_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_527_i1 : Fin 3 → Finset Cell := ![(placed21 0 (2, 1) required_7), (placed21 2 (2, 2) required_23), required_527_i2] +def childrenD_527_i1 : Fin 3 → Finset Cell := ![(placed21 0 (2, 1) envelope_7), (placed21 2 (2, 2) envelope_23), envelope_527_i2] +theorem common_sub_527_i1 : commonEnvelope childrenD_527_i1 ⊆ insert (2, 5) required_527_i1 := by decide +kernel +theorem child_required_sub_527_i1 : ∀ j, childrenC_527_i1 j ⊆ insert (2, 5) required_527_i1 := by decide +kernel +theorem child_envelope_sub_527_i1 : ∀ j, childrenD_527_i1 j ⊆ envelope_527_i1 := by decide +kernel +theorem pivot_mem_527_i1 : (2, 5) ∈ envelope_527_i1 := by decide +kernel +theorem children_work_527_i1 : ∀ j, Template HasSnaky 9 (childrenC_527_i1 j) (childrenD_527_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_23 2 (2, 2)).mono (by decide +kernel) + · exact row_works_527_i2.mono (by decide +kernel) +theorem row_works_527_i1 : Template HasSnaky 10 required_527_i1 envelope_527_i1 := by + refine compose HasSnaky 9 childrenC_527_i1 childrenD_527_i1 children_work_527_i1 (2, 5) + required_527_i1 envelope_527_i1 pivot_mem_527_i1 child_required_sub_527_i1 child_envelope_sub_527_i1 ?_ + intro b hb + exact common_sub_527_i1 (mem_commonEnvelope childrenD_527_i1 b hb) +def required_527 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_527 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_527 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) required_206), required_527_i0, (placed21 4 (1, 5) required_405), required_527_i1] +def childrenD_527 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) envelope_206), envelope_527_i0, (placed21 4 (1, 5) envelope_405), envelope_527_i1] +theorem common_sub_527 : commonEnvelope childrenD_527 ⊆ insert (2, 2) required_527 := by decide +kernel +theorem child_required_sub_527 : ∀ j, childrenC_527 j ⊆ insert (2, 2) required_527 := by decide +kernel +theorem child_envelope_sub_527 : ∀ j, childrenD_527 j ⊆ envelope_527 := by decide +kernel +theorem pivot_mem_527 : (2, 2) ∈ envelope_527 := by decide +kernel +theorem children_work_527 : ∀ j, Template HasSnaky 10 (childrenC_527 j) (childrenD_527 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_206 0 (1, 0)).mono (by decide +kernel) + · exact row_works_527_i0.mono (by decide +kernel) + · exact (placed21_template row_works_405 4 (1, 5)).mono (by decide +kernel) + · exact row_works_527_i1.mono (by decide +kernel) +theorem row_works_527 : Template HasSnaky 11 required_527 envelope_527 := by + refine compose HasSnaky 10 childrenC_527 childrenD_527 children_work_527 (2, 2) + required_527 envelope_527 pivot_mem_527 child_required_sub_527 child_envelope_sub_527 ?_ + intro b hb + exact common_sub_527 (mem_commonEnvelope childrenD_527 b hb) +def required_550 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_550 : Finset Cell := ⟨(([(0, 6), (0, 8), (1, 5), (1, 6), (1, 7), (1, 8), (2, 5), (2, 6), (2, 7), (2, 8), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 4), (7, 5), (8, 4), (8, 5), (8, 6), (9, 4), (9, 5), (9, 6), (10, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_550 : Fin 5 → Finset Cell := ![(placed21 3 (0, 6) required_390), (placed21 5 (8, 3) required_544), (placed21 6 (6, 10) required_545), (placed21 2 (6, 1) required_546), (placed21 2 (6, 0) required_548)] +def childrenD_550 : Fin 5 → Finset Cell := ![(placed21 3 (0, 6) envelope_390), (placed21 5 (8, 3) envelope_544), (placed21 6 (6, 10) envelope_545), (placed21 2 (6, 1) envelope_546), (placed21 2 (6, 0) envelope_548)] +theorem common_sub_550 : commonEnvelope childrenD_550 ⊆ insert (5, 6) required_550 := by decide +kernel +theorem child_required_sub_550 : ∀ j, childrenC_550 j ⊆ insert (5, 6) required_550 := by decide +kernel +theorem child_envelope_sub_550 : ∀ j, childrenD_550 j ⊆ envelope_550 := by decide +kernel +theorem pivot_mem_550 : (5, 6) ∈ envelope_550 := by decide +kernel +theorem children_work_550 : ∀ j, Template HasSnaky 10 (childrenC_550 j) (childrenD_550 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_390 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_544 5 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_545 6 (6, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_546 2 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_548 2 (6, 0)).mono (by decide +kernel) +theorem row_works_550 : Template HasSnaky 11 required_550 envelope_550 := by + refine compose HasSnaky 10 childrenC_550 childrenD_550 children_work_550 (5, 6) + required_550 envelope_550 pivot_mem_550 child_required_sub_550 child_envelope_sub_550 ?_ + intro b hb + exact common_sub_550 (mem_commonEnvelope childrenD_550 b hb) +def required_567_i4 : Finset Cell := ⟨(([(3, 3), (4, 2), (4, 4), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_567_i4 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 1), (3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 5), (5, 6), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_567_i4 : Fin 2 → Finset Cell := ![(placed21 1 (4, 2) required_5), (placed21 7 (6, 5) required_92)] +def childrenD_567_i4 : Fin 2 → Finset Cell := ![(placed21 1 (4, 2) envelope_5), (placed21 7 (6, 5) envelope_92)] +theorem common_sub_567_i4 : commonEnvelope childrenD_567_i4 ⊆ insert (4, 3) required_567_i4 := by decide +kernel +theorem child_required_sub_567_i4 : ∀ j, childrenC_567_i4 j ⊆ insert (4, 3) required_567_i4 := by decide +kernel +theorem child_envelope_sub_567_i4 : ∀ j, childrenD_567_i4 j ⊆ envelope_567_i4 := by decide +kernel +theorem pivot_mem_567_i4 : (4, 3) ∈ envelope_567_i4 := by decide +kernel +theorem children_work_567_i4 : ∀ j, Template HasSnaky 4 (childrenC_567_i4 j) (childrenD_567_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_92 7 (6, 5)).mono (by decide +kernel) +theorem row_works_567_i4 : Template HasSnaky 5 required_567_i4 envelope_567_i4 := by + refine compose HasSnaky 4 childrenC_567_i4 childrenD_567_i4 children_work_567_i4 (4, 3) + required_567_i4 envelope_567_i4 pivot_mem_567_i4 child_required_sub_567_i4 child_envelope_sub_567_i4 ?_ + intro b hb + exact common_sub_567_i4 (mem_commonEnvelope childrenD_567_i4 b hb) +def required_567_i3 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 4), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_567_i3 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 5), (5, 6), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_567_i3 : Fin 3 → Finset Cell := ![(placed21 4 (3, 5) required_94), (placed21 4 (3, 6) required_102), required_567_i4] +def childrenD_567_i3 : Fin 3 → Finset Cell := ![(placed21 4 (3, 5) envelope_94), (placed21 4 (3, 6) envelope_102), envelope_567_i4] +theorem common_sub_567_i3 : commonEnvelope childrenD_567_i3 ⊆ insert (4, 2) required_567_i3 := by decide +kernel +theorem child_required_sub_567_i3 : ∀ j, childrenC_567_i3 j ⊆ insert (4, 2) required_567_i3 := by decide +kernel +theorem child_envelope_sub_567_i3 : ∀ j, childrenD_567_i3 j ⊆ envelope_567_i3 := by decide +kernel +theorem pivot_mem_567_i3 : (4, 2) ∈ envelope_567_i3 := by decide +kernel +theorem children_work_567_i3 : ∀ j, Template HasSnaky 5 (childrenC_567_i3 j) (childrenD_567_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_94 4 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_102 4 (3, 6)).mono (by decide +kernel) + · exact row_works_567_i4.mono (by decide +kernel) +theorem row_works_567_i3 : Template HasSnaky 6 required_567_i3 envelope_567_i3 := by + refine compose HasSnaky 5 childrenC_567_i3 childrenD_567_i3 children_work_567_i3 (4, 2) + required_567_i3 envelope_567_i3 pivot_mem_567_i3 child_required_sub_567_i3 child_envelope_sub_567_i3 ?_ + intro b hb + exact common_sub_567_i3 (mem_commonEnvelope childrenD_567_i3 b hb) +def required_567_i2 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_567_i2 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 5), (5, 6), (6, 2), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_567_i2 : Fin 2 → Finset Cell := ![(placed21 6 (7, 5) required_0), required_567_i3] +def childrenD_567_i2 : Fin 2 → Finset Cell := ![(placed21 6 (7, 5) envelope_0), envelope_567_i3] +theorem common_sub_567_i2 : commonEnvelope childrenD_567_i2 ⊆ insert (4, 4) required_567_i2 := by decide +kernel +theorem child_required_sub_567_i2 : ∀ j, childrenC_567_i2 j ⊆ insert (4, 4) required_567_i2 := by decide +kernel +theorem child_envelope_sub_567_i2 : ∀ j, childrenD_567_i2 j ⊆ envelope_567_i2 := by decide +kernel +theorem pivot_mem_567_i2 : (4, 4) ∈ envelope_567_i2 := by decide +kernel +theorem children_work_567_i2 : ∀ j, Template HasSnaky 6 (childrenC_567_i2 j) (childrenD_567_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (7, 5)).mono (by decide +kernel) + · exact row_works_567_i3.mono (by decide +kernel) +theorem row_works_567_i2 : Template HasSnaky 7 required_567_i2 envelope_567_i2 := by + refine compose HasSnaky 6 childrenC_567_i2 childrenD_567_i2 children_work_567_i2 (4, 4) + required_567_i2 envelope_567_i2 pivot_mem_567_i2 child_required_sub_567_i2 child_envelope_sub_567_i2 ?_ + intro b hb + exact common_sub_567_i2 (mem_commonEnvelope childrenD_567_i2 b hb) +def required_567_i1 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_567_i1 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (6, 2), (6, 4), (6, 5), (7, 4), (7, 5), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_567_i1 : Fin 3 → Finset Cell := ![(placed21 3 (3, 5) required_16), (placed21 7 (7, 6) required_235), required_567_i2] +def childrenD_567_i1 : Fin 3 → Finset Cell := ![(placed21 3 (3, 5) envelope_16), (placed21 7 (7, 6) envelope_235), envelope_567_i2] +theorem common_sub_567_i1 : commonEnvelope childrenD_567_i1 ⊆ insert (6, 5) required_567_i1 := by decide +kernel +theorem child_required_sub_567_i1 : ∀ j, childrenC_567_i1 j ⊆ insert (6, 5) required_567_i1 := by decide +kernel +theorem child_envelope_sub_567_i1 : ∀ j, childrenD_567_i1 j ⊆ envelope_567_i1 := by decide +kernel +theorem pivot_mem_567_i1 : (6, 5) ∈ envelope_567_i1 := by decide +kernel +theorem children_work_567_i1 : ∀ j, Template HasSnaky 7 (childrenC_567_i1 j) (childrenD_567_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_16 3 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_235 7 (7, 6)).mono (by decide +kernel) + · exact row_works_567_i2.mono (by decide +kernel) +theorem row_works_567_i1 : Template HasSnaky 8 required_567_i1 envelope_567_i1 := by + refine compose HasSnaky 7 childrenC_567_i1 childrenD_567_i1 children_work_567_i1 (6, 5) + required_567_i1 envelope_567_i1 pivot_mem_567_i1 child_required_sub_567_i1 child_envelope_sub_567_i1 ?_ + intro b hb + exact common_sub_567_i1 (mem_commonEnvelope childrenD_567_i1 b hb) +def required_567_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_567_i0 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 4), (8, 5), (8, 6), (9, 4), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_567_i0 : Fin 7 → Finset Cell := ![(placed21 3 (1, 6) required_67), (placed21 4 (2, 7) required_134), (placed21 4 (2, 7) required_180), (placed21 6 (6, 9) required_327), (placed21 1 (1, 2) required_504), (placed21 4 (3, 7) required_558), required_567_i1] +def childrenD_567_i0 : Fin 7 → Finset Cell := ![(placed21 3 (1, 6) envelope_67), (placed21 4 (2, 7) envelope_134), (placed21 4 (2, 7) envelope_180), (placed21 6 (6, 9) envelope_327), (placed21 1 (1, 2) envelope_504), (placed21 4 (3, 7) envelope_558), envelope_567_i1] +theorem common_sub_567_i0 : commonEnvelope childrenD_567_i0 ⊆ insert (5, 5) required_567_i0 := by decide +kernel +theorem child_required_sub_567_i0 : ∀ j, childrenC_567_i0 j ⊆ insert (5, 5) required_567_i0 := by decide +kernel +theorem child_envelope_sub_567_i0 : ∀ j, childrenD_567_i0 j ⊆ envelope_567_i0 := by decide +kernel +theorem pivot_mem_567_i0 : (5, 5) ∈ envelope_567_i0 := by decide +kernel +theorem children_work_567_i0 : ∀ j, Template HasSnaky 9 (childrenC_567_i0 j) (childrenD_567_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_67 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_134 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_180 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_327 6 (6, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_504 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_558 4 (3, 7)).mono (by decide +kernel) + · exact row_works_567_i1.mono (by decide +kernel) +theorem row_works_567_i0 : Template HasSnaky 10 required_567_i0 envelope_567_i0 := by + refine compose HasSnaky 9 childrenC_567_i0 childrenD_567_i0 children_work_567_i0 (5, 5) + required_567_i0 envelope_567_i0 pivot_mem_567_i0 child_required_sub_567_i0 child_envelope_sub_567_i0 ?_ + intro b hb + exact common_sub_567_i0 (mem_commonEnvelope childrenD_567_i0 b hb) +def required_567 : Finset Cell := ⟨(([(0, 4), (1, 4), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_567 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 3), (1, 4), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 1), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (9, 4), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_567 : Fin 5 → Finset Cell := ![(placed21 4 (3, 6) required_27), (placed21 0 (3, 2) required_44), (placed21 0 (0, 1) required_560), (placed21 0 (2, 0) required_563), required_567_i0] +def childrenD_567 : Fin 5 → Finset Cell := ![(placed21 4 (3, 6) envelope_27), (placed21 0 (3, 2) envelope_44), (placed21 0 (0, 1) envelope_560), (placed21 0 (2, 0) envelope_563), envelope_567_i0] +theorem common_sub_567 : commonEnvelope childrenD_567 ⊆ insert (4, 5) required_567 := by decide +kernel +theorem child_required_sub_567 : ∀ j, childrenC_567 j ⊆ insert (4, 5) required_567 := by decide +kernel +theorem child_envelope_sub_567 : ∀ j, childrenD_567 j ⊆ envelope_567 := by decide +kernel +theorem pivot_mem_567 : (4, 5) ∈ envelope_567 := by decide +kernel +theorem children_work_567 : ∀ j, Template HasSnaky 10 (childrenC_567 j) (childrenD_567 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_27 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_44 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_560 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_563 0 (2, 0)).mono (by decide +kernel) + · exact row_works_567_i0.mono (by decide +kernel) +theorem row_works_567 : Template HasSnaky 11 required_567 envelope_567 := by + refine compose HasSnaky 10 childrenC_567 childrenD_567 children_work_567 (4, 5) + required_567 envelope_567 pivot_mem_567 child_required_sub_567 child_envelope_sub_567 ?_ + intro b hb + exact common_sub_567 (mem_commonEnvelope childrenD_567 b hb) +def required_579 : Finset Cell := ⟨(([(1, 4), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_579 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 6), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 4), (6, 5), (7, 3), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_579 : Fin 9 → Finset Cell := ![(placed21 0 (0, 1) required_118), (placed21 4 (0, 6) required_137), (placed21 0 (0, 1) required_172), (placed21 0 (0, 1) required_173), (placed21 4 (0, 6) required_181), (placed21 4 (0, 7) required_435), (placed21 0 (0, 1) required_507), (placed21 0 (0, 1) required_578), (placed21 4 (0, 7) required_578)] +def childrenD_579 : Fin 9 → Finset Cell := ![(placed21 0 (0, 1) envelope_118), (placed21 4 (0, 6) envelope_137), (placed21 0 (0, 1) envelope_172), (placed21 0 (0, 1) envelope_173), (placed21 4 (0, 6) envelope_181), (placed21 4 (0, 7) envelope_435), (placed21 0 (0, 1) envelope_507), (placed21 0 (0, 1) envelope_578), (placed21 4 (0, 7) envelope_578)] +theorem common_sub_579 : commonEnvelope childrenD_579 ⊆ insert (3, 4) required_579 := by decide +kernel +theorem child_required_sub_579 : ∀ j, childrenC_579 j ⊆ insert (3, 4) required_579 := by decide +kernel +theorem child_envelope_sub_579 : ∀ j, childrenD_579 j ⊆ envelope_579 := by decide +kernel +theorem pivot_mem_579 : (3, 4) ∈ envelope_579 := by decide +kernel +theorem children_work_579 : ∀ j, Template HasSnaky 10 (childrenC_579 j) (childrenD_579 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_118 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_137 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_172 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_173 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_181 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_435 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_507 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_578 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_578 4 (0, 7)).mono (by decide +kernel) +theorem row_works_579 : Template HasSnaky 11 required_579 envelope_579 := by + refine compose HasSnaky 10 childrenC_579 childrenD_579 children_work_579 (3, 4) + required_579 envelope_579 pivot_mem_579 child_required_sub_579 child_envelope_sub_579 ?_ + intro b hb + exact common_sub_579 (mem_commonEnvelope childrenD_579 b hb) +def required_581 : Finset Cell := ⟨(([(4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_581 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4), (7, 5), (7, 6), (7, 7), (8, 4), (8, 5), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_581 : Fin 6 → Finset Cell := ![(placed21 0 (2, 2) required_188), (placed21 2 (6, 2) required_188), (placed21 5 (7, 4) required_258), (placed21 7 (7, 7) required_309), (placed21 1 (1, 3) required_578), (placed21 5 (7, 3) required_578)] +def childrenD_581 : Fin 6 → Finset Cell := ![(placed21 0 (2, 2) envelope_188), (placed21 2 (6, 2) envelope_188), (placed21 5 (7, 4) envelope_258), (placed21 7 (7, 7) envelope_309), (placed21 1 (1, 3) envelope_578), (placed21 5 (7, 3) envelope_578)] +theorem common_sub_581 : commonEnvelope childrenD_581 ⊆ insert (4, 6) required_581 := by decide +kernel +theorem child_required_sub_581 : ∀ j, childrenC_581 j ⊆ insert (4, 6) required_581 := by decide +kernel +theorem child_envelope_sub_581 : ∀ j, childrenD_581 j ⊆ envelope_581 := by decide +kernel +theorem pivot_mem_581 : (4, 6) ∈ envelope_581 := by decide +kernel +theorem children_work_581 : ∀ j, Template HasSnaky 10 (childrenC_581 j) (childrenD_581 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_188 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_188 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_258 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_309 7 (7, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_578 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_578 5 (7, 3)).mono (by decide +kernel) +theorem row_works_581 : Template HasSnaky 11 required_581 envelope_581 := by + refine compose HasSnaky 10 childrenC_581 childrenD_581 children_work_581 (4, 6) + required_581 envelope_581 pivot_mem_581 child_required_sub_581 child_envelope_sub_581 ?_ + intro b hb + exact common_sub_581 (mem_commonEnvelope childrenD_581 b hb) +def required_586 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_586 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 4), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_586 : Fin 3 → Finset Cell := ![(placed21 0 (1, 1) required_8), required_179, required_585] +def childrenD_586 : Fin 3 → Finset Cell := ![(placed21 0 (1, 1) envelope_8), envelope_179, envelope_585] +theorem common_sub_586 : commonEnvelope childrenD_586 ⊆ insert (4, 2) required_586 := by decide +kernel +theorem child_required_sub_586 : ∀ j, childrenC_586 j ⊆ insert (4, 2) required_586 := by decide +kernel +theorem child_envelope_sub_586 : ∀ j, childrenD_586 j ⊆ envelope_586 := by decide +kernel +theorem pivot_mem_586 : (4, 2) ∈ envelope_586 := by decide +kernel +theorem children_work_586 : ∀ j, Template HasSnaky 10 (childrenC_586 j) (childrenD_586 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (1, 1)).mono (by decide +kernel) + · exact row_works_179.mono (by decide +kernel) + · exact row_works_585.mono (by decide +kernel) +theorem row_works_586 : Template HasSnaky 11 required_586 envelope_586 := by + refine compose HasSnaky 10 childrenC_586 childrenD_586 children_work_586 (4, 2) + required_586 envelope_586 pivot_mem_586 child_required_sub_586 child_envelope_sub_586 ?_ + intro b hb + exact common_sub_586 (mem_commonEnvelope childrenD_586 b hb) +def required_589 : Finset Cell := ⟨(([(1, 2), (2, 2), (3, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_589 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_589 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) required_7), (placed21 0 (1, 1) required_8), (placed21 3 (0, 3) required_9), (placed21 2 (5, 0) required_585)] +def childrenD_589 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) envelope_7), (placed21 0 (1, 1) envelope_8), (placed21 3 (0, 3) envelope_9), (placed21 2 (5, 0) envelope_585)] +theorem common_sub_589 : commonEnvelope childrenD_589 ⊆ insert (4, 2) required_589 := by decide +kernel +theorem child_required_sub_589 : ∀ j, childrenC_589 j ⊆ insert (4, 2) required_589 := by decide +kernel +theorem child_envelope_sub_589 : ∀ j, childrenD_589 j ⊆ envelope_589 := by decide +kernel +theorem pivot_mem_589 : (4, 2) ∈ envelope_589 := by decide +kernel +theorem children_work_589 : ∀ j, Template HasSnaky 10 (childrenC_589 j) (childrenD_589 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_8 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_585 2 (5, 0)).mono (by decide +kernel) +theorem row_works_589 : Template HasSnaky 11 required_589 envelope_589 := by + refine compose HasSnaky 10 childrenC_589 childrenD_589 children_work_589 (4, 2) + required_589 envelope_589 pivot_mem_589 child_required_sub_589 child_envelope_sub_589 ?_ + intro b hb + exact common_sub_589 (mem_commonEnvelope childrenD_589 b hb) +def height_517_i0 : ℕ := 8 +def childrenH_517_i0 : Fin 2 → ℕ := ![height_0, height_404] +theorem height_exact_517_i0 : height_517_i0 = 1 + Finset.univ.sup childrenH_517_i0 := by decide +kernel +theorem required_origin_517_i0 : ∀ x ∈ required_517_i0, + (∃ j, x ∈ childrenC_517_i0 j) ∨ ∀ j, x ∈ childrenD_517_i0 j := by decide +kernel +theorem required_exact_517_i0 : required_517_i0 = + ((Finset.univ.biUnion childrenC_517_i0) ∪ commonEnvelope childrenD_517_i0).erase (3, 4) := by + exact required_eq_combination childrenC_517_i0 childrenD_517_i0 (3, 4) required_517_i0 + (by decide +kernel) child_required_sub_517_i0 common_sub_517_i0 required_origin_517_i0 +theorem envelope_origin_517_i0 : ∀ x ∈ envelope_517_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_517_i0 j := by decide +kernel +theorem envelope_exact_517_i0 : envelope_517_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_517_i0) := by + exact envelope_eq_combination childrenD_517_i0 (3, 4) envelope_517_i0 + pivot_mem_517_i0 child_envelope_sub_517_i0 envelope_origin_517_i0 +def checked_517_i0 : CheckedCard where + required := required_517_i0 + envelope := envelope_517_i0 + height := height_517_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_517_i0 +def height_517_i2 : ℕ := 9 +def childrenH_517_i2 : Fin 5 → ℕ := ![height_14, height_79, height_367, height_513, height_516] +theorem height_exact_517_i2 : height_517_i2 = 1 + Finset.univ.sup childrenH_517_i2 := by decide +kernel +theorem required_origin_517_i2 : ∀ x ∈ required_517_i2, + (∃ j, x ∈ childrenC_517_i2 j) ∨ ∀ j, x ∈ childrenD_517_i2 j := by decide +kernel +theorem required_exact_517_i2 : required_517_i2 = + ((Finset.univ.biUnion childrenC_517_i2) ∪ commonEnvelope childrenD_517_i2).erase (4, 5) := by + exact required_eq_combination childrenC_517_i2 childrenD_517_i2 (4, 5) required_517_i2 + (by decide +kernel) child_required_sub_517_i2 common_sub_517_i2 required_origin_517_i2 +theorem envelope_origin_517_i2 : ∀ x ∈ envelope_517_i2, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_517_i2 j := by decide +kernel +theorem envelope_exact_517_i2 : envelope_517_i2 = + insert (4, 5) (Finset.univ.biUnion childrenD_517_i2) := by + exact envelope_eq_combination childrenD_517_i2 (4, 5) envelope_517_i2 + pivot_mem_517_i2 child_envelope_sub_517_i2 envelope_origin_517_i2 +def checked_517_i2 : CheckedCard where + required := required_517_i2 + envelope := envelope_517_i2 + height := height_517_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_517_i2 +def height_517_i1 : ℕ := 10 +def childrenH_517_i1 : Fin 4 → ℕ := ![height_30, height_59, height_346, height_517_i2] +theorem height_exact_517_i1 : height_517_i1 = 1 + Finset.univ.sup childrenH_517_i1 := by decide +kernel +theorem required_origin_517_i1 : ∀ x ∈ required_517_i1, + (∃ j, x ∈ childrenC_517_i1 j) ∨ ∀ j, x ∈ childrenD_517_i1 j := by decide +kernel +theorem required_exact_517_i1 : required_517_i1 = + ((Finset.univ.biUnion childrenC_517_i1) ∪ commonEnvelope childrenD_517_i1).erase (4, 3) := by + exact required_eq_combination childrenC_517_i1 childrenD_517_i1 (4, 3) required_517_i1 + (by decide +kernel) child_required_sub_517_i1 common_sub_517_i1 required_origin_517_i1 +theorem envelope_origin_517_i1 : ∀ x ∈ envelope_517_i1, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_517_i1 j := by decide +kernel +theorem envelope_exact_517_i1 : envelope_517_i1 = + insert (4, 3) (Finset.univ.biUnion childrenD_517_i1) := by + exact envelope_eq_combination childrenD_517_i1 (4, 3) envelope_517_i1 + pivot_mem_517_i1 child_envelope_sub_517_i1 envelope_origin_517_i1 +def checked_517_i1 : CheckedCard where + required := required_517_i1 + envelope := envelope_517_i1 + height := height_517_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_517_i1 +def height_517_i4 : ℕ := 7 +def childrenH_517_i4 : Fin 4 → ℕ := ![height_14, height_58, height_79, height_429] +theorem height_exact_517_i4 : height_517_i4 = 1 + Finset.univ.sup childrenH_517_i4 := by decide +kernel +theorem required_origin_517_i4 : ∀ x ∈ required_517_i4, + (∃ j, x ∈ childrenC_517_i4 j) ∨ ∀ j, x ∈ childrenD_517_i4 j := by decide +kernel +theorem required_exact_517_i4 : required_517_i4 = + ((Finset.univ.biUnion childrenC_517_i4) ∪ commonEnvelope childrenD_517_i4).erase (4, 5) := by + exact required_eq_combination childrenC_517_i4 childrenD_517_i4 (4, 5) required_517_i4 + (by decide +kernel) child_required_sub_517_i4 common_sub_517_i4 required_origin_517_i4 +theorem envelope_origin_517_i4 : ∀ x ∈ envelope_517_i4, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_517_i4 j := by decide +kernel +theorem envelope_exact_517_i4 : envelope_517_i4 = + insert (4, 5) (Finset.univ.biUnion childrenD_517_i4) := by + exact envelope_eq_combination childrenD_517_i4 (4, 5) envelope_517_i4 + pivot_mem_517_i4 child_envelope_sub_517_i4 envelope_origin_517_i4 +def checked_517_i4 : CheckedCard where + required := required_517_i4 + envelope := envelope_517_i4 + height := height_517_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_517_i4 +def height_517_i3 : ℕ := 8 +def childrenH_517_i3 : Fin 4 → ℕ := ![height_36, height_59, height_346, height_517_i4] +theorem height_exact_517_i3 : height_517_i3 = 1 + Finset.univ.sup childrenH_517_i3 := by decide +kernel +theorem required_origin_517_i3 : ∀ x ∈ required_517_i3, + (∃ j, x ∈ childrenC_517_i3 j) ∨ ∀ j, x ∈ childrenD_517_i3 j := by decide +kernel +theorem required_exact_517_i3 : required_517_i3 = + ((Finset.univ.biUnion childrenC_517_i3) ∪ commonEnvelope childrenD_517_i3).erase (4, 3) := by + exact required_eq_combination childrenC_517_i3 childrenD_517_i3 (4, 3) required_517_i3 + (by decide +kernel) child_required_sub_517_i3 common_sub_517_i3 required_origin_517_i3 +theorem envelope_origin_517_i3 : ∀ x ∈ envelope_517_i3, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_517_i3 j := by decide +kernel +theorem envelope_exact_517_i3 : envelope_517_i3 = + insert (4, 3) (Finset.univ.biUnion childrenD_517_i3) := by + exact envelope_eq_combination childrenD_517_i3 (4, 3) envelope_517_i3 + pivot_mem_517_i3 child_envelope_sub_517_i3 envelope_origin_517_i3 +def checked_517_i3 : CheckedCard where + required := required_517_i3 + envelope := envelope_517_i3 + height := height_517_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_517_i3 +def height_517 : ℕ := 11 +def childrenH_517 : Fin 4 → ℕ := ![height_74, height_517_i0, height_517_i1, height_517_i3] +theorem height_exact_517 : height_517 = 1 + Finset.univ.sup childrenH_517 := by decide +kernel +theorem required_origin_517 : ∀ x ∈ required_517, + (∃ j, x ∈ childrenC_517 j) ∨ ∀ j, x ∈ childrenD_517 j := by decide +kernel +theorem required_exact_517 : required_517 = + ((Finset.univ.biUnion childrenC_517) ∪ commonEnvelope childrenD_517).erase (4, 4) := by + exact required_eq_combination childrenC_517 childrenD_517 (4, 4) required_517 + (by decide +kernel) child_required_sub_517 common_sub_517 required_origin_517 +theorem envelope_origin_517 : ∀ x ∈ envelope_517, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_517 j := by decide +kernel +theorem envelope_exact_517 : envelope_517 = + insert (4, 4) (Finset.univ.biUnion childrenD_517) := by + exact envelope_eq_combination childrenD_517 (4, 4) envelope_517 + pivot_mem_517 child_envelope_sub_517 envelope_origin_517 +def checked_517 : CheckedCard where + required := required_517 + envelope := envelope_517 + height := height_517 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_517 +def height_527_i0 : ℕ := 4 +def childrenH_527_i0 : Fin 2 → ℕ := ![height_23, height_198] +theorem height_exact_527_i0 : height_527_i0 = 1 + Finset.univ.sup childrenH_527_i0 := by decide +kernel +theorem required_origin_527_i0 : ∀ x ∈ required_527_i0, + (∃ j, x ∈ childrenC_527_i0 j) ∨ ∀ j, x ∈ childrenD_527_i0 j := by decide +kernel +theorem required_exact_527_i0 : required_527_i0 = + ((Finset.univ.biUnion childrenC_527_i0) ∪ commonEnvelope childrenD_527_i0).erase (2, 5) := by + exact required_eq_combination childrenC_527_i0 childrenD_527_i0 (2, 5) required_527_i0 + (by decide +kernel) child_required_sub_527_i0 common_sub_527_i0 required_origin_527_i0 +theorem envelope_origin_527_i0 : ∀ x ∈ envelope_527_i0, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_527_i0 j := by decide +kernel +theorem envelope_exact_527_i0 : envelope_527_i0 = + insert (2, 5) (Finset.univ.biUnion childrenD_527_i0) := by + exact envelope_eq_combination childrenD_527_i0 (2, 5) envelope_527_i0 + pivot_mem_527_i0 child_envelope_sub_527_i0 envelope_origin_527_i0 +def checked_527_i0 : CheckedCard where + required := required_527_i0 + envelope := envelope_527_i0 + height := height_527_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_527_i0 +def height_527_i2 : ℕ := 9 +def childrenH_527_i2 : Fin 6 → ℕ := ![height_392, height_417, height_420, height_521, height_522, height_526] +theorem height_exact_527_i2 : height_527_i2 = 1 + Finset.univ.sup childrenH_527_i2 := by decide +kernel +theorem required_origin_527_i2 : ∀ x ∈ required_527_i2, + (∃ j, x ∈ childrenC_527_i2 j) ∨ ∀ j, x ∈ childrenD_527_i2 j := by decide +kernel +theorem required_exact_527_i2 : required_527_i2 = + ((Finset.univ.biUnion childrenC_527_i2) ∪ commonEnvelope childrenD_527_i2).erase (3, 3) := by + exact required_eq_combination childrenC_527_i2 childrenD_527_i2 (3, 3) required_527_i2 + (by decide +kernel) child_required_sub_527_i2 common_sub_527_i2 required_origin_527_i2 +theorem envelope_origin_527_i2 : ∀ x ∈ envelope_527_i2, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_527_i2 j := by decide +kernel +theorem envelope_exact_527_i2 : envelope_527_i2 = + insert (3, 3) (Finset.univ.biUnion childrenD_527_i2) := by + exact envelope_eq_combination childrenD_527_i2 (3, 3) envelope_527_i2 + pivot_mem_527_i2 child_envelope_sub_527_i2 envelope_origin_527_i2 +def checked_527_i2 : CheckedCard where + required := required_527_i2 + envelope := envelope_527_i2 + height := height_527_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_527_i2 +def height_527_i1 : ℕ := 10 +def childrenH_527_i1 : Fin 3 → ℕ := ![height_7, height_23, height_527_i2] +theorem height_exact_527_i1 : height_527_i1 = 1 + Finset.univ.sup childrenH_527_i1 := by decide +kernel +theorem required_origin_527_i1 : ∀ x ∈ required_527_i1, + (∃ j, x ∈ childrenC_527_i1 j) ∨ ∀ j, x ∈ childrenD_527_i1 j := by decide +kernel +theorem required_exact_527_i1 : required_527_i1 = + ((Finset.univ.biUnion childrenC_527_i1) ∪ commonEnvelope childrenD_527_i1).erase (2, 5) := by + exact required_eq_combination childrenC_527_i1 childrenD_527_i1 (2, 5) required_527_i1 + (by decide +kernel) child_required_sub_527_i1 common_sub_527_i1 required_origin_527_i1 +theorem envelope_origin_527_i1 : ∀ x ∈ envelope_527_i1, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_527_i1 j := by decide +kernel +theorem envelope_exact_527_i1 : envelope_527_i1 = + insert (2, 5) (Finset.univ.biUnion childrenD_527_i1) := by + exact envelope_eq_combination childrenD_527_i1 (2, 5) envelope_527_i1 + pivot_mem_527_i1 child_envelope_sub_527_i1 envelope_origin_527_i1 +def checked_527_i1 : CheckedCard where + required := required_527_i1 + envelope := envelope_527_i1 + height := height_527_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_527_i1 +def height_527 : ℕ := 11 +def childrenH_527 : Fin 4 → ℕ := ![height_206, height_527_i0, height_405, height_527_i1] +theorem height_exact_527 : height_527 = 1 + Finset.univ.sup childrenH_527 := by decide +kernel +theorem required_origin_527 : ∀ x ∈ required_527, + (∃ j, x ∈ childrenC_527 j) ∨ ∀ j, x ∈ childrenD_527 j := by decide +kernel +theorem required_exact_527 : required_527 = + ((Finset.univ.biUnion childrenC_527) ∪ commonEnvelope childrenD_527).erase (2, 2) := by + exact required_eq_combination childrenC_527 childrenD_527 (2, 2) required_527 + (by decide +kernel) child_required_sub_527 common_sub_527 required_origin_527 +theorem envelope_origin_527 : ∀ x ∈ envelope_527, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_527 j := by decide +kernel +theorem envelope_exact_527 : envelope_527 = + insert (2, 2) (Finset.univ.biUnion childrenD_527) := by + exact envelope_eq_combination childrenD_527 (2, 2) envelope_527 + pivot_mem_527 child_envelope_sub_527 envelope_origin_527 +def checked_527 : CheckedCard where + required := required_527 + envelope := envelope_527 + height := height_527 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_527 +def height_550 : ℕ := 11 +def childrenH_550 : Fin 5 → ℕ := ![height_390, height_544, height_545, height_546, height_548] +theorem height_exact_550 : height_550 = 1 + Finset.univ.sup childrenH_550 := by decide +kernel +theorem required_origin_550 : ∀ x ∈ required_550, + (∃ j, x ∈ childrenC_550 j) ∨ ∀ j, x ∈ childrenD_550 j := by decide +kernel +theorem required_exact_550 : required_550 = + ((Finset.univ.biUnion childrenC_550) ∪ commonEnvelope childrenD_550).erase (5, 6) := by + exact required_eq_combination childrenC_550 childrenD_550 (5, 6) required_550 + (by decide +kernel) child_required_sub_550 common_sub_550 required_origin_550 +theorem envelope_origin_550 : ∀ x ∈ envelope_550, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_550 j := by decide +kernel +theorem envelope_exact_550 : envelope_550 = + insert (5, 6) (Finset.univ.biUnion childrenD_550) := by + exact envelope_eq_combination childrenD_550 (5, 6) envelope_550 + pivot_mem_550 child_envelope_sub_550 envelope_origin_550 +def checked_550 : CheckedCard where + required := required_550 + envelope := envelope_550 + height := height_550 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_550 +def height_567_i4 : ℕ := 5 +def childrenH_567_i4 : Fin 2 → ℕ := ![height_5, height_92] +theorem height_exact_567_i4 : height_567_i4 = 1 + Finset.univ.sup childrenH_567_i4 := by decide +kernel +theorem required_origin_567_i4 : ∀ x ∈ required_567_i4, + (∃ j, x ∈ childrenC_567_i4 j) ∨ ∀ j, x ∈ childrenD_567_i4 j := by decide +kernel +theorem required_exact_567_i4 : required_567_i4 = + ((Finset.univ.biUnion childrenC_567_i4) ∪ commonEnvelope childrenD_567_i4).erase (4, 3) := by + exact required_eq_combination childrenC_567_i4 childrenD_567_i4 (4, 3) required_567_i4 + (by decide +kernel) child_required_sub_567_i4 common_sub_567_i4 required_origin_567_i4 +theorem envelope_origin_567_i4 : ∀ x ∈ envelope_567_i4, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_567_i4 j := by decide +kernel +theorem envelope_exact_567_i4 : envelope_567_i4 = + insert (4, 3) (Finset.univ.biUnion childrenD_567_i4) := by + exact envelope_eq_combination childrenD_567_i4 (4, 3) envelope_567_i4 + pivot_mem_567_i4 child_envelope_sub_567_i4 envelope_origin_567_i4 +def checked_567_i4 : CheckedCard where + required := required_567_i4 + envelope := envelope_567_i4 + height := height_567_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_567_i4 +def height_567_i3 : ℕ := 6 +def childrenH_567_i3 : Fin 3 → ℕ := ![height_94, height_102, height_567_i4] +theorem height_exact_567_i3 : height_567_i3 = 1 + Finset.univ.sup childrenH_567_i3 := by decide +kernel +theorem required_origin_567_i3 : ∀ x ∈ required_567_i3, + (∃ j, x ∈ childrenC_567_i3 j) ∨ ∀ j, x ∈ childrenD_567_i3 j := by decide +kernel +theorem required_exact_567_i3 : required_567_i3 = + ((Finset.univ.biUnion childrenC_567_i3) ∪ commonEnvelope childrenD_567_i3).erase (4, 2) := by + exact required_eq_combination childrenC_567_i3 childrenD_567_i3 (4, 2) required_567_i3 + (by decide +kernel) child_required_sub_567_i3 common_sub_567_i3 required_origin_567_i3 +theorem envelope_origin_567_i3 : ∀ x ∈ envelope_567_i3, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_567_i3 j := by decide +kernel +theorem envelope_exact_567_i3 : envelope_567_i3 = + insert (4, 2) (Finset.univ.biUnion childrenD_567_i3) := by + exact envelope_eq_combination childrenD_567_i3 (4, 2) envelope_567_i3 + pivot_mem_567_i3 child_envelope_sub_567_i3 envelope_origin_567_i3 +def checked_567_i3 : CheckedCard where + required := required_567_i3 + envelope := envelope_567_i3 + height := height_567_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_567_i3 +def height_567_i2 : ℕ := 7 +def childrenH_567_i2 : Fin 2 → ℕ := ![height_0, height_567_i3] +theorem height_exact_567_i2 : height_567_i2 = 1 + Finset.univ.sup childrenH_567_i2 := by decide +kernel +theorem required_origin_567_i2 : ∀ x ∈ required_567_i2, + (∃ j, x ∈ childrenC_567_i2 j) ∨ ∀ j, x ∈ childrenD_567_i2 j := by decide +kernel +theorem required_exact_567_i2 : required_567_i2 = + ((Finset.univ.biUnion childrenC_567_i2) ∪ commonEnvelope childrenD_567_i2).erase (4, 4) := by + exact required_eq_combination childrenC_567_i2 childrenD_567_i2 (4, 4) required_567_i2 + (by decide +kernel) child_required_sub_567_i2 common_sub_567_i2 required_origin_567_i2 +theorem envelope_origin_567_i2 : ∀ x ∈ envelope_567_i2, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_567_i2 j := by decide +kernel +theorem envelope_exact_567_i2 : envelope_567_i2 = + insert (4, 4) (Finset.univ.biUnion childrenD_567_i2) := by + exact envelope_eq_combination childrenD_567_i2 (4, 4) envelope_567_i2 + pivot_mem_567_i2 child_envelope_sub_567_i2 envelope_origin_567_i2 +def checked_567_i2 : CheckedCard where + required := required_567_i2 + envelope := envelope_567_i2 + height := height_567_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_567_i2 +def height_567_i1 : ℕ := 8 +def childrenH_567_i1 : Fin 3 → ℕ := ![height_16, height_235, height_567_i2] +theorem height_exact_567_i1 : height_567_i1 = 1 + Finset.univ.sup childrenH_567_i1 := by decide +kernel +theorem required_origin_567_i1 : ∀ x ∈ required_567_i1, + (∃ j, x ∈ childrenC_567_i1 j) ∨ ∀ j, x ∈ childrenD_567_i1 j := by decide +kernel +theorem required_exact_567_i1 : required_567_i1 = + ((Finset.univ.biUnion childrenC_567_i1) ∪ commonEnvelope childrenD_567_i1).erase (6, 5) := by + exact required_eq_combination childrenC_567_i1 childrenD_567_i1 (6, 5) required_567_i1 + (by decide +kernel) child_required_sub_567_i1 common_sub_567_i1 required_origin_567_i1 +theorem envelope_origin_567_i1 : ∀ x ∈ envelope_567_i1, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_567_i1 j := by decide +kernel +theorem envelope_exact_567_i1 : envelope_567_i1 = + insert (6, 5) (Finset.univ.biUnion childrenD_567_i1) := by + exact envelope_eq_combination childrenD_567_i1 (6, 5) envelope_567_i1 + pivot_mem_567_i1 child_envelope_sub_567_i1 envelope_origin_567_i1 +def checked_567_i1 : CheckedCard where + required := required_567_i1 + envelope := envelope_567_i1 + height := height_567_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_567_i1 +def height_567_i0 : ℕ := 10 +def childrenH_567_i0 : Fin 7 → ℕ := ![height_67, height_134, height_180, height_327, height_504, height_558, height_567_i1] +theorem height_exact_567_i0 : height_567_i0 = 1 + Finset.univ.sup childrenH_567_i0 := by decide +kernel +theorem required_origin_567_i0 : ∀ x ∈ required_567_i0, + (∃ j, x ∈ childrenC_567_i0 j) ∨ ∀ j, x ∈ childrenD_567_i0 j := by decide +kernel +theorem required_exact_567_i0 : required_567_i0 = + ((Finset.univ.biUnion childrenC_567_i0) ∪ commonEnvelope childrenD_567_i0).erase (5, 5) := by + exact required_eq_combination childrenC_567_i0 childrenD_567_i0 (5, 5) required_567_i0 + (by decide +kernel) child_required_sub_567_i0 common_sub_567_i0 required_origin_567_i0 +theorem envelope_origin_567_i0 : ∀ x ∈ envelope_567_i0, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_567_i0 j := by decide +kernel +theorem envelope_exact_567_i0 : envelope_567_i0 = + insert (5, 5) (Finset.univ.biUnion childrenD_567_i0) := by + exact envelope_eq_combination childrenD_567_i0 (5, 5) envelope_567_i0 + pivot_mem_567_i0 child_envelope_sub_567_i0 envelope_origin_567_i0 +def checked_567_i0 : CheckedCard where + required := required_567_i0 + envelope := envelope_567_i0 + height := height_567_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_567_i0 +def height_567 : ℕ := 11 +def childrenH_567 : Fin 5 → ℕ := ![height_27, height_44, height_560, height_563, height_567_i0] +theorem height_exact_567 : height_567 = 1 + Finset.univ.sup childrenH_567 := by decide +kernel +theorem required_origin_567 : ∀ x ∈ required_567, + (∃ j, x ∈ childrenC_567 j) ∨ ∀ j, x ∈ childrenD_567 j := by decide +kernel +theorem required_exact_567 : required_567 = + ((Finset.univ.biUnion childrenC_567) ∪ commonEnvelope childrenD_567).erase (4, 5) := by + exact required_eq_combination childrenC_567 childrenD_567 (4, 5) required_567 + (by decide +kernel) child_required_sub_567 common_sub_567 required_origin_567 +theorem envelope_origin_567 : ∀ x ∈ envelope_567, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_567 j := by decide +kernel +theorem envelope_exact_567 : envelope_567 = + insert (4, 5) (Finset.univ.biUnion childrenD_567) := by + exact envelope_eq_combination childrenD_567 (4, 5) envelope_567 + pivot_mem_567 child_envelope_sub_567 envelope_origin_567 +def checked_567 : CheckedCard where + required := required_567 + envelope := envelope_567 + height := height_567 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_567 +def height_579 : ℕ := 11 +def childrenH_579 : Fin 9 → ℕ := ![height_118, height_137, height_172, height_173, height_181, height_435, height_507, height_578, height_578] +theorem height_exact_579 : height_579 = 1 + Finset.univ.sup childrenH_579 := by decide +kernel +theorem required_origin_579 : ∀ x ∈ required_579, + (∃ j, x ∈ childrenC_579 j) ∨ ∀ j, x ∈ childrenD_579 j := by decide +kernel +theorem required_exact_579 : required_579 = + ((Finset.univ.biUnion childrenC_579) ∪ commonEnvelope childrenD_579).erase (3, 4) := by + exact required_eq_combination childrenC_579 childrenD_579 (3, 4) required_579 + (by decide +kernel) child_required_sub_579 common_sub_579 required_origin_579 +theorem envelope_origin_579 : ∀ x ∈ envelope_579, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_579 j := by decide +kernel +theorem envelope_exact_579 : envelope_579 = + insert (3, 4) (Finset.univ.biUnion childrenD_579) := by + exact envelope_eq_combination childrenD_579 (3, 4) envelope_579 + pivot_mem_579 child_envelope_sub_579 envelope_origin_579 +def checked_579 : CheckedCard where + required := required_579 + envelope := envelope_579 + height := height_579 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_579 +def height_581 : ℕ := 11 +def childrenH_581 : Fin 6 → ℕ := ![height_188, height_188, height_258, height_309, height_578, height_578] +theorem height_exact_581 : height_581 = 1 + Finset.univ.sup childrenH_581 := by decide +kernel +theorem required_origin_581 : ∀ x ∈ required_581, + (∃ j, x ∈ childrenC_581 j) ∨ ∀ j, x ∈ childrenD_581 j := by decide +kernel +theorem required_exact_581 : required_581 = + ((Finset.univ.biUnion childrenC_581) ∪ commonEnvelope childrenD_581).erase (4, 6) := by + exact required_eq_combination childrenC_581 childrenD_581 (4, 6) required_581 + (by decide +kernel) child_required_sub_581 common_sub_581 required_origin_581 +theorem envelope_origin_581 : ∀ x ∈ envelope_581, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_581 j := by decide +kernel +theorem envelope_exact_581 : envelope_581 = + insert (4, 6) (Finset.univ.biUnion childrenD_581) := by + exact envelope_eq_combination childrenD_581 (4, 6) envelope_581 + pivot_mem_581 child_envelope_sub_581 envelope_origin_581 +def checked_581 : CheckedCard where + required := required_581 + envelope := envelope_581 + height := height_581 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_581 +def height_586 : ℕ := 11 +def childrenH_586 : Fin 3 → ℕ := ![height_8, height_179, height_585] +theorem height_exact_586 : height_586 = 1 + Finset.univ.sup childrenH_586 := by decide +kernel +theorem required_origin_586 : ∀ x ∈ required_586, + (∃ j, x ∈ childrenC_586 j) ∨ ∀ j, x ∈ childrenD_586 j := by decide +kernel +theorem required_exact_586 : required_586 = + ((Finset.univ.biUnion childrenC_586) ∪ commonEnvelope childrenD_586).erase (4, 2) := by + exact required_eq_combination childrenC_586 childrenD_586 (4, 2) required_586 + (by decide +kernel) child_required_sub_586 common_sub_586 required_origin_586 +theorem envelope_origin_586 : ∀ x ∈ envelope_586, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_586 j := by decide +kernel +theorem envelope_exact_586 : envelope_586 = + insert (4, 2) (Finset.univ.biUnion childrenD_586) := by + exact envelope_eq_combination childrenD_586 (4, 2) envelope_586 + pivot_mem_586 child_envelope_sub_586 envelope_origin_586 +def checked_586 : CheckedCard where + required := required_586 + envelope := envelope_586 + height := height_586 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_586 +def height_589 : ℕ := 11 +def childrenH_589 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_585] +theorem height_exact_589 : height_589 = 1 + Finset.univ.sup childrenH_589 := by decide +kernel +theorem required_origin_589 : ∀ x ∈ required_589, + (∃ j, x ∈ childrenC_589 j) ∨ ∀ j, x ∈ childrenD_589 j := by decide +kernel +theorem required_exact_589 : required_589 = + ((Finset.univ.biUnion childrenC_589) ∪ commonEnvelope childrenD_589).erase (4, 2) := by + exact required_eq_combination childrenC_589 childrenD_589 (4, 2) required_589 + (by decide +kernel) child_required_sub_589 common_sub_589 required_origin_589 +theorem envelope_origin_589 : ∀ x ∈ envelope_589, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_589 j := by decide +kernel +theorem envelope_exact_589 : envelope_589 = + insert (4, 2) (Finset.univ.biUnion childrenD_589) := by + exact envelope_eq_combination childrenD_589 (4, 2) envelope_589 + pivot_mem_589 child_envelope_sub_589 envelope_origin_589 +def checked_589 : CheckedCard where + required := required_589 + envelope := envelope_589 + height := height_589 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_589 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part03.lean new file mode 100644 index 0000000..8fcdd35 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part03.lean @@ -0,0 +1,775 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_596_i1 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 1), (3, 2), (3, 4), (4, 2), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_596_i1 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 1), (3, 2), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_596_i1 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) required_2), (placed21 0 (1, 4) required_5)] +def childrenD_596_i1 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) envelope_2), (placed21 0 (1, 4) envelope_5)] +theorem common_sub_596_i1 : commonEnvelope childrenD_596_i1 ⊆ insert (4, 5) required_596_i1 := by decide +kernel +theorem child_required_sub_596_i1 : ∀ j, childrenC_596_i1 j ⊆ insert (4, 5) required_596_i1 := by decide +kernel +theorem child_envelope_sub_596_i1 : ∀ j, childrenD_596_i1 j ⊆ envelope_596_i1 := by decide +kernel +theorem pivot_mem_596_i1 : (4, 5) ∈ envelope_596_i1 := by decide +kernel +theorem children_work_596_i1 : ∀ j, Template HasSnaky 1 (childrenC_596_i1 j) (childrenD_596_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 7 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_5 0 (1, 4)).mono (by decide +kernel) +theorem row_works_596_i1 : Template HasSnaky 2 required_596_i1 envelope_596_i1 := by + refine compose HasSnaky 1 childrenC_596_i1 childrenD_596_i1 children_work_596_i1 (4, 5) + required_596_i1 envelope_596_i1 pivot_mem_596_i1 child_required_sub_596_i1 child_envelope_sub_596_i1 ?_ + intro b hb + exact common_sub_596_i1 (mem_commonEnvelope childrenD_596_i1 b hb) +def required_596_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 4), (3, 1), (3, 2), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_596_i0 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 1), (2, 4), (3, 1), (3, 2), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_596_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_2), required_596_i1] +def childrenD_596_i0 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_2), envelope_596_i1] +theorem common_sub_596_i0 : commonEnvelope childrenD_596_i0 ⊆ insert (4, 2) required_596_i0 := by decide +kernel +theorem child_required_sub_596_i0 : ∀ j, childrenC_596_i0 j ⊆ insert (4, 2) required_596_i0 := by decide +kernel +theorem child_envelope_sub_596_i0 : ∀ j, childrenD_596_i0 j ⊆ envelope_596_i0 := by decide +kernel +theorem pivot_mem_596_i0 : (4, 2) ∈ envelope_596_i0 := by decide +kernel +theorem children_work_596_i0 : ∀ j, Template HasSnaky 2 (childrenC_596_i0 j) (childrenD_596_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 1)).mono (by decide +kernel) + · exact row_works_596_i1.mono (by decide +kernel) +theorem row_works_596_i0 : Template HasSnaky 3 required_596_i0 envelope_596_i0 := by + refine compose HasSnaky 2 childrenC_596_i0 childrenD_596_i0 children_work_596_i0 (4, 2) + required_596_i0 envelope_596_i0 pivot_mem_596_i0 child_required_sub_596_i0 child_envelope_sub_596_i0 ?_ + intro b hb + exact common_sub_596_i0 (mem_commonEnvelope childrenD_596_i0 b hb) +def required_596_i3 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 1), (3, 2), (3, 4), (4, 2), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_596_i3 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 1), (3, 2), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_596_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) required_0), (placed21 4 (1, 4) required_5)] +def childrenD_596_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 5) envelope_0), (placed21 4 (1, 4) envelope_5)] +theorem common_sub_596_i3 : commonEnvelope childrenD_596_i3 ⊆ insert (4, 3) required_596_i3 := by decide +kernel +theorem child_required_sub_596_i3 : ∀ j, childrenC_596_i3 j ⊆ insert (4, 3) required_596_i3 := by decide +kernel +theorem child_envelope_sub_596_i3 : ∀ j, childrenD_596_i3 j ⊆ envelope_596_i3 := by decide +kernel +theorem pivot_mem_596_i3 : (4, 3) ∈ envelope_596_i3 := by decide +kernel +theorem children_work_596_i3 : ∀ j, Template HasSnaky 1 (childrenC_596_i3 j) (childrenD_596_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_5 4 (1, 4)).mono (by decide +kernel) +theorem row_works_596_i3 : Template HasSnaky 2 required_596_i3 envelope_596_i3 := by + refine compose HasSnaky 1 childrenC_596_i3 childrenD_596_i3 children_work_596_i3 (4, 3) + required_596_i3 envelope_596_i3 pivot_mem_596_i3 child_required_sub_596_i3 child_envelope_sub_596_i3 ?_ + intro b hb + exact common_sub_596_i3 (mem_commonEnvelope childrenD_596_i3 b hb) +def required_596_i2 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 4), (3, 1), (3, 2), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_596_i2 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 1), (2, 4), (3, 1), (3, 2), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_596_i2 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_2), required_596_i3] +def childrenD_596_i2 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_2), envelope_596_i3] +theorem common_sub_596_i2 : commonEnvelope childrenD_596_i2 ⊆ insert (4, 2) required_596_i2 := by decide +kernel +theorem child_required_sub_596_i2 : ∀ j, childrenC_596_i2 j ⊆ insert (4, 2) required_596_i2 := by decide +kernel +theorem child_envelope_sub_596_i2 : ∀ j, childrenD_596_i2 j ⊆ envelope_596_i2 := by decide +kernel +theorem pivot_mem_596_i2 : (4, 2) ∈ envelope_596_i2 := by decide +kernel +theorem children_work_596_i2 : ∀ j, Template HasSnaky 2 (childrenC_596_i2 j) (childrenD_596_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 1)).mono (by decide +kernel) + · exact row_works_596_i3.mono (by decide +kernel) +theorem row_works_596_i2 : Template HasSnaky 3 required_596_i2 envelope_596_i2 := by + refine compose HasSnaky 2 childrenC_596_i2 childrenD_596_i2 children_work_596_i2 (4, 2) + required_596_i2 envelope_596_i2 pivot_mem_596_i2 child_required_sub_596_i2 child_envelope_sub_596_i2 ?_ + intro b hb + exact common_sub_596_i2 (mem_commonEnvelope childrenD_596_i2 b hb) +def required_596_i5 : Finset Cell := ⟨(([(0, 1), (1, 1), (3, 1), (3, 2), (3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_596_i5 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 1), (2, 4), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (6, 5), (7, 5), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_596_i5 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) required_2), (placed21 1 (2, 1) required_82)] +def childrenD_596_i5 : Fin 2 → Finset Cell := ![(placed21 0 (0, 1) envelope_2), (placed21 1 (2, 1) envelope_82)] +theorem common_sub_596_i5 : commonEnvelope childrenD_596_i5 ⊆ insert (4, 2) required_596_i5 := by decide +kernel +theorem child_required_sub_596_i5 : ∀ j, childrenC_596_i5 j ⊆ insert (4, 2) required_596_i5 := by decide +kernel +theorem child_envelope_sub_596_i5 : ∀ j, childrenD_596_i5 j ⊆ envelope_596_i5 := by decide +kernel +theorem pivot_mem_596_i5 : (4, 2) ∈ envelope_596_i5 := by decide +kernel +theorem children_work_596_i5 : ∀ j, Template HasSnaky 4 (childrenC_596_i5 j) (childrenD_596_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_82 1 (2, 1)).mono (by decide +kernel) +theorem row_works_596_i5 : Template HasSnaky 5 required_596_i5 envelope_596_i5 := by + refine compose HasSnaky 4 childrenC_596_i5 childrenD_596_i5 children_work_596_i5 (4, 2) + required_596_i5 envelope_596_i5 pivot_mem_596_i5 child_required_sub_596_i5 child_envelope_sub_596_i5 ?_ + intro b hb + exact common_sub_596_i5 (mem_commonEnvelope childrenD_596_i5 b hb) +def required_596_i4 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 4), (3, 1), (3, 2), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_596_i4 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 1), (2, 4), (3, 1), (3, 2), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2), (7, 3), (7, 5), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_596_i4 : Fin 3 → Finset Cell := ![(placed21 3 (1, 4) required_6), required_595, required_596_i5] +def childrenD_596_i4 : Fin 3 → Finset Cell := ![(placed21 3 (1, 4) envelope_6), envelope_595, envelope_596_i5] +theorem common_sub_596_i4 : commonEnvelope childrenD_596_i4 ⊆ insert (5, 4) required_596_i4 := by decide +kernel +theorem child_required_sub_596_i4 : ∀ j, childrenC_596_i4 j ⊆ insert (5, 4) required_596_i4 := by decide +kernel +theorem child_envelope_sub_596_i4 : ∀ j, childrenD_596_i4 j ⊆ envelope_596_i4 := by decide +kernel +theorem pivot_mem_596_i4 : (5, 4) ∈ envelope_596_i4 := by decide +kernel +theorem children_work_596_i4 : ∀ j, Template HasSnaky 9 (childrenC_596_i4 j) (childrenD_596_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (1, 4)).mono (by decide +kernel) + · exact row_works_595.mono (by decide +kernel) + · exact row_works_596_i5.mono (by decide +kernel) +theorem row_works_596_i4 : Template HasSnaky 10 required_596_i4 envelope_596_i4 := by + refine compose HasSnaky 9 childrenC_596_i4 childrenD_596_i4 children_work_596_i4 (5, 4) + required_596_i4 envelope_596_i4 pivot_mem_596_i4 child_required_sub_596_i4 child_envelope_sub_596_i4 ?_ + intro b hb + exact common_sub_596_i4 (mem_commonEnvelope childrenD_596_i4 b hb) +def required_596 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 4), (3, 1), (3, 2), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_596 : Finset Cell := ⟨(([(0, 1), (1, 1), (1, 4), (2, 1), (2, 4), (2, 5), (3, 1), (3, 2), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_596 : Fin 4 → Finset Cell := ![(placed21 4 (1, 5) required_197), required_596_i0, required_596_i2, required_596_i4] +def childrenD_596 : Fin 4 → Finset Cell := ![(placed21 4 (1, 5) envelope_197), envelope_596_i0, envelope_596_i2, envelope_596_i4] +theorem common_sub_596 : commonEnvelope childrenD_596 ⊆ insert (4, 4) required_596 := by decide +kernel +theorem child_required_sub_596 : ∀ j, childrenC_596 j ⊆ insert (4, 4) required_596 := by decide +kernel +theorem child_envelope_sub_596 : ∀ j, childrenD_596 j ⊆ envelope_596 := by decide +kernel +theorem pivot_mem_596 : (4, 4) ∈ envelope_596 := by decide +kernel +theorem children_work_596 : ∀ j, Template HasSnaky 10 (childrenC_596 j) (childrenD_596 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_197 4 (1, 5)).mono (by decide +kernel) + · exact row_works_596_i0.mono (by decide +kernel) + · exact row_works_596_i2.mono (by decide +kernel) + · exact row_works_596_i4.mono (by decide +kernel) +theorem row_works_596 : Template HasSnaky 11 required_596 envelope_596 := by + refine compose HasSnaky 10 childrenC_596 childrenD_596 children_work_596 (4, 4) + required_596 envelope_596 pivot_mem_596 child_required_sub_596 child_envelope_sub_596 ?_ + intro b hb + exact common_sub_596 (mem_commonEnvelope childrenD_596 b hb) +def required_601_i1 : Finset Cell := ⟨(([(0, 2), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_601_i1 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 1), (2, 2), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_601_i1 : Fin 2 → Finset Cell := ![(placed21 0 (3, 2) required_29), (placed21 7 (4, 5) required_35)] +def childrenD_601_i1 : Fin 2 → Finset Cell := ![(placed21 0 (3, 2) envelope_29), (placed21 7 (4, 5) envelope_35)] +theorem common_sub_601_i1 : commonEnvelope childrenD_601_i1 ⊆ insert (3, 5) required_601_i1 := by decide +kernel +theorem child_required_sub_601_i1 : ∀ j, childrenC_601_i1 j ⊆ insert (3, 5) required_601_i1 := by decide +kernel +theorem child_envelope_sub_601_i1 : ∀ j, childrenD_601_i1 j ⊆ envelope_601_i1 := by decide +kernel +theorem pivot_mem_601_i1 : (3, 5) ∈ envelope_601_i1 := by decide +kernel +theorem children_work_601_i1 : ∀ j, Template HasSnaky 3 (childrenC_601_i1 j) (childrenD_601_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_29 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_35 7 (4, 5)).mono (by decide +kernel) +theorem row_works_601_i1 : Template HasSnaky 4 required_601_i1 envelope_601_i1 := by + refine compose HasSnaky 3 childrenC_601_i1 childrenD_601_i1 children_work_601_i1 (3, 5) + required_601_i1 envelope_601_i1 pivot_mem_601_i1 child_required_sub_601_i1 child_envelope_sub_601_i1 ?_ + intro b hb + exact common_sub_601_i1 (mem_commonEnvelope childrenD_601_i1 b hb) +def required_601_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (1, 5), (3, 2), (3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_601_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_601_i0 : Fin 3 → Finset Cell := ![required_601_i1, (placed21 1 (1, 2) required_499), (placed21 0 (0, 1) required_501)] +def childrenD_601_i0 : Fin 3 → Finset Cell := ![envelope_601_i1, (placed21 1 (1, 2) envelope_499), (placed21 0 (0, 1) envelope_501)] +theorem common_sub_601_i0 : commonEnvelope childrenD_601_i0 ⊆ insert (4, 4) required_601_i0 := by decide +kernel +theorem child_required_sub_601_i0 : ∀ j, childrenC_601_i0 j ⊆ insert (4, 4) required_601_i0 := by decide +kernel +theorem child_envelope_sub_601_i0 : ∀ j, childrenD_601_i0 j ⊆ envelope_601_i0 := by decide +kernel +theorem pivot_mem_601_i0 : (4, 4) ∈ envelope_601_i0 := by decide +kernel +theorem children_work_601_i0 : ∀ j, Template HasSnaky 7 (childrenC_601_i0 j) (childrenD_601_i0 j) := by + intro j + fin_cases j + · exact row_works_601_i1.mono (by decide +kernel) + · exact (placed21_template row_works_499 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_501 0 (0, 1)).mono (by decide +kernel) +theorem row_works_601_i0 : Template HasSnaky 8 required_601_i0 envelope_601_i0 := by + refine compose HasSnaky 7 childrenC_601_i0 childrenD_601_i0 children_work_601_i0 (4, 4) + required_601_i0 envelope_601_i0 pivot_mem_601_i0 child_required_sub_601_i0 child_envelope_sub_601_i0 ?_ + intro b hb + exact common_sub_601_i0 (mem_commonEnvelope childrenD_601_i0 b hb) +def required_601_i6 : Finset Cell := ⟨(([(3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_601_i6 : Finset Cell := ⟨(([(3, 2), (3, 3), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_601_i6 : Fin 2 → Finset Cell := ![(placed21 0 (3, 1) required_66), (placed21 1 (3, 2) required_94)] +def childrenD_601_i6 : Fin 2 → Finset Cell := ![(placed21 0 (3, 1) envelope_66), (placed21 1 (3, 2) envelope_94)] +theorem common_sub_601_i6 : commonEnvelope childrenD_601_i6 ⊆ insert (5, 2) required_601_i6 := by decide +kernel +theorem child_required_sub_601_i6 : ∀ j, childrenC_601_i6 j ⊆ insert (5, 2) required_601_i6 := by decide +kernel +theorem child_envelope_sub_601_i6 : ∀ j, childrenD_601_i6 j ⊆ envelope_601_i6 := by decide +kernel +theorem pivot_mem_601_i6 : (5, 2) ∈ envelope_601_i6 := by decide +kernel +theorem children_work_601_i6 : ∀ j, Template HasSnaky 2 (childrenC_601_i6 j) (childrenD_601_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_66 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_94 1 (3, 2)).mono (by decide +kernel) +theorem row_works_601_i6 : Template HasSnaky 3 required_601_i6 envelope_601_i6 := by + refine compose HasSnaky 2 childrenC_601_i6 childrenD_601_i6 children_work_601_i6 (5, 2) + required_601_i6 envelope_601_i6 pivot_mem_601_i6 child_required_sub_601_i6 child_envelope_sub_601_i6 ?_ + intro b hb + exact common_sub_601_i6 (mem_commonEnvelope childrenD_601_i6 b hb) +def required_601_i5 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (4, 3), (4, 4), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_601_i5 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_601_i5 : Fin 2 → Finset Cell := ![(placed21 4 (3, 5) required_15), required_601_i6] +def childrenD_601_i5 : Fin 2 → Finset Cell := ![(placed21 4 (3, 5) envelope_15), envelope_601_i6] +theorem common_sub_601_i5 : commonEnvelope childrenD_601_i5 ⊆ insert (4, 2) required_601_i5 := by decide +kernel +theorem child_required_sub_601_i5 : ∀ j, childrenC_601_i5 j ⊆ insert (4, 2) required_601_i5 := by decide +kernel +theorem child_envelope_sub_601_i5 : ∀ j, childrenD_601_i5 j ⊆ envelope_601_i5 := by decide +kernel +theorem pivot_mem_601_i5 : (4, 2) ∈ envelope_601_i5 := by decide +kernel +theorem children_work_601_i5 : ∀ j, Template HasSnaky 3 (childrenC_601_i5 j) (childrenD_601_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 4 (3, 5)).mono (by decide +kernel) + · exact row_works_601_i6.mono (by decide +kernel) +theorem row_works_601_i5 : Template HasSnaky 4 required_601_i5 envelope_601_i5 := by + refine compose HasSnaky 3 childrenC_601_i5 childrenD_601_i5 children_work_601_i5 (4, 2) + required_601_i5 envelope_601_i5 pivot_mem_601_i5 child_required_sub_601_i5 child_envelope_sub_601_i5 ?_ + intro b hb + exact common_sub_601_i5 (mem_commonEnvelope childrenD_601_i5 b hb) +def required_601_i4 : Finset Cell := ⟨(([(2, 4), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_601_i4 : Finset Cell := ⟨(([(2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_601_i4 : Fin 2 → Finset Cell := ![(placed21 2 (6, 3) required_1), required_601_i5] +def childrenD_601_i4 : Fin 2 → Finset Cell := ![(placed21 2 (6, 3) envelope_1), envelope_601_i5] +theorem common_sub_601_i4 : commonEnvelope childrenD_601_i4 ⊆ insert (6, 3) required_601_i4 := by decide +kernel +theorem child_required_sub_601_i4 : ∀ j, childrenC_601_i4 j ⊆ insert (6, 3) required_601_i4 := by decide +kernel +theorem child_envelope_sub_601_i4 : ∀ j, childrenD_601_i4 j ⊆ envelope_601_i4 := by decide +kernel +theorem pivot_mem_601_i4 : (6, 3) ∈ envelope_601_i4 := by decide +kernel +theorem children_work_601_i4 : ∀ j, Template HasSnaky 4 (childrenC_601_i4 j) (childrenD_601_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 2 (6, 3)).mono (by decide +kernel) + · exact row_works_601_i5.mono (by decide +kernel) +theorem row_works_601_i4 : Template HasSnaky 5 required_601_i4 envelope_601_i4 := by + refine compose HasSnaky 4 childrenC_601_i4 childrenD_601_i4 children_work_601_i4 (6, 3) + required_601_i4 envelope_601_i4 pivot_mem_601_i4 child_required_sub_601_i4 child_envelope_sub_601_i4 ?_ + intro b hb + exact common_sub_601_i4 (mem_commonEnvelope childrenD_601_i4 b hb) +def required_601_i3 : Finset Cell := ⟨(([(0, 5), (1, 5), (3, 2), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_601_i3 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (6, 2), (6, 3), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_601_i3 : Fin 2 → Finset Cell := ![(placed21 2 (4, 4) required_3), required_601_i4] +def childrenD_601_i3 : Fin 2 → Finset Cell := ![(placed21 2 (4, 4) envelope_3), envelope_601_i4] +theorem common_sub_601_i3 : commonEnvelope childrenD_601_i3 ⊆ insert (2, 4) required_601_i3 := by decide +kernel +theorem child_required_sub_601_i3 : ∀ j, childrenC_601_i3 j ⊆ insert (2, 4) required_601_i3 := by decide +kernel +theorem child_envelope_sub_601_i3 : ∀ j, childrenD_601_i3 j ⊆ envelope_601_i3 := by decide +kernel +theorem pivot_mem_601_i3 : (2, 4) ∈ envelope_601_i3 := by decide +kernel +theorem children_work_601_i3 : ∀ j, Template HasSnaky 5 (childrenC_601_i3 j) (childrenD_601_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 2 (4, 4)).mono (by decide +kernel) + · exact row_works_601_i4.mono (by decide +kernel) +theorem row_works_601_i3 : Template HasSnaky 6 required_601_i3 envelope_601_i3 := by + refine compose HasSnaky 5 childrenC_601_i3 childrenD_601_i3 children_work_601_i3 (2, 4) + required_601_i3 envelope_601_i3 pivot_mem_601_i3 child_required_sub_601_i3 child_envelope_sub_601_i3 ?_ + intro b hb + exact common_sub_601_i3 (mem_commonEnvelope childrenD_601_i3 b hb) +def required_601_i7 : Finset Cell := ⟨(([(0, 5), (1, 5), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_601_i7 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (2, 4), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_601_i7 : Fin 2 → Finset Cell := ![(placed21 2 (4, 4) required_3), (placed21 0 (2, 2) required_72)] +def childrenD_601_i7 : Fin 2 → Finset Cell := ![(placed21 2 (4, 4) envelope_3), (placed21 0 (2, 2) envelope_72)] +theorem common_sub_601_i7 : commonEnvelope childrenD_601_i7 ⊆ insert (2, 4) required_601_i7 := by decide +kernel +theorem child_required_sub_601_i7 : ∀ j, childrenC_601_i7 j ⊆ insert (2, 4) required_601_i7 := by decide +kernel +theorem child_envelope_sub_601_i7 : ∀ j, childrenD_601_i7 j ⊆ envelope_601_i7 := by decide +kernel +theorem pivot_mem_601_i7 : (2, 4) ∈ envelope_601_i7 := by decide +kernel +theorem children_work_601_i7 : ∀ j, Template HasSnaky 5 (childrenC_601_i7 j) (childrenD_601_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 2 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_72 0 (2, 2)).mono (by decide +kernel) +theorem row_works_601_i7 : Template HasSnaky 6 required_601_i7 envelope_601_i7 := by + refine compose HasSnaky 5 childrenC_601_i7 childrenD_601_i7 children_work_601_i7 (2, 4) + required_601_i7 envelope_601_i7 pivot_mem_601_i7 child_required_sub_601_i7 child_envelope_sub_601_i7 ?_ + intro b hb + exact common_sub_601_i7 (mem_commonEnvelope childrenD_601_i7 b hb) +def required_601_i2 : Finset Cell := ⟨(([(0, 5), (1, 5), (3, 2), (3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_601_i2 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_601_i2 : Fin 5 → Finset Cell := ![(placed21 4 (3, 6) required_406), (placed21 1 (1, 2) required_499), required_601_i3, (placed21 4 (1, 7) required_600), required_601_i7] +def childrenD_601_i2 : Fin 5 → Finset Cell := ![(placed21 4 (3, 6) envelope_406), (placed21 1 (1, 2) envelope_499), envelope_601_i3, (placed21 4 (1, 7) envelope_600), envelope_601_i7] +theorem common_sub_601_i2 : commonEnvelope childrenD_601_i2 ⊆ insert (4, 4) required_601_i2 := by decide +kernel +theorem child_required_sub_601_i2 : ∀ j, childrenC_601_i2 j ⊆ insert (4, 4) required_601_i2 := by decide +kernel +theorem child_envelope_sub_601_i2 : ∀ j, childrenD_601_i2 j ⊆ envelope_601_i2 := by decide +kernel +theorem pivot_mem_601_i2 : (4, 4) ∈ envelope_601_i2 := by decide +kernel +theorem children_work_601_i2 : ∀ j, Template HasSnaky 9 (childrenC_601_i2 j) (childrenD_601_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_406 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_499 1 (1, 2)).mono (by decide +kernel) + · exact row_works_601_i3.mono (by decide +kernel) + · exact (placed21_template row_works_600 4 (1, 7)).mono (by decide +kernel) + · exact row_works_601_i7.mono (by decide +kernel) +theorem row_works_601_i2 : Template HasSnaky 10 required_601_i2 envelope_601_i2 := by + refine compose HasSnaky 9 childrenC_601_i2 childrenD_601_i2 children_work_601_i2 (4, 4) + required_601_i2 envelope_601_i2 pivot_mem_601_i2 child_required_sub_601_i2 child_envelope_sub_601_i2 ?_ + intro b hb + exact common_sub_601_i2 (mem_commonEnvelope childrenD_601_i2 b hb) +def required_601_i8 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (1, 5), (3, 2), (3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_601_i8 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 4), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_601_i8 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) required_406), (placed21 0 (0, 1) required_501)] +def childrenD_601_i8 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) envelope_406), (placed21 0 (0, 1) envelope_501)] +theorem common_sub_601_i8 : commonEnvelope childrenD_601_i8 ⊆ insert (4, 4) required_601_i8 := by decide +kernel +theorem child_required_sub_601_i8 : ∀ j, childrenC_601_i8 j ⊆ insert (4, 4) required_601_i8 := by decide +kernel +theorem child_envelope_sub_601_i8 : ∀ j, childrenD_601_i8 j ⊆ envelope_601_i8 := by decide +kernel +theorem pivot_mem_601_i8 : (4, 4) ∈ envelope_601_i8 := by decide +kernel +theorem children_work_601_i8 : ∀ j, Template HasSnaky 9 (childrenC_601_i8 j) (childrenD_601_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_406 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_501 0 (0, 1)).mono (by decide +kernel) +theorem row_works_601_i8 : Template HasSnaky 10 required_601_i8 envelope_601_i8 := by + refine compose HasSnaky 9 childrenC_601_i8 childrenD_601_i8 children_work_601_i8 (4, 4) + required_601_i8 envelope_601_i8 pivot_mem_601_i8 child_required_sub_601_i8 child_envelope_sub_601_i8 ?_ + intro b hb + exact common_sub_601_i8 (mem_commonEnvelope childrenD_601_i8 b hb) +def required_601 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (1, 5), (3, 2), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_601 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_601 : Fin 4 → Finset Cell := ![(placed21 0 (0, 1) required_247), required_601_i0, required_601_i2, required_601_i8] +def childrenD_601 : Fin 4 → Finset Cell := ![(placed21 0 (0, 1) envelope_247), envelope_601_i0, envelope_601_i2, envelope_601_i8] +theorem common_sub_601 : commonEnvelope childrenD_601 ⊆ insert (4, 3) required_601 := by decide +kernel +theorem child_required_sub_601 : ∀ j, childrenC_601 j ⊆ insert (4, 3) required_601 := by decide +kernel +theorem child_envelope_sub_601 : ∀ j, childrenD_601 j ⊆ envelope_601 := by decide +kernel +theorem pivot_mem_601 : (4, 3) ∈ envelope_601 := by decide +kernel +theorem children_work_601 : ∀ j, Template HasSnaky 10 (childrenC_601 j) (childrenD_601 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_247 0 (0, 1)).mono (by decide +kernel) + · exact row_works_601_i0.mono (by decide +kernel) + · exact row_works_601_i2.mono (by decide +kernel) + · exact row_works_601_i8.mono (by decide +kernel) +theorem row_works_601 : Template HasSnaky 11 required_601 envelope_601 := by + refine compose HasSnaky 10 childrenC_601 childrenD_601 children_work_601 (4, 3) + required_601 envelope_601 pivot_mem_601 child_required_sub_601 child_envelope_sub_601 ?_ + intro b hb + exact common_sub_601 (mem_commonEnvelope childrenD_601 b hb) +def required_613 : Finset Cell := ⟨(([(1, 3), (1, 5), (2, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_613 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 7), (0, 8), (0, 9), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_613 : Fin 6 → Finset Cell := ![(placed21 0 (1, 0) required_104), (placed21 2 (2, 0) required_329), (placed21 4 (1, 8) required_409), (placed21 0 (1, 2) required_612), (placed21 4 (1, 6) required_612), (placed21 6 (2, 6) required_612)] +def childrenD_613 : Fin 6 → Finset Cell := ![(placed21 0 (1, 0) envelope_104), (placed21 2 (2, 0) envelope_329), (placed21 4 (1, 8) envelope_409), (placed21 0 (1, 2) envelope_612), (placed21 4 (1, 6) envelope_612), (placed21 6 (2, 6) envelope_612)] +theorem common_sub_613 : commonEnvelope childrenD_613 ⊆ insert (2, 5) required_613 := by decide +kernel +theorem child_required_sub_613 : ∀ j, childrenC_613 j ⊆ insert (2, 5) required_613 := by decide +kernel +theorem child_envelope_sub_613 : ∀ j, childrenD_613 j ⊆ envelope_613 := by decide +kernel +theorem pivot_mem_613 : (2, 5) ∈ envelope_613 := by decide +kernel +theorem children_work_613 : ∀ j, Template HasSnaky 10 (childrenC_613 j) (childrenD_613 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_104 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_329 2 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_409 4 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_612 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_612 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_612 6 (2, 6)).mono (by decide +kernel) +theorem row_works_613 : Template HasSnaky 11 required_613 envelope_613 := by + refine compose HasSnaky 10 childrenC_613 childrenD_613 children_work_613 (2, 5) + required_613 envelope_613 pivot_mem_613 child_required_sub_613 child_envelope_sub_613 ?_ + intro b hb + exact common_sub_613 (mem_commonEnvelope childrenD_613 b hb) +def height_596_i1 : ℕ := 2 +def childrenH_596_i1 : Fin 2 → ℕ := ![height_2, height_5] +theorem height_exact_596_i1 : height_596_i1 = 1 + Finset.univ.sup childrenH_596_i1 := by decide +kernel +theorem required_origin_596_i1 : ∀ x ∈ required_596_i1, + (∃ j, x ∈ childrenC_596_i1 j) ∨ ∀ j, x ∈ childrenD_596_i1 j := by decide +kernel +theorem required_exact_596_i1 : required_596_i1 = + ((Finset.univ.biUnion childrenC_596_i1) ∪ commonEnvelope childrenD_596_i1).erase (4, 5) := by + exact required_eq_combination childrenC_596_i1 childrenD_596_i1 (4, 5) required_596_i1 + (by decide +kernel) child_required_sub_596_i1 common_sub_596_i1 required_origin_596_i1 +theorem envelope_origin_596_i1 : ∀ x ∈ envelope_596_i1, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_596_i1 j := by decide +kernel +theorem envelope_exact_596_i1 : envelope_596_i1 = + insert (4, 5) (Finset.univ.biUnion childrenD_596_i1) := by + exact envelope_eq_combination childrenD_596_i1 (4, 5) envelope_596_i1 + pivot_mem_596_i1 child_envelope_sub_596_i1 envelope_origin_596_i1 +def checked_596_i1 : CheckedCard where + required := required_596_i1 + envelope := envelope_596_i1 + height := height_596_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_596_i1 +def height_596_i0 : ℕ := 3 +def childrenH_596_i0 : Fin 2 → ℕ := ![height_2, height_596_i1] +theorem height_exact_596_i0 : height_596_i0 = 1 + Finset.univ.sup childrenH_596_i0 := by decide +kernel +theorem required_origin_596_i0 : ∀ x ∈ required_596_i0, + (∃ j, x ∈ childrenC_596_i0 j) ∨ ∀ j, x ∈ childrenD_596_i0 j := by decide +kernel +theorem required_exact_596_i0 : required_596_i0 = + ((Finset.univ.biUnion childrenC_596_i0) ∪ commonEnvelope childrenD_596_i0).erase (4, 2) := by + exact required_eq_combination childrenC_596_i0 childrenD_596_i0 (4, 2) required_596_i0 + (by decide +kernel) child_required_sub_596_i0 common_sub_596_i0 required_origin_596_i0 +theorem envelope_origin_596_i0 : ∀ x ∈ envelope_596_i0, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_596_i0 j := by decide +kernel +theorem envelope_exact_596_i0 : envelope_596_i0 = + insert (4, 2) (Finset.univ.biUnion childrenD_596_i0) := by + exact envelope_eq_combination childrenD_596_i0 (4, 2) envelope_596_i0 + pivot_mem_596_i0 child_envelope_sub_596_i0 envelope_origin_596_i0 +def checked_596_i0 : CheckedCard where + required := required_596_i0 + envelope := envelope_596_i0 + height := height_596_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_596_i0 +def height_596_i3 : ℕ := 2 +def childrenH_596_i3 : Fin 2 → ℕ := ![height_0, height_5] +theorem height_exact_596_i3 : height_596_i3 = 1 + Finset.univ.sup childrenH_596_i3 := by decide +kernel +theorem required_origin_596_i3 : ∀ x ∈ required_596_i3, + (∃ j, x ∈ childrenC_596_i3 j) ∨ ∀ j, x ∈ childrenD_596_i3 j := by decide +kernel +theorem required_exact_596_i3 : required_596_i3 = + ((Finset.univ.biUnion childrenC_596_i3) ∪ commonEnvelope childrenD_596_i3).erase (4, 3) := by + exact required_eq_combination childrenC_596_i3 childrenD_596_i3 (4, 3) required_596_i3 + (by decide +kernel) child_required_sub_596_i3 common_sub_596_i3 required_origin_596_i3 +theorem envelope_origin_596_i3 : ∀ x ∈ envelope_596_i3, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_596_i3 j := by decide +kernel +theorem envelope_exact_596_i3 : envelope_596_i3 = + insert (4, 3) (Finset.univ.biUnion childrenD_596_i3) := by + exact envelope_eq_combination childrenD_596_i3 (4, 3) envelope_596_i3 + pivot_mem_596_i3 child_envelope_sub_596_i3 envelope_origin_596_i3 +def checked_596_i3 : CheckedCard where + required := required_596_i3 + envelope := envelope_596_i3 + height := height_596_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_596_i3 +def height_596_i2 : ℕ := 3 +def childrenH_596_i2 : Fin 2 → ℕ := ![height_2, height_596_i3] +theorem height_exact_596_i2 : height_596_i2 = 1 + Finset.univ.sup childrenH_596_i2 := by decide +kernel +theorem required_origin_596_i2 : ∀ x ∈ required_596_i2, + (∃ j, x ∈ childrenC_596_i2 j) ∨ ∀ j, x ∈ childrenD_596_i2 j := by decide +kernel +theorem required_exact_596_i2 : required_596_i2 = + ((Finset.univ.biUnion childrenC_596_i2) ∪ commonEnvelope childrenD_596_i2).erase (4, 2) := by + exact required_eq_combination childrenC_596_i2 childrenD_596_i2 (4, 2) required_596_i2 + (by decide +kernel) child_required_sub_596_i2 common_sub_596_i2 required_origin_596_i2 +theorem envelope_origin_596_i2 : ∀ x ∈ envelope_596_i2, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_596_i2 j := by decide +kernel +theorem envelope_exact_596_i2 : envelope_596_i2 = + insert (4, 2) (Finset.univ.biUnion childrenD_596_i2) := by + exact envelope_eq_combination childrenD_596_i2 (4, 2) envelope_596_i2 + pivot_mem_596_i2 child_envelope_sub_596_i2 envelope_origin_596_i2 +def checked_596_i2 : CheckedCard where + required := required_596_i2 + envelope := envelope_596_i2 + height := height_596_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_596_i2 +def height_596_i5 : ℕ := 5 +def childrenH_596_i5 : Fin 2 → ℕ := ![height_2, height_82] +theorem height_exact_596_i5 : height_596_i5 = 1 + Finset.univ.sup childrenH_596_i5 := by decide +kernel +theorem required_origin_596_i5 : ∀ x ∈ required_596_i5, + (∃ j, x ∈ childrenC_596_i5 j) ∨ ∀ j, x ∈ childrenD_596_i5 j := by decide +kernel +theorem required_exact_596_i5 : required_596_i5 = + ((Finset.univ.biUnion childrenC_596_i5) ∪ commonEnvelope childrenD_596_i5).erase (4, 2) := by + exact required_eq_combination childrenC_596_i5 childrenD_596_i5 (4, 2) required_596_i5 + (by decide +kernel) child_required_sub_596_i5 common_sub_596_i5 required_origin_596_i5 +theorem envelope_origin_596_i5 : ∀ x ∈ envelope_596_i5, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_596_i5 j := by decide +kernel +theorem envelope_exact_596_i5 : envelope_596_i5 = + insert (4, 2) (Finset.univ.biUnion childrenD_596_i5) := by + exact envelope_eq_combination childrenD_596_i5 (4, 2) envelope_596_i5 + pivot_mem_596_i5 child_envelope_sub_596_i5 envelope_origin_596_i5 +def checked_596_i5 : CheckedCard where + required := required_596_i5 + envelope := envelope_596_i5 + height := height_596_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_596_i5 +def height_596_i4 : ℕ := 10 +def childrenH_596_i4 : Fin 3 → ℕ := ![height_6, height_595, height_596_i5] +theorem height_exact_596_i4 : height_596_i4 = 1 + Finset.univ.sup childrenH_596_i4 := by decide +kernel +theorem required_origin_596_i4 : ∀ x ∈ required_596_i4, + (∃ j, x ∈ childrenC_596_i4 j) ∨ ∀ j, x ∈ childrenD_596_i4 j := by decide +kernel +theorem required_exact_596_i4 : required_596_i4 = + ((Finset.univ.biUnion childrenC_596_i4) ∪ commonEnvelope childrenD_596_i4).erase (5, 4) := by + exact required_eq_combination childrenC_596_i4 childrenD_596_i4 (5, 4) required_596_i4 + (by decide +kernel) child_required_sub_596_i4 common_sub_596_i4 required_origin_596_i4 +theorem envelope_origin_596_i4 : ∀ x ∈ envelope_596_i4, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_596_i4 j := by decide +kernel +theorem envelope_exact_596_i4 : envelope_596_i4 = + insert (5, 4) (Finset.univ.biUnion childrenD_596_i4) := by + exact envelope_eq_combination childrenD_596_i4 (5, 4) envelope_596_i4 + pivot_mem_596_i4 child_envelope_sub_596_i4 envelope_origin_596_i4 +def checked_596_i4 : CheckedCard where + required := required_596_i4 + envelope := envelope_596_i4 + height := height_596_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_596_i4 +def height_596 : ℕ := 11 +def childrenH_596 : Fin 4 → ℕ := ![height_197, height_596_i0, height_596_i2, height_596_i4] +theorem height_exact_596 : height_596 = 1 + Finset.univ.sup childrenH_596 := by decide +kernel +theorem required_origin_596 : ∀ x ∈ required_596, + (∃ j, x ∈ childrenC_596 j) ∨ ∀ j, x ∈ childrenD_596 j := by decide +kernel +theorem required_exact_596 : required_596 = + ((Finset.univ.biUnion childrenC_596) ∪ commonEnvelope childrenD_596).erase (4, 4) := by + exact required_eq_combination childrenC_596 childrenD_596 (4, 4) required_596 + (by decide +kernel) child_required_sub_596 common_sub_596 required_origin_596 +theorem envelope_origin_596 : ∀ x ∈ envelope_596, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_596 j := by decide +kernel +theorem envelope_exact_596 : envelope_596 = + insert (4, 4) (Finset.univ.biUnion childrenD_596) := by + exact envelope_eq_combination childrenD_596 (4, 4) envelope_596 + pivot_mem_596 child_envelope_sub_596 envelope_origin_596 +def checked_596 : CheckedCard where + required := required_596 + envelope := envelope_596 + height := height_596 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_596 +def height_601_i1 : ℕ := 4 +def childrenH_601_i1 : Fin 2 → ℕ := ![height_29, height_35] +theorem height_exact_601_i1 : height_601_i1 = 1 + Finset.univ.sup childrenH_601_i1 := by decide +kernel +theorem required_origin_601_i1 : ∀ x ∈ required_601_i1, + (∃ j, x ∈ childrenC_601_i1 j) ∨ ∀ j, x ∈ childrenD_601_i1 j := by decide +kernel +theorem required_exact_601_i1 : required_601_i1 = + ((Finset.univ.biUnion childrenC_601_i1) ∪ commonEnvelope childrenD_601_i1).erase (3, 5) := by + exact required_eq_combination childrenC_601_i1 childrenD_601_i1 (3, 5) required_601_i1 + (by decide +kernel) child_required_sub_601_i1 common_sub_601_i1 required_origin_601_i1 +theorem envelope_origin_601_i1 : ∀ x ∈ envelope_601_i1, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_601_i1 j := by decide +kernel +theorem envelope_exact_601_i1 : envelope_601_i1 = + insert (3, 5) (Finset.univ.biUnion childrenD_601_i1) := by + exact envelope_eq_combination childrenD_601_i1 (3, 5) envelope_601_i1 + pivot_mem_601_i1 child_envelope_sub_601_i1 envelope_origin_601_i1 +def checked_601_i1 : CheckedCard where + required := required_601_i1 + envelope := envelope_601_i1 + height := height_601_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_601_i1 +def height_601_i0 : ℕ := 8 +def childrenH_601_i0 : Fin 3 → ℕ := ![height_601_i1, height_499, height_501] +theorem height_exact_601_i0 : height_601_i0 = 1 + Finset.univ.sup childrenH_601_i0 := by decide +kernel +theorem required_origin_601_i0 : ∀ x ∈ required_601_i0, + (∃ j, x ∈ childrenC_601_i0 j) ∨ ∀ j, x ∈ childrenD_601_i0 j := by decide +kernel +theorem required_exact_601_i0 : required_601_i0 = + ((Finset.univ.biUnion childrenC_601_i0) ∪ commonEnvelope childrenD_601_i0).erase (4, 4) := by + exact required_eq_combination childrenC_601_i0 childrenD_601_i0 (4, 4) required_601_i0 + (by decide +kernel) child_required_sub_601_i0 common_sub_601_i0 required_origin_601_i0 +theorem envelope_origin_601_i0 : ∀ x ∈ envelope_601_i0, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_601_i0 j := by decide +kernel +theorem envelope_exact_601_i0 : envelope_601_i0 = + insert (4, 4) (Finset.univ.biUnion childrenD_601_i0) := by + exact envelope_eq_combination childrenD_601_i0 (4, 4) envelope_601_i0 + pivot_mem_601_i0 child_envelope_sub_601_i0 envelope_origin_601_i0 +def checked_601_i0 : CheckedCard where + required := required_601_i0 + envelope := envelope_601_i0 + height := height_601_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_601_i0 +def height_601_i6 : ℕ := 3 +def childrenH_601_i6 : Fin 2 → ℕ := ![height_66, height_94] +theorem height_exact_601_i6 : height_601_i6 = 1 + Finset.univ.sup childrenH_601_i6 := by decide +kernel +theorem required_origin_601_i6 : ∀ x ∈ required_601_i6, + (∃ j, x ∈ childrenC_601_i6 j) ∨ ∀ j, x ∈ childrenD_601_i6 j := by decide +kernel +theorem required_exact_601_i6 : required_601_i6 = + ((Finset.univ.biUnion childrenC_601_i6) ∪ commonEnvelope childrenD_601_i6).erase (5, 2) := by + exact required_eq_combination childrenC_601_i6 childrenD_601_i6 (5, 2) required_601_i6 + (by decide +kernel) child_required_sub_601_i6 common_sub_601_i6 required_origin_601_i6 +theorem envelope_origin_601_i6 : ∀ x ∈ envelope_601_i6, + x = (5, 2) ∨ ∃ j, x ∈ childrenD_601_i6 j := by decide +kernel +theorem envelope_exact_601_i6 : envelope_601_i6 = + insert (5, 2) (Finset.univ.biUnion childrenD_601_i6) := by + exact envelope_eq_combination childrenD_601_i6 (5, 2) envelope_601_i6 + pivot_mem_601_i6 child_envelope_sub_601_i6 envelope_origin_601_i6 +def checked_601_i6 : CheckedCard where + required := required_601_i6 + envelope := envelope_601_i6 + height := height_601_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_601_i6 +def height_601_i5 : ℕ := 4 +def childrenH_601_i5 : Fin 2 → ℕ := ![height_15, height_601_i6] +theorem height_exact_601_i5 : height_601_i5 = 1 + Finset.univ.sup childrenH_601_i5 := by decide +kernel +theorem required_origin_601_i5 : ∀ x ∈ required_601_i5, + (∃ j, x ∈ childrenC_601_i5 j) ∨ ∀ j, x ∈ childrenD_601_i5 j := by decide +kernel +theorem required_exact_601_i5 : required_601_i5 = + ((Finset.univ.biUnion childrenC_601_i5) ∪ commonEnvelope childrenD_601_i5).erase (4, 2) := by + exact required_eq_combination childrenC_601_i5 childrenD_601_i5 (4, 2) required_601_i5 + (by decide +kernel) child_required_sub_601_i5 common_sub_601_i5 required_origin_601_i5 +theorem envelope_origin_601_i5 : ∀ x ∈ envelope_601_i5, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_601_i5 j := by decide +kernel +theorem envelope_exact_601_i5 : envelope_601_i5 = + insert (4, 2) (Finset.univ.biUnion childrenD_601_i5) := by + exact envelope_eq_combination childrenD_601_i5 (4, 2) envelope_601_i5 + pivot_mem_601_i5 child_envelope_sub_601_i5 envelope_origin_601_i5 +def checked_601_i5 : CheckedCard where + required := required_601_i5 + envelope := envelope_601_i5 + height := height_601_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_601_i5 +def height_601_i4 : ℕ := 5 +def childrenH_601_i4 : Fin 2 → ℕ := ![height_1, height_601_i5] +theorem height_exact_601_i4 : height_601_i4 = 1 + Finset.univ.sup childrenH_601_i4 := by decide +kernel +theorem required_origin_601_i4 : ∀ x ∈ required_601_i4, + (∃ j, x ∈ childrenC_601_i4 j) ∨ ∀ j, x ∈ childrenD_601_i4 j := by decide +kernel +theorem required_exact_601_i4 : required_601_i4 = + ((Finset.univ.biUnion childrenC_601_i4) ∪ commonEnvelope childrenD_601_i4).erase (6, 3) := by + exact required_eq_combination childrenC_601_i4 childrenD_601_i4 (6, 3) required_601_i4 + (by decide +kernel) child_required_sub_601_i4 common_sub_601_i4 required_origin_601_i4 +theorem envelope_origin_601_i4 : ∀ x ∈ envelope_601_i4, + x = (6, 3) ∨ ∃ j, x ∈ childrenD_601_i4 j := by decide +kernel +theorem envelope_exact_601_i4 : envelope_601_i4 = + insert (6, 3) (Finset.univ.biUnion childrenD_601_i4) := by + exact envelope_eq_combination childrenD_601_i4 (6, 3) envelope_601_i4 + pivot_mem_601_i4 child_envelope_sub_601_i4 envelope_origin_601_i4 +def checked_601_i4 : CheckedCard where + required := required_601_i4 + envelope := envelope_601_i4 + height := height_601_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_601_i4 +def height_601_i3 : ℕ := 6 +def childrenH_601_i3 : Fin 2 → ℕ := ![height_3, height_601_i4] +theorem height_exact_601_i3 : height_601_i3 = 1 + Finset.univ.sup childrenH_601_i3 := by decide +kernel +theorem required_origin_601_i3 : ∀ x ∈ required_601_i3, + (∃ j, x ∈ childrenC_601_i3 j) ∨ ∀ j, x ∈ childrenD_601_i3 j := by decide +kernel +theorem required_exact_601_i3 : required_601_i3 = + ((Finset.univ.biUnion childrenC_601_i3) ∪ commonEnvelope childrenD_601_i3).erase (2, 4) := by + exact required_eq_combination childrenC_601_i3 childrenD_601_i3 (2, 4) required_601_i3 + (by decide +kernel) child_required_sub_601_i3 common_sub_601_i3 required_origin_601_i3 +theorem envelope_origin_601_i3 : ∀ x ∈ envelope_601_i3, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_601_i3 j := by decide +kernel +theorem envelope_exact_601_i3 : envelope_601_i3 = + insert (2, 4) (Finset.univ.biUnion childrenD_601_i3) := by + exact envelope_eq_combination childrenD_601_i3 (2, 4) envelope_601_i3 + pivot_mem_601_i3 child_envelope_sub_601_i3 envelope_origin_601_i3 +def checked_601_i3 : CheckedCard where + required := required_601_i3 + envelope := envelope_601_i3 + height := height_601_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_601_i3 +def height_601_i7 : ℕ := 6 +def childrenH_601_i7 : Fin 2 → ℕ := ![height_3, height_72] +theorem height_exact_601_i7 : height_601_i7 = 1 + Finset.univ.sup childrenH_601_i7 := by decide +kernel +theorem required_origin_601_i7 : ∀ x ∈ required_601_i7, + (∃ j, x ∈ childrenC_601_i7 j) ∨ ∀ j, x ∈ childrenD_601_i7 j := by decide +kernel +theorem required_exact_601_i7 : required_601_i7 = + ((Finset.univ.biUnion childrenC_601_i7) ∪ commonEnvelope childrenD_601_i7).erase (2, 4) := by + exact required_eq_combination childrenC_601_i7 childrenD_601_i7 (2, 4) required_601_i7 + (by decide +kernel) child_required_sub_601_i7 common_sub_601_i7 required_origin_601_i7 +theorem envelope_origin_601_i7 : ∀ x ∈ envelope_601_i7, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_601_i7 j := by decide +kernel +theorem envelope_exact_601_i7 : envelope_601_i7 = + insert (2, 4) (Finset.univ.biUnion childrenD_601_i7) := by + exact envelope_eq_combination childrenD_601_i7 (2, 4) envelope_601_i7 + pivot_mem_601_i7 child_envelope_sub_601_i7 envelope_origin_601_i7 +def checked_601_i7 : CheckedCard where + required := required_601_i7 + envelope := envelope_601_i7 + height := height_601_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_601_i7 +def height_601_i2 : ℕ := 10 +def childrenH_601_i2 : Fin 5 → ℕ := ![height_406, height_499, height_601_i3, height_600, height_601_i7] +theorem height_exact_601_i2 : height_601_i2 = 1 + Finset.univ.sup childrenH_601_i2 := by decide +kernel +theorem required_origin_601_i2 : ∀ x ∈ required_601_i2, + (∃ j, x ∈ childrenC_601_i2 j) ∨ ∀ j, x ∈ childrenD_601_i2 j := by decide +kernel +theorem required_exact_601_i2 : required_601_i2 = + ((Finset.univ.biUnion childrenC_601_i2) ∪ commonEnvelope childrenD_601_i2).erase (4, 4) := by + exact required_eq_combination childrenC_601_i2 childrenD_601_i2 (4, 4) required_601_i2 + (by decide +kernel) child_required_sub_601_i2 common_sub_601_i2 required_origin_601_i2 +theorem envelope_origin_601_i2 : ∀ x ∈ envelope_601_i2, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_601_i2 j := by decide +kernel +theorem envelope_exact_601_i2 : envelope_601_i2 = + insert (4, 4) (Finset.univ.biUnion childrenD_601_i2) := by + exact envelope_eq_combination childrenD_601_i2 (4, 4) envelope_601_i2 + pivot_mem_601_i2 child_envelope_sub_601_i2 envelope_origin_601_i2 +def checked_601_i2 : CheckedCard where + required := required_601_i2 + envelope := envelope_601_i2 + height := height_601_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_601_i2 +def height_601_i8 : ℕ := 10 +def childrenH_601_i8 : Fin 2 → ℕ := ![height_406, height_501] +theorem height_exact_601_i8 : height_601_i8 = 1 + Finset.univ.sup childrenH_601_i8 := by decide +kernel +theorem required_origin_601_i8 : ∀ x ∈ required_601_i8, + (∃ j, x ∈ childrenC_601_i8 j) ∨ ∀ j, x ∈ childrenD_601_i8 j := by decide +kernel +theorem required_exact_601_i8 : required_601_i8 = + ((Finset.univ.biUnion childrenC_601_i8) ∪ commonEnvelope childrenD_601_i8).erase (4, 4) := by + exact required_eq_combination childrenC_601_i8 childrenD_601_i8 (4, 4) required_601_i8 + (by decide +kernel) child_required_sub_601_i8 common_sub_601_i8 required_origin_601_i8 +theorem envelope_origin_601_i8 : ∀ x ∈ envelope_601_i8, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_601_i8 j := by decide +kernel +theorem envelope_exact_601_i8 : envelope_601_i8 = + insert (4, 4) (Finset.univ.biUnion childrenD_601_i8) := by + exact envelope_eq_combination childrenD_601_i8 (4, 4) envelope_601_i8 + pivot_mem_601_i8 child_envelope_sub_601_i8 envelope_origin_601_i8 +def checked_601_i8 : CheckedCard where + required := required_601_i8 + envelope := envelope_601_i8 + height := height_601_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_601_i8 +def height_601 : ℕ := 11 +def childrenH_601 : Fin 4 → ℕ := ![height_247, height_601_i0, height_601_i2, height_601_i8] +theorem height_exact_601 : height_601 = 1 + Finset.univ.sup childrenH_601 := by decide +kernel +theorem required_origin_601 : ∀ x ∈ required_601, + (∃ j, x ∈ childrenC_601 j) ∨ ∀ j, x ∈ childrenD_601 j := by decide +kernel +theorem required_exact_601 : required_601 = + ((Finset.univ.biUnion childrenC_601) ∪ commonEnvelope childrenD_601).erase (4, 3) := by + exact required_eq_combination childrenC_601 childrenD_601 (4, 3) required_601 + (by decide +kernel) child_required_sub_601 common_sub_601 required_origin_601 +theorem envelope_origin_601 : ∀ x ∈ envelope_601, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_601 j := by decide +kernel +theorem envelope_exact_601 : envelope_601 = + insert (4, 3) (Finset.univ.biUnion childrenD_601) := by + exact envelope_eq_combination childrenD_601 (4, 3) envelope_601 + pivot_mem_601 child_envelope_sub_601 envelope_origin_601 +def checked_601 : CheckedCard where + required := required_601 + envelope := envelope_601 + height := height_601 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_601 +def height_613 : ℕ := 11 +def childrenH_613 : Fin 6 → ℕ := ![height_104, height_329, height_409, height_612, height_612, height_612] +theorem height_exact_613 : height_613 = 1 + Finset.univ.sup childrenH_613 := by decide +kernel +theorem required_origin_613 : ∀ x ∈ required_613, + (∃ j, x ∈ childrenC_613 j) ∨ ∀ j, x ∈ childrenD_613 j := by decide +kernel +theorem required_exact_613 : required_613 = + ((Finset.univ.biUnion childrenC_613) ∪ commonEnvelope childrenD_613).erase (2, 5) := by + exact required_eq_combination childrenC_613 childrenD_613 (2, 5) required_613 + (by decide +kernel) child_required_sub_613 common_sub_613 required_origin_613 +theorem envelope_origin_613 : ∀ x ∈ envelope_613, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_613 j := by decide +kernel +theorem envelope_exact_613 : envelope_613 = + insert (2, 5) (Finset.univ.biUnion childrenD_613) := by + exact envelope_eq_combination childrenD_613 (2, 5) envelope_613 + pivot_mem_613 child_envelope_sub_613 envelope_origin_613 +def checked_613 : CheckedCard where + required := required_613 + envelope := envelope_613 + height := height_613 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_613 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part04.lean new file mode 100644 index 0000000..e20210d --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part04.lean @@ -0,0 +1,880 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_615_i5 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 4), (4, 5), (4, 6), (5, 5), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_615_i5 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_615_i5 : Fin 3 → Finset Cell := ![(placed21 4 (4, 7) required_11), (placed21 4 (3, 6) required_20), (placed21 0 (3, 2) required_402)] +def childrenD_615_i5 : Fin 3 → Finset Cell := ![(placed21 4 (4, 7) envelope_11), (placed21 4 (3, 6) envelope_20), (placed21 0 (3, 2) envelope_402)] +theorem common_sub_615_i5 : commonEnvelope childrenD_615_i5 ⊆ insert (4, 3) required_615_i5 := by decide +kernel +theorem child_required_sub_615_i5 : ∀ j, childrenC_615_i5 j ⊆ insert (4, 3) required_615_i5 := by decide +kernel +theorem child_envelope_sub_615_i5 : ∀ j, childrenD_615_i5 j ⊆ envelope_615_i5 := by decide +kernel +theorem pivot_mem_615_i5 : (4, 3) ∈ envelope_615_i5 := by decide +kernel +theorem children_work_615_i5 : ∀ j, Template HasSnaky 3 (childrenC_615_i5 j) (childrenD_615_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 4 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_20 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_402 0 (3, 2)).mono (by decide +kernel) +theorem row_works_615_i5 : Template HasSnaky 4 required_615_i5 envelope_615_i5 := by + refine compose HasSnaky 3 childrenC_615_i5 childrenD_615_i5 children_work_615_i5 (4, 3) + required_615_i5 envelope_615_i5 pivot_mem_615_i5 child_required_sub_615_i5 child_envelope_sub_615_i5 ?_ + intro b hb + exact common_sub_615_i5 (mem_commonEnvelope childrenD_615_i5 b hb) +def required_615_i4 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 5), (4, 6), (5, 5), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_615_i4 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_615_i4 : Fin 2 → Finset Cell := ![(placed21 6 (7, 5) required_0), required_615_i5] +def childrenD_615_i4 : Fin 2 → Finset Cell := ![(placed21 6 (7, 5) envelope_0), envelope_615_i5] +theorem common_sub_615_i4 : commonEnvelope childrenD_615_i4 ⊆ insert (4, 4) required_615_i4 := by decide +kernel +theorem child_required_sub_615_i4 : ∀ j, childrenC_615_i4 j ⊆ insert (4, 4) required_615_i4 := by decide +kernel +theorem child_envelope_sub_615_i4 : ∀ j, childrenD_615_i4 j ⊆ envelope_615_i4 := by decide +kernel +theorem pivot_mem_615_i4 : (4, 4) ∈ envelope_615_i4 := by decide +kernel +theorem children_work_615_i4 : ∀ j, Template HasSnaky 4 (childrenC_615_i4 j) (childrenD_615_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (7, 5)).mono (by decide +kernel) + · exact row_works_615_i5.mono (by decide +kernel) +theorem row_works_615_i4 : Template HasSnaky 5 required_615_i4 envelope_615_i4 := by + refine compose HasSnaky 4 childrenC_615_i4 childrenD_615_i4 children_work_615_i4 (4, 4) + required_615_i4 envelope_615_i4 pivot_mem_615_i4 child_required_sub_615_i4 child_envelope_sub_615_i4 ?_ + intro b hb + exact common_sub_615_i4 (mem_commonEnvelope childrenD_615_i4 b hb) +def required_615_i3 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 5), (4, 6), (5, 5), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_615_i3 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_615_i3 : Fin 2 → Finset Cell := ![(placed21 4 (3, 5) required_5), required_615_i4] +def childrenD_615_i3 : Fin 2 → Finset Cell := ![(placed21 4 (3, 5) envelope_5), envelope_615_i4] +theorem common_sub_615_i3 : commonEnvelope childrenD_615_i3 ⊆ insert (6, 5) required_615_i3 := by decide +kernel +theorem child_required_sub_615_i3 : ∀ j, childrenC_615_i3 j ⊆ insert (6, 5) required_615_i3 := by decide +kernel +theorem child_envelope_sub_615_i3 : ∀ j, childrenD_615_i3 j ⊆ envelope_615_i3 := by decide +kernel +theorem pivot_mem_615_i3 : (6, 5) ∈ envelope_615_i3 := by decide +kernel +theorem children_work_615_i3 : ∀ j, Template HasSnaky 5 (childrenC_615_i3 j) (childrenD_615_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (3, 5)).mono (by decide +kernel) + · exact row_works_615_i4.mono (by decide +kernel) +theorem row_works_615_i3 : Template HasSnaky 6 required_615_i3 envelope_615_i3 := by + refine compose HasSnaky 5 childrenC_615_i3 childrenD_615_i3 children_work_615_i3 (6, 5) + required_615_i3 envelope_615_i3 pivot_mem_615_i3 child_required_sub_615_i3 child_envelope_sub_615_i3 ?_ + intro b hb + exact common_sub_615_i3 (mem_commonEnvelope childrenD_615_i3 b hb) +def required_615_i2 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 5), (4, 6), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_615_i2 : Finset Cell := ⟨(([(0, 6), (1, 5), (1, 6), (2, 5), (2, 6), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_615_i2 : Fin 3 → Finset Cell := ![(placed21 3 (2, 5) required_139), (placed21 5 (6, 4) required_148), required_615_i3] +def childrenD_615_i2 : Fin 3 → Finset Cell := ![(placed21 3 (2, 5) envelope_139), (placed21 5 (6, 4) envelope_148), envelope_615_i3] +theorem common_sub_615_i2 : commonEnvelope childrenD_615_i2 ⊆ insert (6, 4) required_615_i2 := by decide +kernel +theorem child_required_sub_615_i2 : ∀ j, childrenC_615_i2 j ⊆ insert (6, 4) required_615_i2 := by decide +kernel +theorem child_envelope_sub_615_i2 : ∀ j, childrenD_615_i2 j ⊆ envelope_615_i2 := by decide +kernel +theorem pivot_mem_615_i2 : (6, 4) ∈ envelope_615_i2 := by decide +kernel +theorem children_work_615_i2 : ∀ j, Template HasSnaky 6 (childrenC_615_i2 j) (childrenD_615_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_139 3 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_148 5 (6, 4)).mono (by decide +kernel) + · exact row_works_615_i3.mono (by decide +kernel) +theorem row_works_615_i2 : Template HasSnaky 7 required_615_i2 envelope_615_i2 := by + refine compose HasSnaky 6 childrenC_615_i2 childrenD_615_i2 children_work_615_i2 (6, 4) + required_615_i2 envelope_615_i2 pivot_mem_615_i2 child_required_sub_615_i2 child_envelope_sub_615_i2 ?_ + intro b hb + exact common_sub_615_i2 (mem_commonEnvelope childrenD_615_i2 b hb) +def required_615_i1 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_615_i1 : Finset Cell := ⟨(([(0, 6), (1, 5), (1, 6), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_615_i1 : Fin 3 → Finset Cell := ![(placed21 0 (3, 3) required_43), (placed21 4 (2, 8) required_57), required_615_i2] +def childrenD_615_i1 : Fin 3 → Finset Cell := ![(placed21 0 (3, 3) envelope_43), (placed21 4 (2, 8) envelope_57), envelope_615_i2] +theorem common_sub_615_i1 : commonEnvelope childrenD_615_i1 ⊆ insert (4, 6) required_615_i1 := by decide +kernel +theorem child_required_sub_615_i1 : ∀ j, childrenC_615_i1 j ⊆ insert (4, 6) required_615_i1 := by decide +kernel +theorem child_envelope_sub_615_i1 : ∀ j, childrenD_615_i1 j ⊆ envelope_615_i1 := by decide +kernel +theorem pivot_mem_615_i1 : (4, 6) ∈ envelope_615_i1 := by decide +kernel +theorem children_work_615_i1 : ∀ j, Template HasSnaky 7 (childrenC_615_i1 j) (childrenD_615_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_43 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_57 4 (2, 8)).mono (by decide +kernel) + · exact row_works_615_i2.mono (by decide +kernel) +theorem row_works_615_i1 : Template HasSnaky 8 required_615_i1 envelope_615_i1 := by + refine compose HasSnaky 7 childrenC_615_i1 childrenD_615_i1 children_work_615_i1 (4, 6) + required_615_i1 envelope_615_i1 pivot_mem_615_i1 child_required_sub_615_i1 child_envelope_sub_615_i1 ?_ + intro b hb + exact common_sub_615_i1 (mem_commonEnvelope childrenD_615_i1 b hb) +def required_615_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_615_i0 : Finset Cell := ⟨(([(0, 6), (1, 5), (1, 6), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_615_i0 : Fin 7 → Finset Cell := ![(placed21 2 (6, 2) required_116), (placed21 4 (2, 7) required_134), (placed21 4 (2, 7) required_180), (placed21 4 (2, 8) required_435), (placed21 4 (3, 7) required_558), (placed21 0 (2, 0) required_561), required_615_i1] +def childrenD_615_i0 : Fin 7 → Finset Cell := ![(placed21 2 (6, 2) envelope_116), (placed21 4 (2, 7) envelope_134), (placed21 4 (2, 7) envelope_180), (placed21 4 (2, 8) envelope_435), (placed21 4 (3, 7) envelope_558), (placed21 0 (2, 0) envelope_561), envelope_615_i1] +theorem common_sub_615_i0 : commonEnvelope childrenD_615_i0 ⊆ insert (5, 5) required_615_i0 := by decide +kernel +theorem child_required_sub_615_i0 : ∀ j, childrenC_615_i0 j ⊆ insert (5, 5) required_615_i0 := by decide +kernel +theorem child_envelope_sub_615_i0 : ∀ j, childrenD_615_i0 j ⊆ envelope_615_i0 := by decide +kernel +theorem pivot_mem_615_i0 : (5, 5) ∈ envelope_615_i0 := by decide +kernel +theorem children_work_615_i0 : ∀ j, Template HasSnaky 9 (childrenC_615_i0 j) (childrenD_615_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_116 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_134 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_180 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_435 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_558 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_561 0 (2, 0)).mono (by decide +kernel) + · exact row_works_615_i1.mono (by decide +kernel) +theorem row_works_615_i0 : Template HasSnaky 10 required_615_i0 envelope_615_i0 := by + refine compose HasSnaky 9 childrenC_615_i0 childrenD_615_i0 children_work_615_i0 (5, 5) + required_615_i0 envelope_615_i0 pivot_mem_615_i0 child_required_sub_615_i0 child_envelope_sub_615_i0 ?_ + intro b hb + exact common_sub_615_i0 (mem_commonEnvelope childrenD_615_i0 b hb) +def required_615 : Finset Cell := ⟨(([(0, 3), (0, 4), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_615 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 4), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 2), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_615 : Fin 3 → Finset Cell := ![(placed21 0 (0, 1) required_362), required_614, required_615_i0] +def childrenD_615 : Fin 3 → Finset Cell := ![(placed21 0 (0, 1) envelope_362), envelope_614, envelope_615_i0] +theorem common_sub_615 : commonEnvelope childrenD_615 ⊆ insert (4, 5) required_615 := by decide +kernel +theorem child_required_sub_615 : ∀ j, childrenC_615 j ⊆ insert (4, 5) required_615 := by decide +kernel +theorem child_envelope_sub_615 : ∀ j, childrenD_615 j ⊆ envelope_615 := by decide +kernel +theorem pivot_mem_615 : (4, 5) ∈ envelope_615 := by decide +kernel +theorem children_work_615 : ∀ j, Template HasSnaky 10 (childrenC_615 j) (childrenD_615 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_362 0 (0, 1)).mono (by decide +kernel) + · exact row_works_614.mono (by decide +kernel) + · exact row_works_615_i0.mono (by decide +kernel) +theorem row_works_615 : Template HasSnaky 11 required_615 envelope_615 := by + refine compose HasSnaky 10 childrenC_615 childrenD_615 children_work_615 (4, 5) + required_615 envelope_615 pivot_mem_615 child_required_sub_615 child_envelope_sub_615 ?_ + intro b hb + exact common_sub_615 (mem_commonEnvelope childrenD_615 b hb) +def required_617 : Finset Cell := ⟨(([(3, 4), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_617 : Finset Cell := ⟨(([(0, 5), (0, 6), (1, 5), (1, 6), (2, 2), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 3), (8, 4), (8, 5), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_617 : Fin 4 → Finset Cell := ![(placed21 6 (5, 7) required_14), (placed21 4 (2, 6) required_136), (placed21 7 (7, 6) required_332), (placed21 0 (2, 1) required_616)] +def childrenD_617 : Fin 4 → Finset Cell := ![(placed21 6 (5, 7) envelope_14), (placed21 4 (2, 6) envelope_136), (placed21 7 (7, 6) envelope_332), (placed21 0 (2, 1) envelope_616)] +theorem common_sub_617 : commonEnvelope childrenD_617 ⊆ insert (4, 3) required_617 := by decide +kernel +theorem child_required_sub_617 : ∀ j, childrenC_617 j ⊆ insert (4, 3) required_617 := by decide +kernel +theorem child_envelope_sub_617 : ∀ j, childrenD_617 j ⊆ envelope_617 := by decide +kernel +theorem pivot_mem_617 : (4, 3) ∈ envelope_617 := by decide +kernel +theorem children_work_617 : ∀ j, Template HasSnaky 10 (childrenC_617 j) (childrenD_617 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_136 4 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_332 7 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_616 0 (2, 1)).mono (by decide +kernel) +theorem row_works_617 : Template HasSnaky 11 required_617 envelope_617 := by + refine compose HasSnaky 10 childrenC_617 childrenD_617 children_work_617 (4, 3) + required_617 envelope_617 pivot_mem_617 child_required_sub_617 child_envelope_sub_617 ?_ + intro b hb + exact common_sub_617 (mem_commonEnvelope childrenD_617 b hb) +def required_624_i1 : Finset Cell := ⟨(([(1, 4), (3, 3), (3, 4), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_624_i1 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 3), (2, 4), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_624_i1 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) required_64), (placed21 2 (4, 2) required_315)] +def childrenD_624_i1 : Fin 2 → Finset Cell := ![(placed21 3 (0, 4) envelope_64), (placed21 2 (4, 2) envelope_315)] +theorem common_sub_624_i1 : commonEnvelope childrenD_624_i1 ⊆ insert (4, 3) required_624_i1 := by decide +kernel +theorem child_required_sub_624_i1 : ∀ j, childrenC_624_i1 j ⊆ insert (4, 3) required_624_i1 := by decide +kernel +theorem child_envelope_sub_624_i1 : ∀ j, childrenD_624_i1 j ⊆ envelope_624_i1 := by decide +kernel +theorem pivot_mem_624_i1 : (4, 3) ∈ envelope_624_i1 := by decide +kernel +theorem children_work_624_i1 : ∀ j, Template HasSnaky 6 (childrenC_624_i1 j) (childrenD_624_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_64 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_315 2 (4, 2)).mono (by decide +kernel) +theorem row_works_624_i1 : Template HasSnaky 7 required_624_i1 envelope_624_i1 := by + refine compose HasSnaky 6 childrenC_624_i1 childrenD_624_i1 children_work_624_i1 (4, 3) + required_624_i1 envelope_624_i1 pivot_mem_624_i1 child_required_sub_624_i1 child_envelope_sub_624_i1 ?_ + intro b hb + exact common_sub_624_i1 (mem_commonEnvelope childrenD_624_i1 b hb) +def required_624_i0 : Finset Cell := ⟨(([(1, 4), (3, 4), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_624_i0 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_624_i0 : Fin 4 → Finset Cell := ![(placed21 6 (4, 6) required_10), (placed21 0 (3, 2) required_52), (placed21 4 (0, 6) required_82), required_624_i1] +def childrenD_624_i0 : Fin 4 → Finset Cell := ![(placed21 6 (4, 6) envelope_10), (placed21 0 (3, 2) envelope_52), (placed21 4 (0, 6) envelope_82), envelope_624_i1] +theorem common_sub_624_i0 : commonEnvelope childrenD_624_i0 ⊆ insert (3, 3) required_624_i0 := by decide +kernel +theorem child_required_sub_624_i0 : ∀ j, childrenC_624_i0 j ⊆ insert (3, 3) required_624_i0 := by decide +kernel +theorem child_envelope_sub_624_i0 : ∀ j, childrenD_624_i0 j ⊆ envelope_624_i0 := by decide +kernel +theorem pivot_mem_624_i0 : (3, 3) ∈ envelope_624_i0 := by decide +kernel +theorem children_work_624_i0 : ∀ j, Template HasSnaky 7 (childrenC_624_i0 j) (childrenD_624_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_82 4 (0, 6)).mono (by decide +kernel) + · exact row_works_624_i1.mono (by decide +kernel) +theorem row_works_624_i0 : Template HasSnaky 8 required_624_i0 envelope_624_i0 := by + refine compose HasSnaky 7 childrenC_624_i0 childrenD_624_i0 children_work_624_i0 (3, 3) + required_624_i0 envelope_624_i0 pivot_mem_624_i0 child_required_sub_624_i0 child_envelope_sub_624_i0 ?_ + intro b hb + exact common_sub_624_i0 (mem_commonEnvelope childrenD_624_i0 b hb) +def required_624 : Finset Cell := ⟨(([(1, 4), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_624 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 2), (5, 3), (5, 4), (5, 5), (6, 2), (6, 3), (6, 4), (6, 5), (7, 2), (7, 3), (7, 4), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_624 : Fin 3 → Finset Cell := ![(placed21 1 (0, 4) required_54), (placed21 0 (2, 0) required_545), required_624_i0] +def childrenD_624 : Fin 3 → Finset Cell := ![(placed21 1 (0, 4) envelope_54), (placed21 0 (2, 0) envelope_545), envelope_624_i0] +theorem common_sub_624 : commonEnvelope childrenD_624 ⊆ insert (3, 4) required_624 := by decide +kernel +theorem child_required_sub_624 : ∀ j, childrenC_624 j ⊆ insert (3, 4) required_624 := by decide +kernel +theorem child_envelope_sub_624 : ∀ j, childrenD_624 j ⊆ envelope_624 := by decide +kernel +theorem pivot_mem_624 : (3, 4) ∈ envelope_624 := by decide +kernel +theorem children_work_624 : ∀ j, Template HasSnaky 10 (childrenC_624 j) (childrenD_624 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_545 0 (2, 0)).mono (by decide +kernel) + · exact row_works_624_i0.mono (by decide +kernel) +theorem row_works_624 : Template HasSnaky 11 required_624 envelope_624 := by + refine compose HasSnaky 10 childrenC_624 childrenD_624 children_work_624 (3, 4) + required_624 envelope_624 pivot_mem_624 child_required_sub_624 child_envelope_sub_624 ?_ + intro b hb + exact common_sub_624 (mem_commonEnvelope childrenD_624 b hb) +def required_625_i2 : Finset Cell := ⟨(([(1, 3), (3, 2), (3, 3), (3, 4), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_625_i2 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 3), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (5, 2), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_625_i2 : Fin 2 → Finset Cell := ![(placed21 7 (6, 4) required_56), (placed21 2 (4, 0) required_73)] +def childrenD_625_i2 : Fin 2 → Finset Cell := ![(placed21 7 (6, 4) envelope_56), (placed21 2 (4, 0) envelope_73)] +theorem common_sub_625_i2 : commonEnvelope childrenD_625_i2 ⊆ insert (3, 1) required_625_i2 := by decide +kernel +theorem child_required_sub_625_i2 : ∀ j, childrenC_625_i2 j ⊆ insert (3, 1) required_625_i2 := by decide +kernel +theorem child_envelope_sub_625_i2 : ∀ j, childrenD_625_i2 j ⊆ envelope_625_i2 := by decide +kernel +theorem pivot_mem_625_i2 : (3, 1) ∈ envelope_625_i2 := by decide +kernel +theorem children_work_625_i2 : ∀ j, Template HasSnaky 4 (childrenC_625_i2 j) (childrenD_625_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_56 7 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_73 2 (4, 0)).mono (by decide +kernel) +theorem row_works_625_i2 : Template HasSnaky 5 required_625_i2 envelope_625_i2 := by + refine compose HasSnaky 4 childrenC_625_i2 childrenD_625_i2 children_work_625_i2 (3, 1) + required_625_i2 envelope_625_i2 pivot_mem_625_i2 child_required_sub_625_i2 child_envelope_sub_625_i2 ?_ + intro b hb + exact common_sub_625_i2 (mem_commonEnvelope childrenD_625_i2 b hb) +def required_625_i1 : Finset Cell := ⟨(([(1, 3), (3, 2), (3, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_625_i1 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 3), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 4), (6, 2), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_625_i1 : Fin 3 → Finset Cell := ![(placed21 2 (4, 1) required_10), (placed21 0 (0, 1) required_82), required_625_i2] +def childrenD_625_i1 : Fin 3 → Finset Cell := ![(placed21 2 (4, 1) envelope_10), (placed21 0 (0, 1) envelope_82), envelope_625_i2] +theorem common_sub_625_i1 : commonEnvelope childrenD_625_i1 ⊆ insert (3, 4) required_625_i1 := by decide +kernel +theorem child_required_sub_625_i1 : ∀ j, childrenC_625_i1 j ⊆ insert (3, 4) required_625_i1 := by decide +kernel +theorem child_envelope_sub_625_i1 : ∀ j, childrenD_625_i1 j ⊆ envelope_625_i1 := by decide +kernel +theorem pivot_mem_625_i1 : (3, 4) ∈ envelope_625_i1 := by decide +kernel +theorem children_work_625_i1 : ∀ j, Template HasSnaky 5 (childrenC_625_i1 j) (childrenD_625_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_82 0 (0, 1)).mono (by decide +kernel) + · exact row_works_625_i2.mono (by decide +kernel) +theorem row_works_625_i1 : Template HasSnaky 6 required_625_i1 envelope_625_i1 := by + refine compose HasSnaky 5 childrenC_625_i1 childrenD_625_i1 children_work_625_i1 (3, 4) + required_625_i1 envelope_625_i1 pivot_mem_625_i1 child_required_sub_625_i1 child_envelope_sub_625_i1 ?_ + intro b hb + exact common_sub_625_i1 (mem_commonEnvelope childrenD_625_i1 b hb) +def required_625_i0 : Finset Cell := ⟨(([(1, 3), (3, 2), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_625_i0 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 3), (2, 0), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_625_i0 : Fin 4 → Finset Cell := ![(placed21 3 (0, 3) required_54), (placed21 5 (6, 1) required_294), (placed21 1 (0, 0) required_449), required_625_i1] +def childrenD_625_i0 : Fin 4 → Finset Cell := ![(placed21 3 (0, 3) envelope_54), (placed21 5 (6, 1) envelope_294), (placed21 1 (0, 0) envelope_449), envelope_625_i1] +theorem common_sub_625_i0 : commonEnvelope childrenD_625_i0 ⊆ insert (3, 3) required_625_i0 := by decide +kernel +theorem child_required_sub_625_i0 : ∀ j, childrenC_625_i0 j ⊆ insert (3, 3) required_625_i0 := by decide +kernel +theorem child_envelope_sub_625_i0 : ∀ j, childrenD_625_i0 j ⊆ envelope_625_i0 := by decide +kernel +theorem pivot_mem_625_i0 : (3, 3) ∈ envelope_625_i0 := by decide +kernel +theorem children_work_625_i0 : ∀ j, Template HasSnaky 9 (childrenC_625_i0 j) (childrenD_625_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_294 5 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_449 1 (0, 0)).mono (by decide +kernel) + · exact row_works_625_i1.mono (by decide +kernel) +theorem row_works_625_i0 : Template HasSnaky 10 required_625_i0 envelope_625_i0 := by + refine compose HasSnaky 9 childrenC_625_i0 childrenD_625_i0 children_work_625_i0 (3, 3) + required_625_i0 envelope_625_i0 pivot_mem_625_i0 child_required_sub_625_i0 child_envelope_sub_625_i0 ?_ + intro b hb + exact common_sub_625_i0 (mem_commonEnvelope childrenD_625_i0 b hb) +def required_625 : Finset Cell := ⟨(([(1, 2), (1, 3), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_625 : Finset Cell := ⟨(([(0, 1), (0, 3), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_625 : Fin 5 → Finset Cell := ![(placed21 3 (0, 3) required_50), (placed21 3 (0, 3) required_125), (placed21 5 (5, 1) required_454), (placed21 0 (1, 1) required_455), required_625_i0] +def childrenD_625 : Fin 5 → Finset Cell := ![(placed21 3 (0, 3) envelope_50), (placed21 3 (0, 3) envelope_125), (placed21 5 (5, 1) envelope_454), (placed21 0 (1, 1) envelope_455), envelope_625_i0] +theorem common_sub_625 : commonEnvelope childrenD_625 ⊆ insert (3, 2) required_625 := by decide +kernel +theorem child_required_sub_625 : ∀ j, childrenC_625 j ⊆ insert (3, 2) required_625 := by decide +kernel +theorem child_envelope_sub_625 : ∀ j, childrenD_625 j ⊆ envelope_625 := by decide +kernel +theorem pivot_mem_625 : (3, 2) ∈ envelope_625 := by decide +kernel +theorem children_work_625 : ∀ j, Template HasSnaky 10 (childrenC_625 j) (childrenD_625 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_50 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_125 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_454 5 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_455 0 (1, 1)).mono (by decide +kernel) + · exact row_works_625_i0.mono (by decide +kernel) +theorem row_works_625 : Template HasSnaky 11 required_625 envelope_625 := by + refine compose HasSnaky 10 childrenC_625 childrenD_625 children_work_625 (3, 2) + required_625 envelope_625 pivot_mem_625 child_required_sub_625 child_envelope_sub_625 ?_ + intro b hb + exact common_sub_625 (mem_commonEnvelope childrenD_625 b hb) +def required_626_i1 : Finset Cell := ⟨(([(2, 3), (3, 5), (3, 6), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_626_i1 : Finset Cell := ⟨(([(1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (3, 5), (3, 6), (4, 5), (5, 5), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_626_i1 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) required_5), (placed21 6 (5, 6) required_38)] +def childrenD_626_i1 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) envelope_5), (placed21 6 (5, 6) envelope_38)] +theorem common_sub_626_i1 : commonEnvelope childrenD_626_i1 ⊆ insert (2, 5) required_626_i1 := by decide +kernel +theorem child_required_sub_626_i1 : ∀ j, childrenC_626_i1 j ⊆ insert (2, 5) required_626_i1 := by decide +kernel +theorem child_envelope_sub_626_i1 : ∀ j, childrenD_626_i1 j ⊆ envelope_626_i1 := by decide +kernel +theorem pivot_mem_626_i1 : (2, 5) ∈ envelope_626_i1 := by decide +kernel +theorem children_work_626_i1 : ∀ j, Template HasSnaky 2 (childrenC_626_i1 j) (childrenD_626_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_38 6 (5, 6)).mono (by decide +kernel) +theorem row_works_626_i1 : Template HasSnaky 3 required_626_i1 envelope_626_i1 := by + refine compose HasSnaky 2 childrenC_626_i1 childrenD_626_i1 children_work_626_i1 (2, 5) + required_626_i1 envelope_626_i1 pivot_mem_626_i1 child_required_sub_626_i1 child_envelope_sub_626_i1 ?_ + intro b hb + exact common_sub_626_i1 (mem_commonEnvelope childrenD_626_i1 b hb) +def required_626_i0 : Finset Cell := ⟨(([(2, 3), (3, 5), (3, 6), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_626_i0 : Finset Cell := ⟨(([(1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 8), (3, 5), (3, 6), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 4), (7, 7), (8, 4), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_626_i0 : Fin 3 → Finset Cell := ![(placed21 4 (2, 9) required_317), required_626_i1, (placed21 0 (2, 2) required_519)] +def childrenD_626_i0 : Fin 3 → Finset Cell := ![(placed21 4 (2, 9) envelope_317), envelope_626_i1, (placed21 0 (2, 2) envelope_519)] +theorem common_sub_626_i0 : commonEnvelope childrenD_626_i0 ⊆ insert (4, 5) required_626_i0 := by decide +kernel +theorem child_required_sub_626_i0 : ∀ j, childrenC_626_i0 j ⊆ insert (4, 5) required_626_i0 := by decide +kernel +theorem child_envelope_sub_626_i0 : ∀ j, childrenD_626_i0 j ⊆ envelope_626_i0 := by decide +kernel +theorem pivot_mem_626_i0 : (4, 5) ∈ envelope_626_i0 := by decide +kernel +theorem children_work_626_i0 : ∀ j, Template HasSnaky 9 (childrenC_626_i0 j) (childrenD_626_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_317 4 (2, 9)).mono (by decide +kernel) + · exact row_works_626_i1.mono (by decide +kernel) + · exact (placed21_template row_works_519 0 (2, 2)).mono (by decide +kernel) +theorem row_works_626_i0 : Template HasSnaky 10 required_626_i0 envelope_626_i0 := by + refine compose HasSnaky 9 childrenC_626_i0 childrenD_626_i0 children_work_626_i0 (4, 5) + required_626_i0 envelope_626_i0 pivot_mem_626_i0 child_required_sub_626_i0 child_envelope_sub_626_i0 ?_ + intro b hb + exact common_sub_626_i0 (mem_commonEnvelope childrenD_626_i0 b hb) +def required_626_i3 : Finset Cell := ⟨(([(2, 6), (3, 5), (3, 6), (4, 6), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_626_i3 : Finset Cell := ⟨(([(1, 5), (1, 7), (1, 8), (1, 9), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 5), (3, 6), (3, 8), (3, 9), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_626_i3 : Fin 2 → Finset Cell := ![(placed21 6 (5, 6) required_5), (placed21 1 (1, 5) required_412)] +def childrenD_626_i3 : Fin 2 → Finset Cell := ![(placed21 6 (5, 6) envelope_5), (placed21 1 (1, 5) envelope_412)] +theorem common_sub_626_i3 : commonEnvelope childrenD_626_i3 ⊆ insert (2, 5) required_626_i3 := by decide +kernel +theorem child_required_sub_626_i3 : ∀ j, childrenC_626_i3 j ⊆ insert (2, 5) required_626_i3 := by decide +kernel +theorem child_envelope_sub_626_i3 : ∀ j, childrenD_626_i3 j ⊆ envelope_626_i3 := by decide +kernel +theorem pivot_mem_626_i3 : (2, 5) ∈ envelope_626_i3 := by decide +kernel +theorem children_work_626_i3 : ∀ j, Template HasSnaky 8 (childrenC_626_i3 j) (childrenD_626_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_412 1 (1, 5)).mono (by decide +kernel) +theorem row_works_626_i3 : Template HasSnaky 9 required_626_i3 envelope_626_i3 := by + refine compose HasSnaky 8 childrenC_626_i3 childrenD_626_i3 children_work_626_i3 (2, 5) + required_626_i3 envelope_626_i3 pivot_mem_626_i3 child_required_sub_626_i3 child_envelope_sub_626_i3 ?_ + intro b hb + exact common_sub_626_i3 (mem_commonEnvelope childrenD_626_i3 b hb) +def required_626_i2 : Finset Cell := ⟨(([(2, 6), (3, 5), (3, 6), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_626_i2 : Finset Cell := ⟨(([(1, 5), (1, 7), (1, 8), (1, 9), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 5), (3, 6), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_626_i2 : Fin 3 → Finset Cell := ![(placed21 3 (1, 6) required_11), (placed21 1 (2, 5) required_336), required_626_i3] +def childrenD_626_i2 : Fin 3 → Finset Cell := ![(placed21 3 (1, 6) envelope_11), (placed21 1 (2, 5) envelope_336), envelope_626_i3] +theorem common_sub_626_i2 : commonEnvelope childrenD_626_i2 ⊆ insert (4, 6) required_626_i2 := by decide +kernel +theorem child_required_sub_626_i2 : ∀ j, childrenC_626_i2 j ⊆ insert (4, 6) required_626_i2 := by decide +kernel +theorem child_envelope_sub_626_i2 : ∀ j, childrenD_626_i2 j ⊆ envelope_626_i2 := by decide +kernel +theorem pivot_mem_626_i2 : (4, 6) ∈ envelope_626_i2 := by decide +kernel +theorem children_work_626_i2 : ∀ j, Template HasSnaky 9 (childrenC_626_i2 j) (childrenD_626_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_336 1 (2, 5)).mono (by decide +kernel) + · exact row_works_626_i3.mono (by decide +kernel) +theorem row_works_626_i2 : Template HasSnaky 10 required_626_i2 envelope_626_i2 := by + refine compose HasSnaky 9 childrenC_626_i2 childrenD_626_i2 children_work_626_i2 (4, 6) + required_626_i2 envelope_626_i2 pivot_mem_626_i2 child_required_sub_626_i2 child_envelope_sub_626_i2 ?_ + intro b hb + exact common_sub_626_i2 (mem_commonEnvelope childrenD_626_i2 b hb) +def required_626 : Finset Cell := ⟨(([(2, 3), (2, 6), (3, 5), (3, 6), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_626 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 5), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 5), (3, 6), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 4), (7, 5), (7, 6), (7, 7), (8, 4), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_626 : Fin 5 → Finset Cell := ![(placed21 2 (6, 2) required_323), (placed21 0 (2, 2) required_430), (placed21 7 (6, 6) required_592), required_626_i0, required_626_i2] +def childrenD_626 : Fin 5 → Finset Cell := ![(placed21 2 (6, 2) envelope_323), (placed21 0 (2, 2) envelope_430), (placed21 7 (6, 6) envelope_592), envelope_626_i0, envelope_626_i2] +theorem common_sub_626 : commonEnvelope childrenD_626 ⊆ insert (5, 6) required_626 := by decide +kernel +theorem child_required_sub_626 : ∀ j, childrenC_626 j ⊆ insert (5, 6) required_626 := by decide +kernel +theorem child_envelope_sub_626 : ∀ j, childrenD_626 j ⊆ envelope_626 := by decide +kernel +theorem pivot_mem_626 : (5, 6) ∈ envelope_626 := by decide +kernel +theorem children_work_626 : ∀ j, Template HasSnaky 10 (childrenC_626 j) (childrenD_626 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_323 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_430 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_592 7 (6, 6)).mono (by decide +kernel) + · exact row_works_626_i0.mono (by decide +kernel) + · exact row_works_626_i2.mono (by decide +kernel) +theorem row_works_626 : Template HasSnaky 11 required_626 envelope_626 := by + refine compose HasSnaky 10 childrenC_626 childrenD_626 children_work_626 (5, 6) + required_626 envelope_626 pivot_mem_626 child_required_sub_626 child_envelope_sub_626 ?_ + intro b hb + exact common_sub_626 (mem_commonEnvelope childrenD_626 b hb) +def height_615_i5 : ℕ := 4 +def childrenH_615_i5 : Fin 3 → ℕ := ![height_11, height_20, height_402] +theorem height_exact_615_i5 : height_615_i5 = 1 + Finset.univ.sup childrenH_615_i5 := by decide +kernel +theorem required_origin_615_i5 : ∀ x ∈ required_615_i5, + (∃ j, x ∈ childrenC_615_i5 j) ∨ ∀ j, x ∈ childrenD_615_i5 j := by decide +kernel +theorem required_exact_615_i5 : required_615_i5 = + ((Finset.univ.biUnion childrenC_615_i5) ∪ commonEnvelope childrenD_615_i5).erase (4, 3) := by + exact required_eq_combination childrenC_615_i5 childrenD_615_i5 (4, 3) required_615_i5 + (by decide +kernel) child_required_sub_615_i5 common_sub_615_i5 required_origin_615_i5 +theorem envelope_origin_615_i5 : ∀ x ∈ envelope_615_i5, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_615_i5 j := by decide +kernel +theorem envelope_exact_615_i5 : envelope_615_i5 = + insert (4, 3) (Finset.univ.biUnion childrenD_615_i5) := by + exact envelope_eq_combination childrenD_615_i5 (4, 3) envelope_615_i5 + pivot_mem_615_i5 child_envelope_sub_615_i5 envelope_origin_615_i5 +def checked_615_i5 : CheckedCard where + required := required_615_i5 + envelope := envelope_615_i5 + height := height_615_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_615_i5 +def height_615_i4 : ℕ := 5 +def childrenH_615_i4 : Fin 2 → ℕ := ![height_0, height_615_i5] +theorem height_exact_615_i4 : height_615_i4 = 1 + Finset.univ.sup childrenH_615_i4 := by decide +kernel +theorem required_origin_615_i4 : ∀ x ∈ required_615_i4, + (∃ j, x ∈ childrenC_615_i4 j) ∨ ∀ j, x ∈ childrenD_615_i4 j := by decide +kernel +theorem required_exact_615_i4 : required_615_i4 = + ((Finset.univ.biUnion childrenC_615_i4) ∪ commonEnvelope childrenD_615_i4).erase (4, 4) := by + exact required_eq_combination childrenC_615_i4 childrenD_615_i4 (4, 4) required_615_i4 + (by decide +kernel) child_required_sub_615_i4 common_sub_615_i4 required_origin_615_i4 +theorem envelope_origin_615_i4 : ∀ x ∈ envelope_615_i4, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_615_i4 j := by decide +kernel +theorem envelope_exact_615_i4 : envelope_615_i4 = + insert (4, 4) (Finset.univ.biUnion childrenD_615_i4) := by + exact envelope_eq_combination childrenD_615_i4 (4, 4) envelope_615_i4 + pivot_mem_615_i4 child_envelope_sub_615_i4 envelope_origin_615_i4 +def checked_615_i4 : CheckedCard where + required := required_615_i4 + envelope := envelope_615_i4 + height := height_615_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_615_i4 +def height_615_i3 : ℕ := 6 +def childrenH_615_i3 : Fin 2 → ℕ := ![height_5, height_615_i4] +theorem height_exact_615_i3 : height_615_i3 = 1 + Finset.univ.sup childrenH_615_i3 := by decide +kernel +theorem required_origin_615_i3 : ∀ x ∈ required_615_i3, + (∃ j, x ∈ childrenC_615_i3 j) ∨ ∀ j, x ∈ childrenD_615_i3 j := by decide +kernel +theorem required_exact_615_i3 : required_615_i3 = + ((Finset.univ.biUnion childrenC_615_i3) ∪ commonEnvelope childrenD_615_i3).erase (6, 5) := by + exact required_eq_combination childrenC_615_i3 childrenD_615_i3 (6, 5) required_615_i3 + (by decide +kernel) child_required_sub_615_i3 common_sub_615_i3 required_origin_615_i3 +theorem envelope_origin_615_i3 : ∀ x ∈ envelope_615_i3, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_615_i3 j := by decide +kernel +theorem envelope_exact_615_i3 : envelope_615_i3 = + insert (6, 5) (Finset.univ.biUnion childrenD_615_i3) := by + exact envelope_eq_combination childrenD_615_i3 (6, 5) envelope_615_i3 + pivot_mem_615_i3 child_envelope_sub_615_i3 envelope_origin_615_i3 +def checked_615_i3 : CheckedCard where + required := required_615_i3 + envelope := envelope_615_i3 + height := height_615_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_615_i3 +def height_615_i2 : ℕ := 7 +def childrenH_615_i2 : Fin 3 → ℕ := ![height_139, height_148, height_615_i3] +theorem height_exact_615_i2 : height_615_i2 = 1 + Finset.univ.sup childrenH_615_i2 := by decide +kernel +theorem required_origin_615_i2 : ∀ x ∈ required_615_i2, + (∃ j, x ∈ childrenC_615_i2 j) ∨ ∀ j, x ∈ childrenD_615_i2 j := by decide +kernel +theorem required_exact_615_i2 : required_615_i2 = + ((Finset.univ.biUnion childrenC_615_i2) ∪ commonEnvelope childrenD_615_i2).erase (6, 4) := by + exact required_eq_combination childrenC_615_i2 childrenD_615_i2 (6, 4) required_615_i2 + (by decide +kernel) child_required_sub_615_i2 common_sub_615_i2 required_origin_615_i2 +theorem envelope_origin_615_i2 : ∀ x ∈ envelope_615_i2, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_615_i2 j := by decide +kernel +theorem envelope_exact_615_i2 : envelope_615_i2 = + insert (6, 4) (Finset.univ.biUnion childrenD_615_i2) := by + exact envelope_eq_combination childrenD_615_i2 (6, 4) envelope_615_i2 + pivot_mem_615_i2 child_envelope_sub_615_i2 envelope_origin_615_i2 +def checked_615_i2 : CheckedCard where + required := required_615_i2 + envelope := envelope_615_i2 + height := height_615_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_615_i2 +def height_615_i1 : ℕ := 8 +def childrenH_615_i1 : Fin 3 → ℕ := ![height_43, height_57, height_615_i2] +theorem height_exact_615_i1 : height_615_i1 = 1 + Finset.univ.sup childrenH_615_i1 := by decide +kernel +theorem required_origin_615_i1 : ∀ x ∈ required_615_i1, + (∃ j, x ∈ childrenC_615_i1 j) ∨ ∀ j, x ∈ childrenD_615_i1 j := by decide +kernel +theorem required_exact_615_i1 : required_615_i1 = + ((Finset.univ.biUnion childrenC_615_i1) ∪ commonEnvelope childrenD_615_i1).erase (4, 6) := by + exact required_eq_combination childrenC_615_i1 childrenD_615_i1 (4, 6) required_615_i1 + (by decide +kernel) child_required_sub_615_i1 common_sub_615_i1 required_origin_615_i1 +theorem envelope_origin_615_i1 : ∀ x ∈ envelope_615_i1, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_615_i1 j := by decide +kernel +theorem envelope_exact_615_i1 : envelope_615_i1 = + insert (4, 6) (Finset.univ.biUnion childrenD_615_i1) := by + exact envelope_eq_combination childrenD_615_i1 (4, 6) envelope_615_i1 + pivot_mem_615_i1 child_envelope_sub_615_i1 envelope_origin_615_i1 +def checked_615_i1 : CheckedCard where + required := required_615_i1 + envelope := envelope_615_i1 + height := height_615_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_615_i1 +def height_615_i0 : ℕ := 10 +def childrenH_615_i0 : Fin 7 → ℕ := ![height_116, height_134, height_180, height_435, height_558, height_561, height_615_i1] +theorem height_exact_615_i0 : height_615_i0 = 1 + Finset.univ.sup childrenH_615_i0 := by decide +kernel +theorem required_origin_615_i0 : ∀ x ∈ required_615_i0, + (∃ j, x ∈ childrenC_615_i0 j) ∨ ∀ j, x ∈ childrenD_615_i0 j := by decide +kernel +theorem required_exact_615_i0 : required_615_i0 = + ((Finset.univ.biUnion childrenC_615_i0) ∪ commonEnvelope childrenD_615_i0).erase (5, 5) := by + exact required_eq_combination childrenC_615_i0 childrenD_615_i0 (5, 5) required_615_i0 + (by decide +kernel) child_required_sub_615_i0 common_sub_615_i0 required_origin_615_i0 +theorem envelope_origin_615_i0 : ∀ x ∈ envelope_615_i0, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_615_i0 j := by decide +kernel +theorem envelope_exact_615_i0 : envelope_615_i0 = + insert (5, 5) (Finset.univ.biUnion childrenD_615_i0) := by + exact envelope_eq_combination childrenD_615_i0 (5, 5) envelope_615_i0 + pivot_mem_615_i0 child_envelope_sub_615_i0 envelope_origin_615_i0 +def checked_615_i0 : CheckedCard where + required := required_615_i0 + envelope := envelope_615_i0 + height := height_615_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_615_i0 +def height_615 : ℕ := 11 +def childrenH_615 : Fin 3 → ℕ := ![height_362, height_614, height_615_i0] +theorem height_exact_615 : height_615 = 1 + Finset.univ.sup childrenH_615 := by decide +kernel +theorem required_origin_615 : ∀ x ∈ required_615, + (∃ j, x ∈ childrenC_615 j) ∨ ∀ j, x ∈ childrenD_615 j := by decide +kernel +theorem required_exact_615 : required_615 = + ((Finset.univ.biUnion childrenC_615) ∪ commonEnvelope childrenD_615).erase (4, 5) := by + exact required_eq_combination childrenC_615 childrenD_615 (4, 5) required_615 + (by decide +kernel) child_required_sub_615 common_sub_615 required_origin_615 +theorem envelope_origin_615 : ∀ x ∈ envelope_615, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_615 j := by decide +kernel +theorem envelope_exact_615 : envelope_615 = + insert (4, 5) (Finset.univ.biUnion childrenD_615) := by + exact envelope_eq_combination childrenD_615 (4, 5) envelope_615 + pivot_mem_615 child_envelope_sub_615 envelope_origin_615 +def checked_615 : CheckedCard where + required := required_615 + envelope := envelope_615 + height := height_615 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_615 +def height_617 : ℕ := 11 +def childrenH_617 : Fin 4 → ℕ := ![height_14, height_136, height_332, height_616] +theorem height_exact_617 : height_617 = 1 + Finset.univ.sup childrenH_617 := by decide +kernel +theorem required_origin_617 : ∀ x ∈ required_617, + (∃ j, x ∈ childrenC_617 j) ∨ ∀ j, x ∈ childrenD_617 j := by decide +kernel +theorem required_exact_617 : required_617 = + ((Finset.univ.biUnion childrenC_617) ∪ commonEnvelope childrenD_617).erase (4, 3) := by + exact required_eq_combination childrenC_617 childrenD_617 (4, 3) required_617 + (by decide +kernel) child_required_sub_617 common_sub_617 required_origin_617 +theorem envelope_origin_617 : ∀ x ∈ envelope_617, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_617 j := by decide +kernel +theorem envelope_exact_617 : envelope_617 = + insert (4, 3) (Finset.univ.biUnion childrenD_617) := by + exact envelope_eq_combination childrenD_617 (4, 3) envelope_617 + pivot_mem_617 child_envelope_sub_617 envelope_origin_617 +def checked_617 : CheckedCard where + required := required_617 + envelope := envelope_617 + height := height_617 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_617 +def height_624_i1 : ℕ := 7 +def childrenH_624_i1 : Fin 2 → ℕ := ![height_64, height_315] +theorem height_exact_624_i1 : height_624_i1 = 1 + Finset.univ.sup childrenH_624_i1 := by decide +kernel +theorem required_origin_624_i1 : ∀ x ∈ required_624_i1, + (∃ j, x ∈ childrenC_624_i1 j) ∨ ∀ j, x ∈ childrenD_624_i1 j := by decide +kernel +theorem required_exact_624_i1 : required_624_i1 = + ((Finset.univ.biUnion childrenC_624_i1) ∪ commonEnvelope childrenD_624_i1).erase (4, 3) := by + exact required_eq_combination childrenC_624_i1 childrenD_624_i1 (4, 3) required_624_i1 + (by decide +kernel) child_required_sub_624_i1 common_sub_624_i1 required_origin_624_i1 +theorem envelope_origin_624_i1 : ∀ x ∈ envelope_624_i1, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_624_i1 j := by decide +kernel +theorem envelope_exact_624_i1 : envelope_624_i1 = + insert (4, 3) (Finset.univ.biUnion childrenD_624_i1) := by + exact envelope_eq_combination childrenD_624_i1 (4, 3) envelope_624_i1 + pivot_mem_624_i1 child_envelope_sub_624_i1 envelope_origin_624_i1 +def checked_624_i1 : CheckedCard where + required := required_624_i1 + envelope := envelope_624_i1 + height := height_624_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_624_i1 +def height_624_i0 : ℕ := 8 +def childrenH_624_i0 : Fin 4 → ℕ := ![height_10, height_52, height_82, height_624_i1] +theorem height_exact_624_i0 : height_624_i0 = 1 + Finset.univ.sup childrenH_624_i0 := by decide +kernel +theorem required_origin_624_i0 : ∀ x ∈ required_624_i0, + (∃ j, x ∈ childrenC_624_i0 j) ∨ ∀ j, x ∈ childrenD_624_i0 j := by decide +kernel +theorem required_exact_624_i0 : required_624_i0 = + ((Finset.univ.biUnion childrenC_624_i0) ∪ commonEnvelope childrenD_624_i0).erase (3, 3) := by + exact required_eq_combination childrenC_624_i0 childrenD_624_i0 (3, 3) required_624_i0 + (by decide +kernel) child_required_sub_624_i0 common_sub_624_i0 required_origin_624_i0 +theorem envelope_origin_624_i0 : ∀ x ∈ envelope_624_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_624_i0 j := by decide +kernel +theorem envelope_exact_624_i0 : envelope_624_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_624_i0) := by + exact envelope_eq_combination childrenD_624_i0 (3, 3) envelope_624_i0 + pivot_mem_624_i0 child_envelope_sub_624_i0 envelope_origin_624_i0 +def checked_624_i0 : CheckedCard where + required := required_624_i0 + envelope := envelope_624_i0 + height := height_624_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_624_i0 +def height_624 : ℕ := 11 +def childrenH_624 : Fin 3 → ℕ := ![height_54, height_545, height_624_i0] +theorem height_exact_624 : height_624 = 1 + Finset.univ.sup childrenH_624 := by decide +kernel +theorem required_origin_624 : ∀ x ∈ required_624, + (∃ j, x ∈ childrenC_624 j) ∨ ∀ j, x ∈ childrenD_624 j := by decide +kernel +theorem required_exact_624 : required_624 = + ((Finset.univ.biUnion childrenC_624) ∪ commonEnvelope childrenD_624).erase (3, 4) := by + exact required_eq_combination childrenC_624 childrenD_624 (3, 4) required_624 + (by decide +kernel) child_required_sub_624 common_sub_624 required_origin_624 +theorem envelope_origin_624 : ∀ x ∈ envelope_624, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_624 j := by decide +kernel +theorem envelope_exact_624 : envelope_624 = + insert (3, 4) (Finset.univ.biUnion childrenD_624) := by + exact envelope_eq_combination childrenD_624 (3, 4) envelope_624 + pivot_mem_624 child_envelope_sub_624 envelope_origin_624 +def checked_624 : CheckedCard where + required := required_624 + envelope := envelope_624 + height := height_624 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_624 +def height_625_i2 : ℕ := 5 +def childrenH_625_i2 : Fin 2 → ℕ := ![height_56, height_73] +theorem height_exact_625_i2 : height_625_i2 = 1 + Finset.univ.sup childrenH_625_i2 := by decide +kernel +theorem required_origin_625_i2 : ∀ x ∈ required_625_i2, + (∃ j, x ∈ childrenC_625_i2 j) ∨ ∀ j, x ∈ childrenD_625_i2 j := by decide +kernel +theorem required_exact_625_i2 : required_625_i2 = + ((Finset.univ.biUnion childrenC_625_i2) ∪ commonEnvelope childrenD_625_i2).erase (3, 1) := by + exact required_eq_combination childrenC_625_i2 childrenD_625_i2 (3, 1) required_625_i2 + (by decide +kernel) child_required_sub_625_i2 common_sub_625_i2 required_origin_625_i2 +theorem envelope_origin_625_i2 : ∀ x ∈ envelope_625_i2, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_625_i2 j := by decide +kernel +theorem envelope_exact_625_i2 : envelope_625_i2 = + insert (3, 1) (Finset.univ.biUnion childrenD_625_i2) := by + exact envelope_eq_combination childrenD_625_i2 (3, 1) envelope_625_i2 + pivot_mem_625_i2 child_envelope_sub_625_i2 envelope_origin_625_i2 +def checked_625_i2 : CheckedCard where + required := required_625_i2 + envelope := envelope_625_i2 + height := height_625_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_625_i2 +def height_625_i1 : ℕ := 6 +def childrenH_625_i1 : Fin 3 → ℕ := ![height_10, height_82, height_625_i2] +theorem height_exact_625_i1 : height_625_i1 = 1 + Finset.univ.sup childrenH_625_i1 := by decide +kernel +theorem required_origin_625_i1 : ∀ x ∈ required_625_i1, + (∃ j, x ∈ childrenC_625_i1 j) ∨ ∀ j, x ∈ childrenD_625_i1 j := by decide +kernel +theorem required_exact_625_i1 : required_625_i1 = + ((Finset.univ.biUnion childrenC_625_i1) ∪ commonEnvelope childrenD_625_i1).erase (3, 4) := by + exact required_eq_combination childrenC_625_i1 childrenD_625_i1 (3, 4) required_625_i1 + (by decide +kernel) child_required_sub_625_i1 common_sub_625_i1 required_origin_625_i1 +theorem envelope_origin_625_i1 : ∀ x ∈ envelope_625_i1, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_625_i1 j := by decide +kernel +theorem envelope_exact_625_i1 : envelope_625_i1 = + insert (3, 4) (Finset.univ.biUnion childrenD_625_i1) := by + exact envelope_eq_combination childrenD_625_i1 (3, 4) envelope_625_i1 + pivot_mem_625_i1 child_envelope_sub_625_i1 envelope_origin_625_i1 +def checked_625_i1 : CheckedCard where + required := required_625_i1 + envelope := envelope_625_i1 + height := height_625_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_625_i1 +def height_625_i0 : ℕ := 10 +def childrenH_625_i0 : Fin 4 → ℕ := ![height_54, height_294, height_449, height_625_i1] +theorem height_exact_625_i0 : height_625_i0 = 1 + Finset.univ.sup childrenH_625_i0 := by decide +kernel +theorem required_origin_625_i0 : ∀ x ∈ required_625_i0, + (∃ j, x ∈ childrenC_625_i0 j) ∨ ∀ j, x ∈ childrenD_625_i0 j := by decide +kernel +theorem required_exact_625_i0 : required_625_i0 = + ((Finset.univ.biUnion childrenC_625_i0) ∪ commonEnvelope childrenD_625_i0).erase (3, 3) := by + exact required_eq_combination childrenC_625_i0 childrenD_625_i0 (3, 3) required_625_i0 + (by decide +kernel) child_required_sub_625_i0 common_sub_625_i0 required_origin_625_i0 +theorem envelope_origin_625_i0 : ∀ x ∈ envelope_625_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_625_i0 j := by decide +kernel +theorem envelope_exact_625_i0 : envelope_625_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_625_i0) := by + exact envelope_eq_combination childrenD_625_i0 (3, 3) envelope_625_i0 + pivot_mem_625_i0 child_envelope_sub_625_i0 envelope_origin_625_i0 +def checked_625_i0 : CheckedCard where + required := required_625_i0 + envelope := envelope_625_i0 + height := height_625_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_625_i0 +def height_625 : ℕ := 11 +def childrenH_625 : Fin 5 → ℕ := ![height_50, height_125, height_454, height_455, height_625_i0] +theorem height_exact_625 : height_625 = 1 + Finset.univ.sup childrenH_625 := by decide +kernel +theorem required_origin_625 : ∀ x ∈ required_625, + (∃ j, x ∈ childrenC_625 j) ∨ ∀ j, x ∈ childrenD_625 j := by decide +kernel +theorem required_exact_625 : required_625 = + ((Finset.univ.biUnion childrenC_625) ∪ commonEnvelope childrenD_625).erase (3, 2) := by + exact required_eq_combination childrenC_625 childrenD_625 (3, 2) required_625 + (by decide +kernel) child_required_sub_625 common_sub_625 required_origin_625 +theorem envelope_origin_625 : ∀ x ∈ envelope_625, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_625 j := by decide +kernel +theorem envelope_exact_625 : envelope_625 = + insert (3, 2) (Finset.univ.biUnion childrenD_625) := by + exact envelope_eq_combination childrenD_625 (3, 2) envelope_625 + pivot_mem_625 child_envelope_sub_625 envelope_origin_625 +def checked_625 : CheckedCard where + required := required_625 + envelope := envelope_625 + height := height_625 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_625 +def height_626_i1 : ℕ := 3 +def childrenH_626_i1 : Fin 2 → ℕ := ![height_5, height_38] +theorem height_exact_626_i1 : height_626_i1 = 1 + Finset.univ.sup childrenH_626_i1 := by decide +kernel +theorem required_origin_626_i1 : ∀ x ∈ required_626_i1, + (∃ j, x ∈ childrenC_626_i1 j) ∨ ∀ j, x ∈ childrenD_626_i1 j := by decide +kernel +theorem required_exact_626_i1 : required_626_i1 = + ((Finset.univ.biUnion childrenC_626_i1) ∪ commonEnvelope childrenD_626_i1).erase (2, 5) := by + exact required_eq_combination childrenC_626_i1 childrenD_626_i1 (2, 5) required_626_i1 + (by decide +kernel) child_required_sub_626_i1 common_sub_626_i1 required_origin_626_i1 +theorem envelope_origin_626_i1 : ∀ x ∈ envelope_626_i1, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_626_i1 j := by decide +kernel +theorem envelope_exact_626_i1 : envelope_626_i1 = + insert (2, 5) (Finset.univ.biUnion childrenD_626_i1) := by + exact envelope_eq_combination childrenD_626_i1 (2, 5) envelope_626_i1 + pivot_mem_626_i1 child_envelope_sub_626_i1 envelope_origin_626_i1 +def checked_626_i1 : CheckedCard where + required := required_626_i1 + envelope := envelope_626_i1 + height := height_626_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_626_i1 +def height_626_i0 : ℕ := 10 +def childrenH_626_i0 : Fin 3 → ℕ := ![height_317, height_626_i1, height_519] +theorem height_exact_626_i0 : height_626_i0 = 1 + Finset.univ.sup childrenH_626_i0 := by decide +kernel +theorem required_origin_626_i0 : ∀ x ∈ required_626_i0, + (∃ j, x ∈ childrenC_626_i0 j) ∨ ∀ j, x ∈ childrenD_626_i0 j := by decide +kernel +theorem required_exact_626_i0 : required_626_i0 = + ((Finset.univ.biUnion childrenC_626_i0) ∪ commonEnvelope childrenD_626_i0).erase (4, 5) := by + exact required_eq_combination childrenC_626_i0 childrenD_626_i0 (4, 5) required_626_i0 + (by decide +kernel) child_required_sub_626_i0 common_sub_626_i0 required_origin_626_i0 +theorem envelope_origin_626_i0 : ∀ x ∈ envelope_626_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_626_i0 j := by decide +kernel +theorem envelope_exact_626_i0 : envelope_626_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_626_i0) := by + exact envelope_eq_combination childrenD_626_i0 (4, 5) envelope_626_i0 + pivot_mem_626_i0 child_envelope_sub_626_i0 envelope_origin_626_i0 +def checked_626_i0 : CheckedCard where + required := required_626_i0 + envelope := envelope_626_i0 + height := height_626_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_626_i0 +def height_626_i3 : ℕ := 9 +def childrenH_626_i3 : Fin 2 → ℕ := ![height_5, height_412] +theorem height_exact_626_i3 : height_626_i3 = 1 + Finset.univ.sup childrenH_626_i3 := by decide +kernel +theorem required_origin_626_i3 : ∀ x ∈ required_626_i3, + (∃ j, x ∈ childrenC_626_i3 j) ∨ ∀ j, x ∈ childrenD_626_i3 j := by decide +kernel +theorem required_exact_626_i3 : required_626_i3 = + ((Finset.univ.biUnion childrenC_626_i3) ∪ commonEnvelope childrenD_626_i3).erase (2, 5) := by + exact required_eq_combination childrenC_626_i3 childrenD_626_i3 (2, 5) required_626_i3 + (by decide +kernel) child_required_sub_626_i3 common_sub_626_i3 required_origin_626_i3 +theorem envelope_origin_626_i3 : ∀ x ∈ envelope_626_i3, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_626_i3 j := by decide +kernel +theorem envelope_exact_626_i3 : envelope_626_i3 = + insert (2, 5) (Finset.univ.biUnion childrenD_626_i3) := by + exact envelope_eq_combination childrenD_626_i3 (2, 5) envelope_626_i3 + pivot_mem_626_i3 child_envelope_sub_626_i3 envelope_origin_626_i3 +def checked_626_i3 : CheckedCard where + required := required_626_i3 + envelope := envelope_626_i3 + height := height_626_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_626_i3 +def height_626_i2 : ℕ := 10 +def childrenH_626_i2 : Fin 3 → ℕ := ![height_11, height_336, height_626_i3] +theorem height_exact_626_i2 : height_626_i2 = 1 + Finset.univ.sup childrenH_626_i2 := by decide +kernel +theorem required_origin_626_i2 : ∀ x ∈ required_626_i2, + (∃ j, x ∈ childrenC_626_i2 j) ∨ ∀ j, x ∈ childrenD_626_i2 j := by decide +kernel +theorem required_exact_626_i2 : required_626_i2 = + ((Finset.univ.biUnion childrenC_626_i2) ∪ commonEnvelope childrenD_626_i2).erase (4, 6) := by + exact required_eq_combination childrenC_626_i2 childrenD_626_i2 (4, 6) required_626_i2 + (by decide +kernel) child_required_sub_626_i2 common_sub_626_i2 required_origin_626_i2 +theorem envelope_origin_626_i2 : ∀ x ∈ envelope_626_i2, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_626_i2 j := by decide +kernel +theorem envelope_exact_626_i2 : envelope_626_i2 = + insert (4, 6) (Finset.univ.biUnion childrenD_626_i2) := by + exact envelope_eq_combination childrenD_626_i2 (4, 6) envelope_626_i2 + pivot_mem_626_i2 child_envelope_sub_626_i2 envelope_origin_626_i2 +def checked_626_i2 : CheckedCard where + required := required_626_i2 + envelope := envelope_626_i2 + height := height_626_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_626_i2 +def height_626 : ℕ := 11 +def childrenH_626 : Fin 5 → ℕ := ![height_323, height_430, height_592, height_626_i0, height_626_i2] +theorem height_exact_626 : height_626 = 1 + Finset.univ.sup childrenH_626 := by decide +kernel +theorem required_origin_626 : ∀ x ∈ required_626, + (∃ j, x ∈ childrenC_626 j) ∨ ∀ j, x ∈ childrenD_626 j := by decide +kernel +theorem required_exact_626 : required_626 = + ((Finset.univ.biUnion childrenC_626) ∪ commonEnvelope childrenD_626).erase (5, 6) := by + exact required_eq_combination childrenC_626 childrenD_626 (5, 6) required_626 + (by decide +kernel) child_required_sub_626 common_sub_626 required_origin_626 +theorem envelope_origin_626 : ∀ x ∈ envelope_626, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_626 j := by decide +kernel +theorem envelope_exact_626 : envelope_626 = + insert (5, 6) (Finset.univ.biUnion childrenD_626) := by + exact envelope_eq_combination childrenD_626 (5, 6) envelope_626 + pivot_mem_626 child_envelope_sub_626 envelope_origin_626 +def checked_626 : CheckedCard where + required := required_626 + envelope := envelope_626 + height := height_626 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_626 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part05.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part05.lean new file mode 100644 index 0000000..e99f4fc --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part05.lean @@ -0,0 +1,1022 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part06 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_639_i2 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_639_i2 : Finset Cell := ⟨(([(2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_639_i2 : Fin 3 → Finset Cell := ![(placed21 0 (3, 3) required_21), (placed21 2 (4, 3) required_37), (placed21 6 (4, 7) required_62)] +def childrenD_639_i2 : Fin 3 → Finset Cell := ![(placed21 0 (3, 3) envelope_21), (placed21 2 (4, 3) envelope_37), (placed21 6 (4, 7) envelope_62)] +theorem common_sub_639_i2 : commonEnvelope childrenD_639_i2 ⊆ insert (3, 6) required_639_i2 := by decide +kernel +theorem child_required_sub_639_i2 : ∀ j, childrenC_639_i2 j ⊆ insert (3, 6) required_639_i2 := by decide +kernel +theorem child_envelope_sub_639_i2 : ∀ j, childrenD_639_i2 j ⊆ envelope_639_i2 := by decide +kernel +theorem pivot_mem_639_i2 : (3, 6) ∈ envelope_639_i2 := by decide +kernel +theorem children_work_639_i2 : ∀ j, Template HasSnaky 3 (childrenC_639_i2 j) (childrenD_639_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_37 2 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_62 6 (4, 7)).mono (by decide +kernel) +theorem row_works_639_i2 : Template HasSnaky 4 required_639_i2 envelope_639_i2 := by + refine compose HasSnaky 3 childrenC_639_i2 childrenD_639_i2 children_work_639_i2 (3, 6) + required_639_i2 envelope_639_i2 pivot_mem_639_i2 child_required_sub_639_i2 child_envelope_sub_639_i2 ?_ + intro b hb + exact common_sub_639_i2 (mem_commonEnvelope childrenD_639_i2 b hb) +def required_639_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_639_i1 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_639_i1 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) required_71), (placed21 6 (4, 6) required_73), required_639_i2, (placed21 6 (4, 6) required_451)] +def childrenD_639_i1 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) envelope_71), (placed21 6 (4, 6) envelope_73), envelope_639_i2, (placed21 6 (4, 6) envelope_451)] +theorem common_sub_639_i1 : commonEnvelope childrenD_639_i1 ⊆ insert (3, 5) required_639_i1 := by decide +kernel +theorem child_required_sub_639_i1 : ∀ j, childrenC_639_i1 j ⊆ insert (3, 5) required_639_i1 := by decide +kernel +theorem child_envelope_sub_639_i1 : ∀ j, childrenD_639_i1 j ⊆ envelope_639_i1 := by decide +kernel +theorem pivot_mem_639_i1 : (3, 5) ∈ envelope_639_i1 := by decide +kernel +theorem children_work_639_i1 : ∀ j, Template HasSnaky 5 (childrenC_639_i1 j) (childrenD_639_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_71 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_73 6 (4, 6)).mono (by decide +kernel) + · exact row_works_639_i2.mono (by decide +kernel) + · exact (placed21_template row_works_451 6 (4, 6)).mono (by decide +kernel) +theorem row_works_639_i1 : Template HasSnaky 6 required_639_i1 envelope_639_i1 := by + refine compose HasSnaky 5 childrenC_639_i1 childrenD_639_i1 children_work_639_i1 (3, 5) + required_639_i1 envelope_639_i1 pivot_mem_639_i1 child_required_sub_639_i1 child_envelope_sub_639_i1 ?_ + intro b hb + exact common_sub_639_i1 (mem_commonEnvelope childrenD_639_i1 b hb) +def required_639_i3 : Finset Cell := ⟨(([(1, 3), (1, 4), (3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_639_i3 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_639_i3 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) required_71), (placed21 6 (4, 6) required_73), (placed21 5 (6, 2) required_435), (placed21 6 (4, 6) required_451)] +def childrenD_639_i3 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) envelope_71), (placed21 6 (4, 6) envelope_73), (placed21 5 (6, 2) envelope_435), (placed21 6 (4, 6) envelope_451)] +theorem common_sub_639_i3 : commonEnvelope childrenD_639_i3 ⊆ insert (3, 5) required_639_i3 := by decide +kernel +theorem child_required_sub_639_i3 : ∀ j, childrenC_639_i3 j ⊆ insert (3, 5) required_639_i3 := by decide +kernel +theorem child_envelope_sub_639_i3 : ∀ j, childrenD_639_i3 j ⊆ envelope_639_i3 := by decide +kernel +theorem pivot_mem_639_i3 : (3, 5) ∈ envelope_639_i3 := by decide +kernel +theorem children_work_639_i3 : ∀ j, Template HasSnaky 6 (childrenC_639_i3 j) (childrenD_639_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_71 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_73 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_451 6 (4, 6)).mono (by decide +kernel) +theorem row_works_639_i3 : Template HasSnaky 7 required_639_i3 envelope_639_i3 := by + refine compose HasSnaky 6 childrenC_639_i3 childrenD_639_i3 children_work_639_i3 (3, 5) + required_639_i3 envelope_639_i3 pivot_mem_639_i3 child_required_sub_639_i3 child_envelope_sub_639_i3 ?_ + intro b hb + exact common_sub_639_i3 (mem_commonEnvelope childrenD_639_i3 b hb) +def required_639_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_639_i0 : Finset Cell := ⟨(([(0, 3), (0, 5), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_639_i0 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) required_54), (placed21 1 (0, 2) required_638), required_639_i1, required_639_i3] +def childrenD_639_i0 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) envelope_54), (placed21 1 (0, 2) envelope_638), envelope_639_i1, envelope_639_i3] +theorem common_sub_639_i0 : commonEnvelope childrenD_639_i0 ⊆ insert (3, 3) required_639_i0 := by decide +kernel +theorem child_required_sub_639_i0 : ∀ j, childrenC_639_i0 j ⊆ insert (3, 3) required_639_i0 := by decide +kernel +theorem child_envelope_sub_639_i0 : ∀ j, childrenD_639_i0 j ⊆ envelope_639_i0 := by decide +kernel +theorem pivot_mem_639_i0 : (3, 3) ∈ envelope_639_i0 := by decide +kernel +theorem children_work_639_i0 : ∀ j, Template HasSnaky 9 (childrenC_639_i0 j) (childrenD_639_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_638 1 (0, 2)).mono (by decide +kernel) + · exact row_works_639_i1.mono (by decide +kernel) + · exact row_works_639_i3.mono (by decide +kernel) +theorem row_works_639_i0 : Template HasSnaky 10 required_639_i0 envelope_639_i0 := by + refine compose HasSnaky 9 childrenC_639_i0 childrenD_639_i0 children_work_639_i0 (3, 3) + required_639_i0 envelope_639_i0 pivot_mem_639_i0 child_required_sub_639_i0 child_envelope_sub_639_i0 ?_ + intro b hb + exact common_sub_639_i0 (mem_commonEnvelope childrenD_639_i0 b hb) +def required_639 : Finset Cell := ⟨(([(1, 3), (1, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_639 : Finset Cell := ⟨(([(0, 3), (0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_639 : Fin 5 → Finset Cell := ![(placed21 1 (0, 3) required_50), (placed21 1 (0, 3) required_125), (placed21 0 (0, 2) required_478), (placed21 0 (0, 2) required_482), required_639_i0] +def childrenD_639 : Fin 5 → Finset Cell := ![(placed21 1 (0, 3) envelope_50), (placed21 1 (0, 3) envelope_125), (placed21 0 (0, 2) envelope_478), (placed21 0 (0, 2) envelope_482), envelope_639_i0] +theorem common_sub_639 : commonEnvelope childrenD_639 ⊆ insert (3, 4) required_639 := by decide +kernel +theorem child_required_sub_639 : ∀ j, childrenC_639 j ⊆ insert (3, 4) required_639 := by decide +kernel +theorem child_envelope_sub_639 : ∀ j, childrenD_639 j ⊆ envelope_639 := by decide +kernel +theorem pivot_mem_639 : (3, 4) ∈ envelope_639 := by decide +kernel +theorem children_work_639 : ∀ j, Template HasSnaky 10 (childrenC_639 j) (childrenD_639 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_50 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_125 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_478 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_482 0 (0, 2)).mono (by decide +kernel) + · exact row_works_639_i0.mono (by decide +kernel) +theorem row_works_639 : Template HasSnaky 11 required_639 envelope_639 := by + refine compose HasSnaky 10 childrenC_639 childrenD_639 children_work_639 (3, 4) + required_639 envelope_639 pivot_mem_639 child_required_sub_639 child_envelope_sub_639 ?_ + intro b hb + exact common_sub_639 (mem_commonEnvelope childrenD_639 b hb) +def required_646_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_646_i0 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_646_i0 : Fin 3 → Finset Cell := ![(placed21 2 (4, 1) required_15), (placed21 1 (2, 2) required_72), (placed21 7 (6, 5) required_262)] +def childrenD_646_i0 : Fin 3 → Finset Cell := ![(placed21 2 (4, 1) envelope_15), (placed21 1 (2, 2) envelope_72), (placed21 7 (6, 5) envelope_262)] +theorem common_sub_646_i0 : commonEnvelope childrenD_646_i0 ⊆ insert (4, 2) required_646_i0 := by decide +kernel +theorem child_required_sub_646_i0 : ∀ j, childrenC_646_i0 j ⊆ insert (4, 2) required_646_i0 := by decide +kernel +theorem child_envelope_sub_646_i0 : ∀ j, childrenD_646_i0 j ⊆ envelope_646_i0 := by decide +kernel +theorem pivot_mem_646_i0 : (4, 2) ∈ envelope_646_i0 := by decide +kernel +theorem children_work_646_i0 : ∀ j, Template HasSnaky 5 (childrenC_646_i0 j) (childrenD_646_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_72 1 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_262 7 (6, 5)).mono (by decide +kernel) +theorem row_works_646_i0 : Template HasSnaky 6 required_646_i0 envelope_646_i0 := by + refine compose HasSnaky 5 childrenC_646_i0 childrenD_646_i0 children_work_646_i0 (4, 2) + required_646_i0 envelope_646_i0 pivot_mem_646_i0 child_required_sub_646_i0 child_envelope_sub_646_i0 ?_ + intro b hb + exact common_sub_646_i0 (mem_commonEnvelope childrenD_646_i0 b hb) +def required_646 : Finset Cell := ⟨(([(3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_646 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_646 : Fin 6 → Finset Cell := ![(placed21 0 (1, 1) required_361), (placed21 5 (6, 1) required_361), (placed21 1 (0, 3) required_411), (placed21 5 (7, 1) required_600), (placed21 3 (0, 7) required_621), required_646_i0] +def childrenD_646 : Fin 6 → Finset Cell := ![(placed21 0 (1, 1) envelope_361), (placed21 5 (6, 1) envelope_361), (placed21 1 (0, 3) envelope_411), (placed21 5 (7, 1) envelope_600), (placed21 3 (0, 7) envelope_621), envelope_646_i0] +theorem common_sub_646 : commonEnvelope childrenD_646 ⊆ insert (4, 4) required_646 := by decide +kernel +theorem child_required_sub_646 : ∀ j, childrenC_646 j ⊆ insert (4, 4) required_646 := by decide +kernel +theorem child_envelope_sub_646 : ∀ j, childrenD_646 j ⊆ envelope_646 := by decide +kernel +theorem pivot_mem_646 : (4, 4) ∈ envelope_646 := by decide +kernel +theorem children_work_646 : ∀ j, Template HasSnaky 10 (childrenC_646 j) (childrenD_646 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_361 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_361 5 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_411 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_600 5 (7, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_621 3 (0, 7)).mono (by decide +kernel) + · exact row_works_646_i0.mono (by decide +kernel) +theorem row_works_646 : Template HasSnaky 11 required_646 envelope_646 := by + refine compose HasSnaky 10 childrenC_646 childrenD_646 children_work_646 (4, 4) + required_646 envelope_646 pivot_mem_646 child_required_sub_646 child_envelope_sub_646 ?_ + intro b hb + exact common_sub_646 (mem_commonEnvelope childrenD_646 b hb) +def required_653_i0 : Finset Cell := ⟨(([(2, 4), (3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_653_i0 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (6, 5), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_653_i0 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) required_206), (placed21 0 (2, 1) required_301), (placed21 5 (5, 3) required_405)] +def childrenD_653_i0 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) envelope_206), (placed21 0 (2, 1) envelope_301), (placed21 5 (5, 3) envelope_405)] +theorem common_sub_653_i0 : commonEnvelope childrenD_653_i0 ⊆ insert (4, 4) required_653_i0 := by decide +kernel +theorem child_required_sub_653_i0 : ∀ j, childrenC_653_i0 j ⊆ insert (4, 4) required_653_i0 := by decide +kernel +theorem child_envelope_sub_653_i0 : ∀ j, childrenD_653_i0 j ⊆ envelope_653_i0 := by decide +kernel +theorem pivot_mem_653_i0 : (4, 4) ∈ envelope_653_i0 := by decide +kernel +theorem children_work_653_i0 : ∀ j, Template HasSnaky 8 (childrenC_653_i0 j) (childrenD_653_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_206 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_301 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_405 5 (5, 3)).mono (by decide +kernel) +theorem row_works_653_i0 : Template HasSnaky 9 required_653_i0 envelope_653_i0 := by + refine compose HasSnaky 8 childrenC_653_i0 childrenD_653_i0 children_work_653_i0 (4, 4) + required_653_i0 envelope_653_i0 pivot_mem_653_i0 child_required_sub_653_i0 child_envelope_sub_653_i0 ?_ + intro b hb + exact common_sub_653_i0 (mem_commonEnvelope childrenD_653_i0 b hb) +def required_653 : Finset Cell := ⟨(([(3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_653 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 2), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_653 : Fin 4 → Finset Cell := ![(placed21 3 (0, 4) required_53), (placed21 5 (6, 3) required_53), (placed21 0 (1, 0) required_652), required_653_i0] +def childrenD_653 : Fin 4 → Finset Cell := ![(placed21 3 (0, 4) envelope_53), (placed21 5 (6, 3) envelope_53), (placed21 0 (1, 0) envelope_652), envelope_653_i0] +theorem common_sub_653 : commonEnvelope childrenD_653 ⊆ insert (2, 4) required_653 := by decide +kernel +theorem child_required_sub_653 : ∀ j, childrenC_653 j ⊆ insert (2, 4) required_653 := by decide +kernel +theorem child_envelope_sub_653 : ∀ j, childrenD_653 j ⊆ envelope_653 := by decide +kernel +theorem pivot_mem_653 : (2, 4) ∈ envelope_653 := by decide +kernel +theorem children_work_653 : ∀ j, Template HasSnaky 10 (childrenC_653 j) (childrenD_653 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_53 5 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_652 0 (1, 0)).mono (by decide +kernel) + · exact row_works_653_i0.mono (by decide +kernel) +theorem row_works_653 : Template HasSnaky 11 required_653 envelope_653 := by + refine compose HasSnaky 10 childrenC_653 childrenD_653 children_work_653 (2, 4) + required_653 envelope_653 pivot_mem_653 child_required_sub_653 child_envelope_sub_653 ?_ + intro b hb + exact common_sub_653 (mem_commonEnvelope childrenD_653 b hb) +def required_660_i1 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_660_i1 : Finset Cell := ⟨(([(2, 6), (3, 5), (3, 6), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (6, 5), (7, 5), (8, 4), (8, 5), (8, 6), (9, 4), (9, 5), (9, 6), (10, 4), (10, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_660_i1 : Fin 2 → Finset Cell := ![(placed21 5 (7, 5) required_6), (placed21 1 (4, 4) required_18)] +def childrenD_660_i1 : Fin 2 → Finset Cell := ![(placed21 5 (7, 5) envelope_6), (placed21 1 (4, 4) envelope_18)] +theorem common_sub_660_i1 : commonEnvelope childrenD_660_i1 ⊆ insert (7, 5) required_660_i1 := by decide +kernel +theorem child_required_sub_660_i1 : ∀ j, childrenC_660_i1 j ⊆ insert (7, 5) required_660_i1 := by decide +kernel +theorem child_envelope_sub_660_i1 : ∀ j, childrenD_660_i1 j ⊆ envelope_660_i1 := by decide +kernel +theorem pivot_mem_660_i1 : (7, 5) ∈ envelope_660_i1 := by decide +kernel +theorem children_work_660_i1 : ∀ j, Template HasSnaky 4 (childrenC_660_i1 j) (childrenD_660_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 5 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_18 1 (4, 4)).mono (by decide +kernel) +theorem row_works_660_i1 : Template HasSnaky 5 required_660_i1 envelope_660_i1 := by + refine compose HasSnaky 4 childrenC_660_i1 childrenD_660_i1 children_work_660_i1 (7, 5) + required_660_i1 envelope_660_i1 pivot_mem_660_i1 child_required_sub_660_i1 child_envelope_sub_660_i1 ?_ + intro b hb + exact common_sub_660_i1 (mem_commonEnvelope childrenD_660_i1 b hb) +def required_660_i2 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_660_i2 : Finset Cell := ⟨(([(2, 6), (3, 5), (3, 6), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (8, 5), (8, 6), (9, 5), (9, 6), (10, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_660_i2 : Fin 2 → Finset Cell := ![(placed21 5 (7, 5) required_6), (placed21 0 (3, 2) required_252)] +def childrenD_660_i2 : Fin 2 → Finset Cell := ![(placed21 5 (7, 5) envelope_6), (placed21 0 (3, 2) envelope_252)] +theorem common_sub_660_i2 : commonEnvelope childrenD_660_i2 ⊆ insert (7, 5) required_660_i2 := by decide +kernel +theorem child_required_sub_660_i2 : ∀ j, childrenC_660_i2 j ⊆ insert (7, 5) required_660_i2 := by decide +kernel +theorem child_envelope_sub_660_i2 : ∀ j, childrenD_660_i2 j ⊆ envelope_660_i2 := by decide +kernel +theorem pivot_mem_660_i2 : (7, 5) ∈ envelope_660_i2 := by decide +kernel +theorem children_work_660_i2 : ∀ j, Template HasSnaky 5 (childrenC_660_i2 j) (childrenD_660_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 5 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_252 0 (3, 2)).mono (by decide +kernel) +theorem row_works_660_i2 : Template HasSnaky 6 required_660_i2 envelope_660_i2 := by + refine compose HasSnaky 5 childrenC_660_i2 childrenD_660_i2 children_work_660_i2 (7, 5) + required_660_i2 envelope_660_i2 pivot_mem_660_i2 child_required_sub_660_i2 child_envelope_sub_660_i2 ?_ + intro b hb + exact common_sub_660_i2 (mem_commonEnvelope childrenD_660_i2 b hb) +def required_660_i0 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_660_i0 : Finset Cell := ⟨(([(2, 6), (3, 5), (3, 6), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (10, 2), (10, 4), (10, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_660_i0 : Fin 4 → Finset Cell := ![(placed21 3 (2, 6) required_9), required_660_i1, (placed21 0 (3, 0) required_659), required_660_i2] +def childrenD_660_i0 : Fin 4 → Finset Cell := ![(placed21 3 (2, 6) envelope_9), envelope_660_i1, (placed21 0 (3, 0) envelope_659), envelope_660_i2] +theorem common_sub_660_i0 : commonEnvelope childrenD_660_i0 ⊆ insert (6, 5) required_660_i0 := by decide +kernel +theorem child_required_sub_660_i0 : ∀ j, childrenC_660_i0 j ⊆ insert (6, 5) required_660_i0 := by decide +kernel +theorem child_envelope_sub_660_i0 : ∀ j, childrenD_660_i0 j ⊆ envelope_660_i0 := by decide +kernel +theorem pivot_mem_660_i0 : (6, 5) ∈ envelope_660_i0 := by decide +kernel +theorem children_work_660_i0 : ∀ j, Template HasSnaky 9 (childrenC_660_i0 j) (childrenD_660_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 3 (2, 6)).mono (by decide +kernel) + · exact row_works_660_i1.mono (by decide +kernel) + · exact (placed21_template row_works_659 0 (3, 0)).mono (by decide +kernel) + · exact row_works_660_i2.mono (by decide +kernel) +theorem row_works_660_i0 : Template HasSnaky 10 required_660_i0 envelope_660_i0 := by + refine compose HasSnaky 9 childrenC_660_i0 childrenD_660_i0 children_work_660_i0 (6, 5) + required_660_i0 envelope_660_i0 pivot_mem_660_i0 child_required_sub_660_i0 child_envelope_sub_660_i0 ?_ + intro b hb + exact common_sub_660_i0 (mem_commonEnvelope childrenD_660_i0 b hb) +def required_660 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_660 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (10, 2), (10, 4), (10, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_660 : Fin 4 → Finset Cell := ![(placed21 5 (7, 4) required_13), (placed21 2 (6, 3) required_137), (placed21 6 (6, 8) required_332), required_660_i0] +def childrenD_660 : Fin 4 → Finset Cell := ![(placed21 5 (7, 4) envelope_13), (placed21 2 (6, 3) envelope_137), (placed21 6 (6, 8) envelope_332), envelope_660_i0] +theorem common_sub_660 : commonEnvelope childrenD_660 ⊆ insert (3, 5) required_660 := by decide +kernel +theorem child_required_sub_660 : ∀ j, childrenC_660 j ⊆ insert (3, 5) required_660 := by decide +kernel +theorem child_envelope_sub_660 : ∀ j, childrenD_660 j ⊆ envelope_660 := by decide +kernel +theorem pivot_mem_660 : (3, 5) ∈ envelope_660 := by decide +kernel +theorem children_work_660 : ∀ j, Template HasSnaky 10 (childrenC_660 j) (childrenD_660 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_137 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_332 6 (6, 8)).mono (by decide +kernel) + · exact row_works_660_i0.mono (by decide +kernel) +theorem row_works_660 : Template HasSnaky 11 required_660 envelope_660 := by + refine compose HasSnaky 10 childrenC_660 childrenD_660 children_work_660 (3, 5) + required_660 envelope_660 pivot_mem_660 child_required_sub_660 child_envelope_sub_660 ?_ + intro b hb + exact common_sub_660 (mem_commonEnvelope childrenD_660 b hb) +def required_663 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_663 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 2), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_663 : Fin 8 → Finset Cell := ![(placed21 4 (1, 7) required_134), (placed21 4 (1, 7) required_180), (placed21 4 (1, 8) required_435), (placed21 0 (1, 2) required_507), (placed21 4 (2, 7) required_558), (placed21 4 (1, 9) required_562), (placed21 0 (1, 3) required_580), required_662] +def childrenD_663 : Fin 8 → Finset Cell := ![(placed21 4 (1, 7) envelope_134), (placed21 4 (1, 7) envelope_180), (placed21 4 (1, 8) envelope_435), (placed21 0 (1, 2) envelope_507), (placed21 4 (2, 7) envelope_558), (placed21 4 (1, 9) envelope_562), (placed21 0 (1, 3) envelope_580), envelope_662] +theorem common_sub_663 : commonEnvelope childrenD_663 ⊆ insert (4, 5) required_663 := by decide +kernel +theorem child_required_sub_663 : ∀ j, childrenC_663 j ⊆ insert (4, 5) required_663 := by decide +kernel +theorem child_envelope_sub_663 : ∀ j, childrenD_663 j ⊆ envelope_663 := by decide +kernel +theorem pivot_mem_663 : (4, 5) ∈ envelope_663 := by decide +kernel +theorem children_work_663 : ∀ j, Template HasSnaky 10 (childrenC_663 j) (childrenD_663 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_134 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_180 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_435 4 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_507 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_558 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_562 4 (1, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_580 0 (1, 3)).mono (by decide +kernel) + · exact row_works_662.mono (by decide +kernel) +theorem row_works_663 : Template HasSnaky 11 required_663 envelope_663 := by + refine compose HasSnaky 10 childrenC_663 childrenD_663 children_work_663 (4, 5) + required_663 envelope_663 pivot_mem_663 child_required_sub_663 child_envelope_sub_663 ?_ + intro b hb + exact common_sub_663 (mem_commonEnvelope childrenD_663 b hb) +def required_664 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_664 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 5), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (10, 2), (10, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_664 : Fin 7 → Finset Cell := ![(placed21 4 (3, 7) required_134), (placed21 4 (3, 7) required_180), (placed21 2 (7, 2) required_309), (placed21 4 (3, 8) required_435), (placed21 4 (4, 7) required_558), (placed21 0 (3, 3) required_580), (placed21 0 (2, 0) required_662)] +def childrenD_664 : Fin 7 → Finset Cell := ![(placed21 4 (3, 7) envelope_134), (placed21 4 (3, 7) envelope_180), (placed21 2 (7, 2) envelope_309), (placed21 4 (3, 8) envelope_435), (placed21 4 (4, 7) envelope_558), (placed21 0 (3, 3) envelope_580), (placed21 0 (2, 0) envelope_662)] +theorem common_sub_664 : commonEnvelope childrenD_664 ⊆ insert (6, 5) required_664 := by decide +kernel +theorem child_required_sub_664 : ∀ j, childrenC_664 j ⊆ insert (6, 5) required_664 := by decide +kernel +theorem child_envelope_sub_664 : ∀ j, childrenD_664 j ⊆ envelope_664 := by decide +kernel +theorem pivot_mem_664 : (6, 5) ∈ envelope_664 := by decide +kernel +theorem children_work_664 : ∀ j, Template HasSnaky 10 (childrenC_664 j) (childrenD_664 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_134 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_180 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_309 2 (7, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_435 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_558 4 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_580 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_662 0 (2, 0)).mono (by decide +kernel) +theorem row_works_664 : Template HasSnaky 11 required_664 envelope_664 := by + refine compose HasSnaky 10 childrenC_664 childrenD_664 children_work_664 (6, 5) + required_664 envelope_664 pivot_mem_664 child_required_sub_664 child_envelope_sub_664 ?_ + intro b hb + exact common_sub_664 (mem_commonEnvelope childrenD_664 b hb) +def required_676_i0 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_676_i0 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_676_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 6) required_55), (placed21 0 (1, 2) required_380)] +def childrenD_676_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 6) envelope_55), (placed21 0 (1, 2) envelope_380)] +theorem common_sub_676_i0 : commonEnvelope childrenD_676_i0 ⊆ insert (2, 4) required_676_i0 := by decide +kernel +theorem child_required_sub_676_i0 : ∀ j, childrenC_676_i0 j ⊆ insert (2, 4) required_676_i0 := by decide +kernel +theorem child_envelope_sub_676_i0 : ∀ j, childrenD_676_i0 j ⊆ envelope_676_i0 := by decide +kernel +theorem pivot_mem_676_i0 : (2, 4) ∈ envelope_676_i0 := by decide +kernel +theorem children_work_676_i0 : ∀ j, Template HasSnaky 9 (childrenC_676_i0 j) (childrenD_676_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_55 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_380 0 (1, 2)).mono (by decide +kernel) +theorem row_works_676_i0 : Template HasSnaky 10 required_676_i0 envelope_676_i0 := by + refine compose HasSnaky 9 childrenC_676_i0 childrenD_676_i0 children_work_676_i0 (2, 4) + required_676_i0 envelope_676_i0 pivot_mem_676_i0 child_required_sub_676_i0 child_envelope_sub_676_i0 ?_ + intro b hb + exact common_sub_676_i0 (mem_commonEnvelope childrenD_676_i0 b hb) +def required_676 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_676 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_676 : Fin 4 → Finset Cell := ![(placed21 3 (0, 3) required_7), (placed21 0 (1, 2) required_8), (placed21 1 (0, 2) required_9), required_676_i0] +def childrenD_676 : Fin 4 → Finset Cell := ![(placed21 3 (0, 3) envelope_7), (placed21 0 (1, 2) envelope_8), (placed21 1 (0, 2) envelope_9), envelope_676_i0] +theorem common_sub_676 : commonEnvelope childrenD_676 ⊆ insert (4, 3) required_676 := by decide +kernel +theorem child_required_sub_676 : ∀ j, childrenC_676 j ⊆ insert (4, 3) required_676 := by decide +kernel +theorem child_envelope_sub_676 : ∀ j, childrenD_676 j ⊆ envelope_676 := by decide +kernel +theorem pivot_mem_676 : (4, 3) ∈ envelope_676 := by decide +kernel +theorem children_work_676 : ∀ j, Template HasSnaky 10 (childrenC_676 j) (childrenD_676 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_8 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (0, 2)).mono (by decide +kernel) + · exact row_works_676_i0.mono (by decide +kernel) +theorem row_works_676 : Template HasSnaky 11 required_676 envelope_676 := by + refine compose HasSnaky 10 childrenC_676 childrenD_676 children_work_676 (4, 3) + required_676 envelope_676 pivot_mem_676 child_required_sub_676 child_envelope_sub_676 ?_ + intro b hb + exact common_sub_676 (mem_commonEnvelope childrenD_676 b hb) +def required_685_i4 : Finset Cell := ⟨(([(2, 1), (3, 2), (3, 3), (3, 4), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_685_i4 : Finset Cell := ⟨(([(2, 0), (2, 1), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (5, 0), (5, 1), (5, 2), (6, 0), (6, 1), (6, 2), (7, 0), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_685_i4 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) required_5), (placed21 0 (2, 0) required_312)] +def childrenD_685_i4 : Fin 2 → Finset Cell := ![(placed21 7 (3, 4) envelope_5), (placed21 0 (2, 0) envelope_312)] +theorem common_sub_685_i4 : commonEnvelope childrenD_685_i4 ⊆ insert (3, 1) required_685_i4 := by decide +kernel +theorem child_required_sub_685_i4 : ∀ j, childrenC_685_i4 j ⊆ insert (3, 1) required_685_i4 := by decide +kernel +theorem child_envelope_sub_685_i4 : ∀ j, childrenD_685_i4 j ⊆ envelope_685_i4 := by decide +kernel +theorem pivot_mem_685_i4 : (3, 1) ∈ envelope_685_i4 := by decide +kernel +theorem children_work_685_i4 : ∀ j, Template HasSnaky 5 (childrenC_685_i4 j) (childrenD_685_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_312 0 (2, 0)).mono (by decide +kernel) +theorem row_works_685_i4 : Template HasSnaky 6 required_685_i4 envelope_685_i4 := by + refine compose HasSnaky 5 childrenC_685_i4 childrenD_685_i4 children_work_685_i4 (3, 1) + required_685_i4 envelope_685_i4 pivot_mem_685_i4 child_required_sub_685_i4 child_envelope_sub_685_i4 ?_ + intro b hb + exact common_sub_685_i4 (mem_commonEnvelope childrenD_685_i4 b hb) +def required_685_i3 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (3, 5), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_685_i3 : Finset Cell := ⟨(([(2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (5, 0), (5, 1), (5, 2), (6, 0), (6, 1), (6, 2), (7, 0), (7, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_685_i3 : Fin 2 → Finset Cell := ![(placed21 7 (3, 5) required_4), required_685_i4] +def childrenD_685_i3 : Fin 2 → Finset Cell := ![(placed21 7 (3, 5) envelope_4), envelope_685_i4] +theorem common_sub_685_i3 : commonEnvelope childrenD_685_i3 ⊆ insert (2, 1) required_685_i3 := by decide +kernel +theorem child_required_sub_685_i3 : ∀ j, childrenC_685_i3 j ⊆ insert (2, 1) required_685_i3 := by decide +kernel +theorem child_envelope_sub_685_i3 : ∀ j, childrenD_685_i3 j ⊆ envelope_685_i3 := by decide +kernel +theorem pivot_mem_685_i3 : (2, 1) ∈ envelope_685_i3 := by decide +kernel +theorem children_work_685_i3 : ∀ j, Template HasSnaky 6 (childrenC_685_i3 j) (childrenD_685_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (3, 5)).mono (by decide +kernel) + · exact row_works_685_i4.mono (by decide +kernel) +theorem row_works_685_i3 : Template HasSnaky 7 required_685_i3 envelope_685_i3 := by + refine compose HasSnaky 6 childrenC_685_i3 childrenD_685_i3 children_work_685_i3 (2, 1) + required_685_i3 envelope_685_i3 pivot_mem_685_i3 child_required_sub_685_i3 child_envelope_sub_685_i3 ?_ + intro b hb + exact common_sub_685_i3 (mem_commonEnvelope childrenD_685_i3 b hb) +def required_685_i2 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (3, 5), (4, 5), (5, 5), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_685_i2 : Finset Cell := ⟨(([(2, 0), (2, 1), (2, 2), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 5), (5, 0), (5, 1), (5, 2), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 0), (7, 2), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_685_i2 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) required_351), required_685_i3] +def childrenD_685_i2 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) envelope_351), envelope_685_i3] +theorem common_sub_685_i2 : commonEnvelope childrenD_685_i2 ⊆ insert (6, 2) required_685_i2 := by decide +kernel +theorem child_required_sub_685_i2 : ∀ j, childrenC_685_i2 j ⊆ insert (6, 2) required_685_i2 := by decide +kernel +theorem child_envelope_sub_685_i2 : ∀ j, childrenD_685_i2 j ⊆ envelope_685_i2 := by decide +kernel +theorem pivot_mem_685_i2 : (6, 2) ∈ envelope_685_i2 := by decide +kernel +theorem children_work_685_i2 : ∀ j, Template HasSnaky 7 (childrenC_685_i2 j) (childrenD_685_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_351 4 (3, 6)).mono (by decide +kernel) + · exact row_works_685_i3.mono (by decide +kernel) +theorem row_works_685_i2 : Template HasSnaky 8 required_685_i2 envelope_685_i2 := by + refine compose HasSnaky 7 childrenC_685_i2 childrenD_685_i2 children_work_685_i2 (6, 2) + required_685_i2 envelope_685_i2 pivot_mem_685_i2 child_required_sub_685_i2 child_envelope_sub_685_i2 ?_ + intro b hb + exact common_sub_685_i2 (mem_commonEnvelope childrenD_685_i2 b hb) +def required_685_i1 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (3, 5), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_685_i1 : Finset Cell := ⟨(([(2, 0), (2, 1), (2, 2), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 5), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 0), (7, 2), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_685_i1 : Fin 2 → Finset Cell := ![(placed21 1 (2, 2) required_96), required_685_i2] +def childrenD_685_i1 : Fin 2 → Finset Cell := ![(placed21 1 (2, 2) envelope_96), envelope_685_i2] +theorem common_sub_685_i1 : commonEnvelope childrenD_685_i1 ⊆ insert (6, 4) required_685_i1 := by decide +kernel +theorem child_required_sub_685_i1 : ∀ j, childrenC_685_i1 j ⊆ insert (6, 4) required_685_i1 := by decide +kernel +theorem child_envelope_sub_685_i1 : ∀ j, childrenD_685_i1 j ⊆ envelope_685_i1 := by decide +kernel +theorem pivot_mem_685_i1 : (6, 4) ∈ envelope_685_i1 := by decide +kernel +theorem children_work_685_i1 : ∀ j, Template HasSnaky 8 (childrenC_685_i1 j) (childrenD_685_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_96 1 (2, 2)).mono (by decide +kernel) + · exact row_works_685_i2.mono (by decide +kernel) +theorem row_works_685_i1 : Template HasSnaky 9 required_685_i1 envelope_685_i1 := by + refine compose HasSnaky 8 childrenC_685_i1 childrenD_685_i1 children_work_685_i1 (6, 4) + required_685_i1 envelope_685_i1 pivot_mem_685_i1 child_required_sub_685_i1 child_envelope_sub_685_i1 ?_ + intro b hb + exact common_sub_685_i1 (mem_commonEnvelope childrenD_685_i1 b hb) +def required_685_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_685_i0 : Finset Cell := ⟨(([(2, 0), (2, 1), (2, 2), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 0), (7, 2), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_685_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 2) required_5), required_685_i1] +def childrenD_685_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 2) envelope_5), envelope_685_i1] +theorem common_sub_685_i0 : commonEnvelope childrenD_685_i0 ⊆ insert (3, 2) required_685_i0 := by decide +kernel +theorem child_required_sub_685_i0 : ∀ j, childrenC_685_i0 j ⊆ insert (3, 2) required_685_i0 := by decide +kernel +theorem child_envelope_sub_685_i0 : ∀ j, childrenD_685_i0 j ⊆ envelope_685_i0 := by decide +kernel +theorem pivot_mem_685_i0 : (3, 2) ∈ envelope_685_i0 := by decide +kernel +theorem children_work_685_i0 : ∀ j, Template HasSnaky 9 (childrenC_685_i0 j) (childrenD_685_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 2)).mono (by decide +kernel) + · exact row_works_685_i1.mono (by decide +kernel) +theorem row_works_685_i0 : Template HasSnaky 10 required_685_i0 envelope_685_i0 := by + refine compose HasSnaky 9 childrenC_685_i0 childrenD_685_i0 children_work_685_i0 (3, 2) + required_685_i0 envelope_685_i0 pivot_mem_685_i0 child_required_sub_685_i0 child_envelope_sub_685_i0 ?_ + intro b hb + exact common_sub_685_i0 (mem_commonEnvelope childrenD_685_i0 b hb) +def required_685 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_685 : Finset Cell := ⟨(([(0, 6), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 2), (7, 4), (7, 5), (7, 6), (7, 7), (8, 4), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_685 : Fin 6 → Finset Cell := ![(placed21 3 (1, 6) required_67), (placed21 7 (7, 6) required_175), (placed21 0 (2, 2) required_228), (placed21 4 (2, 8) required_435), (placed21 0 (3, 2) required_531), required_685_i0] +def childrenD_685 : Fin 6 → Finset Cell := ![(placed21 3 (1, 6) envelope_67), (placed21 7 (7, 6) envelope_175), (placed21 0 (2, 2) envelope_228), (placed21 4 (2, 8) envelope_435), (placed21 0 (3, 2) envelope_531), envelope_685_i0] +theorem common_sub_685 : commonEnvelope childrenD_685 ⊆ insert (5, 5) required_685 := by decide +kernel +theorem child_required_sub_685 : ∀ j, childrenC_685 j ⊆ insert (5, 5) required_685 := by decide +kernel +theorem child_envelope_sub_685 : ∀ j, childrenD_685 j ⊆ envelope_685 := by decide +kernel +theorem pivot_mem_685 : (5, 5) ∈ envelope_685 := by decide +kernel +theorem children_work_685 : ∀ j, Template HasSnaky 10 (childrenC_685 j) (childrenD_685 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_67 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_175 7 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_228 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_435 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_531 0 (3, 2)).mono (by decide +kernel) + · exact row_works_685_i0.mono (by decide +kernel) +theorem row_works_685 : Template HasSnaky 11 required_685 envelope_685 := by + refine compose HasSnaky 10 childrenC_685 childrenD_685 children_work_685 (5, 5) + required_685 envelope_685 pivot_mem_685 child_required_sub_685 child_envelope_sub_685 ?_ + intro b hb + exact common_sub_685 (mem_commonEnvelope childrenD_685 b hb) +def height_639_i2 : ℕ := 4 +def childrenH_639_i2 : Fin 3 → ℕ := ![height_21, height_37, height_62] +theorem height_exact_639_i2 : height_639_i2 = 1 + Finset.univ.sup childrenH_639_i2 := by decide +kernel +theorem required_origin_639_i2 : ∀ x ∈ required_639_i2, + (∃ j, x ∈ childrenC_639_i2 j) ∨ ∀ j, x ∈ childrenD_639_i2 j := by decide +kernel +theorem required_exact_639_i2 : required_639_i2 = + ((Finset.univ.biUnion childrenC_639_i2) ∪ commonEnvelope childrenD_639_i2).erase (3, 6) := by + exact required_eq_combination childrenC_639_i2 childrenD_639_i2 (3, 6) required_639_i2 + (by decide +kernel) child_required_sub_639_i2 common_sub_639_i2 required_origin_639_i2 +theorem envelope_origin_639_i2 : ∀ x ∈ envelope_639_i2, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_639_i2 j := by decide +kernel +theorem envelope_exact_639_i2 : envelope_639_i2 = + insert (3, 6) (Finset.univ.biUnion childrenD_639_i2) := by + exact envelope_eq_combination childrenD_639_i2 (3, 6) envelope_639_i2 + pivot_mem_639_i2 child_envelope_sub_639_i2 envelope_origin_639_i2 +def checked_639_i2 : CheckedCard where + required := required_639_i2 + envelope := envelope_639_i2 + height := height_639_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_639_i2 +def height_639_i1 : ℕ := 6 +def childrenH_639_i1 : Fin 4 → ℕ := ![height_71, height_73, height_639_i2, height_451] +theorem height_exact_639_i1 : height_639_i1 = 1 + Finset.univ.sup childrenH_639_i1 := by decide +kernel +theorem required_origin_639_i1 : ∀ x ∈ required_639_i1, + (∃ j, x ∈ childrenC_639_i1 j) ∨ ∀ j, x ∈ childrenD_639_i1 j := by decide +kernel +theorem required_exact_639_i1 : required_639_i1 = + ((Finset.univ.biUnion childrenC_639_i1) ∪ commonEnvelope childrenD_639_i1).erase (3, 5) := by + exact required_eq_combination childrenC_639_i1 childrenD_639_i1 (3, 5) required_639_i1 + (by decide +kernel) child_required_sub_639_i1 common_sub_639_i1 required_origin_639_i1 +theorem envelope_origin_639_i1 : ∀ x ∈ envelope_639_i1, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_639_i1 j := by decide +kernel +theorem envelope_exact_639_i1 : envelope_639_i1 = + insert (3, 5) (Finset.univ.biUnion childrenD_639_i1) := by + exact envelope_eq_combination childrenD_639_i1 (3, 5) envelope_639_i1 + pivot_mem_639_i1 child_envelope_sub_639_i1 envelope_origin_639_i1 +def checked_639_i1 : CheckedCard where + required := required_639_i1 + envelope := envelope_639_i1 + height := height_639_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_639_i1 +def height_639_i3 : ℕ := 7 +def childrenH_639_i3 : Fin 4 → ℕ := ![height_71, height_73, height_435, height_451] +theorem height_exact_639_i3 : height_639_i3 = 1 + Finset.univ.sup childrenH_639_i3 := by decide +kernel +theorem required_origin_639_i3 : ∀ x ∈ required_639_i3, + (∃ j, x ∈ childrenC_639_i3 j) ∨ ∀ j, x ∈ childrenD_639_i3 j := by decide +kernel +theorem required_exact_639_i3 : required_639_i3 = + ((Finset.univ.biUnion childrenC_639_i3) ∪ commonEnvelope childrenD_639_i3).erase (3, 5) := by + exact required_eq_combination childrenC_639_i3 childrenD_639_i3 (3, 5) required_639_i3 + (by decide +kernel) child_required_sub_639_i3 common_sub_639_i3 required_origin_639_i3 +theorem envelope_origin_639_i3 : ∀ x ∈ envelope_639_i3, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_639_i3 j := by decide +kernel +theorem envelope_exact_639_i3 : envelope_639_i3 = + insert (3, 5) (Finset.univ.biUnion childrenD_639_i3) := by + exact envelope_eq_combination childrenD_639_i3 (3, 5) envelope_639_i3 + pivot_mem_639_i3 child_envelope_sub_639_i3 envelope_origin_639_i3 +def checked_639_i3 : CheckedCard where + required := required_639_i3 + envelope := envelope_639_i3 + height := height_639_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_639_i3 +def height_639_i0 : ℕ := 10 +def childrenH_639_i0 : Fin 4 → ℕ := ![height_54, height_638, height_639_i1, height_639_i3] +theorem height_exact_639_i0 : height_639_i0 = 1 + Finset.univ.sup childrenH_639_i0 := by decide +kernel +theorem required_origin_639_i0 : ∀ x ∈ required_639_i0, + (∃ j, x ∈ childrenC_639_i0 j) ∨ ∀ j, x ∈ childrenD_639_i0 j := by decide +kernel +theorem required_exact_639_i0 : required_639_i0 = + ((Finset.univ.biUnion childrenC_639_i0) ∪ commonEnvelope childrenD_639_i0).erase (3, 3) := by + exact required_eq_combination childrenC_639_i0 childrenD_639_i0 (3, 3) required_639_i0 + (by decide +kernel) child_required_sub_639_i0 common_sub_639_i0 required_origin_639_i0 +theorem envelope_origin_639_i0 : ∀ x ∈ envelope_639_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_639_i0 j := by decide +kernel +theorem envelope_exact_639_i0 : envelope_639_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_639_i0) := by + exact envelope_eq_combination childrenD_639_i0 (3, 3) envelope_639_i0 + pivot_mem_639_i0 child_envelope_sub_639_i0 envelope_origin_639_i0 +def checked_639_i0 : CheckedCard where + required := required_639_i0 + envelope := envelope_639_i0 + height := height_639_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_639_i0 +def height_639 : ℕ := 11 +def childrenH_639 : Fin 5 → ℕ := ![height_50, height_125, height_478, height_482, height_639_i0] +theorem height_exact_639 : height_639 = 1 + Finset.univ.sup childrenH_639 := by decide +kernel +theorem required_origin_639 : ∀ x ∈ required_639, + (∃ j, x ∈ childrenC_639 j) ∨ ∀ j, x ∈ childrenD_639 j := by decide +kernel +theorem required_exact_639 : required_639 = + ((Finset.univ.biUnion childrenC_639) ∪ commonEnvelope childrenD_639).erase (3, 4) := by + exact required_eq_combination childrenC_639 childrenD_639 (3, 4) required_639 + (by decide +kernel) child_required_sub_639 common_sub_639 required_origin_639 +theorem envelope_origin_639 : ∀ x ∈ envelope_639, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_639 j := by decide +kernel +theorem envelope_exact_639 : envelope_639 = + insert (3, 4) (Finset.univ.biUnion childrenD_639) := by + exact envelope_eq_combination childrenD_639 (3, 4) envelope_639 + pivot_mem_639 child_envelope_sub_639 envelope_origin_639 +def checked_639 : CheckedCard where + required := required_639 + envelope := envelope_639 + height := height_639 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_639 +def height_646_i0 : ℕ := 6 +def childrenH_646_i0 : Fin 3 → ℕ := ![height_15, height_72, height_262] +theorem height_exact_646_i0 : height_646_i0 = 1 + Finset.univ.sup childrenH_646_i0 := by decide +kernel +theorem required_origin_646_i0 : ∀ x ∈ required_646_i0, + (∃ j, x ∈ childrenC_646_i0 j) ∨ ∀ j, x ∈ childrenD_646_i0 j := by decide +kernel +theorem required_exact_646_i0 : required_646_i0 = + ((Finset.univ.biUnion childrenC_646_i0) ∪ commonEnvelope childrenD_646_i0).erase (4, 2) := by + exact required_eq_combination childrenC_646_i0 childrenD_646_i0 (4, 2) required_646_i0 + (by decide +kernel) child_required_sub_646_i0 common_sub_646_i0 required_origin_646_i0 +theorem envelope_origin_646_i0 : ∀ x ∈ envelope_646_i0, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_646_i0 j := by decide +kernel +theorem envelope_exact_646_i0 : envelope_646_i0 = + insert (4, 2) (Finset.univ.biUnion childrenD_646_i0) := by + exact envelope_eq_combination childrenD_646_i0 (4, 2) envelope_646_i0 + pivot_mem_646_i0 child_envelope_sub_646_i0 envelope_origin_646_i0 +def checked_646_i0 : CheckedCard where + required := required_646_i0 + envelope := envelope_646_i0 + height := height_646_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_646_i0 +def height_646 : ℕ := 11 +def childrenH_646 : Fin 6 → ℕ := ![height_361, height_361, height_411, height_600, height_621, height_646_i0] +theorem height_exact_646 : height_646 = 1 + Finset.univ.sup childrenH_646 := by decide +kernel +theorem required_origin_646 : ∀ x ∈ required_646, + (∃ j, x ∈ childrenC_646 j) ∨ ∀ j, x ∈ childrenD_646 j := by decide +kernel +theorem required_exact_646 : required_646 = + ((Finset.univ.biUnion childrenC_646) ∪ commonEnvelope childrenD_646).erase (4, 4) := by + exact required_eq_combination childrenC_646 childrenD_646 (4, 4) required_646 + (by decide +kernel) child_required_sub_646 common_sub_646 required_origin_646 +theorem envelope_origin_646 : ∀ x ∈ envelope_646, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_646 j := by decide +kernel +theorem envelope_exact_646 : envelope_646 = + insert (4, 4) (Finset.univ.biUnion childrenD_646) := by + exact envelope_eq_combination childrenD_646 (4, 4) envelope_646 + pivot_mem_646 child_envelope_sub_646 envelope_origin_646 +def checked_646 : CheckedCard where + required := required_646 + envelope := envelope_646 + height := height_646 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_646 +def height_653_i0 : ℕ := 9 +def childrenH_653_i0 : Fin 3 → ℕ := ![height_206, height_301, height_405] +theorem height_exact_653_i0 : height_653_i0 = 1 + Finset.univ.sup childrenH_653_i0 := by decide +kernel +theorem required_origin_653_i0 : ∀ x ∈ required_653_i0, + (∃ j, x ∈ childrenC_653_i0 j) ∨ ∀ j, x ∈ childrenD_653_i0 j := by decide +kernel +theorem required_exact_653_i0 : required_653_i0 = + ((Finset.univ.biUnion childrenC_653_i0) ∪ commonEnvelope childrenD_653_i0).erase (4, 4) := by + exact required_eq_combination childrenC_653_i0 childrenD_653_i0 (4, 4) required_653_i0 + (by decide +kernel) child_required_sub_653_i0 common_sub_653_i0 required_origin_653_i0 +theorem envelope_origin_653_i0 : ∀ x ∈ envelope_653_i0, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_653_i0 j := by decide +kernel +theorem envelope_exact_653_i0 : envelope_653_i0 = + insert (4, 4) (Finset.univ.biUnion childrenD_653_i0) := by + exact envelope_eq_combination childrenD_653_i0 (4, 4) envelope_653_i0 + pivot_mem_653_i0 child_envelope_sub_653_i0 envelope_origin_653_i0 +def checked_653_i0 : CheckedCard where + required := required_653_i0 + envelope := envelope_653_i0 + height := height_653_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_653_i0 +def height_653 : ℕ := 11 +def childrenH_653 : Fin 4 → ℕ := ![height_53, height_53, height_652, height_653_i0] +theorem height_exact_653 : height_653 = 1 + Finset.univ.sup childrenH_653 := by decide +kernel +theorem required_origin_653 : ∀ x ∈ required_653, + (∃ j, x ∈ childrenC_653 j) ∨ ∀ j, x ∈ childrenD_653 j := by decide +kernel +theorem required_exact_653 : required_653 = + ((Finset.univ.biUnion childrenC_653) ∪ commonEnvelope childrenD_653).erase (2, 4) := by + exact required_eq_combination childrenC_653 childrenD_653 (2, 4) required_653 + (by decide +kernel) child_required_sub_653 common_sub_653 required_origin_653 +theorem envelope_origin_653 : ∀ x ∈ envelope_653, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_653 j := by decide +kernel +theorem envelope_exact_653 : envelope_653 = + insert (2, 4) (Finset.univ.biUnion childrenD_653) := by + exact envelope_eq_combination childrenD_653 (2, 4) envelope_653 + pivot_mem_653 child_envelope_sub_653 envelope_origin_653 +def checked_653 : CheckedCard where + required := required_653 + envelope := envelope_653 + height := height_653 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_653 +def height_660_i1 : ℕ := 5 +def childrenH_660_i1 : Fin 2 → ℕ := ![height_6, height_18] +theorem height_exact_660_i1 : height_660_i1 = 1 + Finset.univ.sup childrenH_660_i1 := by decide +kernel +theorem required_origin_660_i1 : ∀ x ∈ required_660_i1, + (∃ j, x ∈ childrenC_660_i1 j) ∨ ∀ j, x ∈ childrenD_660_i1 j := by decide +kernel +theorem required_exact_660_i1 : required_660_i1 = + ((Finset.univ.biUnion childrenC_660_i1) ∪ commonEnvelope childrenD_660_i1).erase (7, 5) := by + exact required_eq_combination childrenC_660_i1 childrenD_660_i1 (7, 5) required_660_i1 + (by decide +kernel) child_required_sub_660_i1 common_sub_660_i1 required_origin_660_i1 +theorem envelope_origin_660_i1 : ∀ x ∈ envelope_660_i1, + x = (7, 5) ∨ ∃ j, x ∈ childrenD_660_i1 j := by decide +kernel +theorem envelope_exact_660_i1 : envelope_660_i1 = + insert (7, 5) (Finset.univ.biUnion childrenD_660_i1) := by + exact envelope_eq_combination childrenD_660_i1 (7, 5) envelope_660_i1 + pivot_mem_660_i1 child_envelope_sub_660_i1 envelope_origin_660_i1 +def checked_660_i1 : CheckedCard where + required := required_660_i1 + envelope := envelope_660_i1 + height := height_660_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_660_i1 +def height_660_i2 : ℕ := 6 +def childrenH_660_i2 : Fin 2 → ℕ := ![height_6, height_252] +theorem height_exact_660_i2 : height_660_i2 = 1 + Finset.univ.sup childrenH_660_i2 := by decide +kernel +theorem required_origin_660_i2 : ∀ x ∈ required_660_i2, + (∃ j, x ∈ childrenC_660_i2 j) ∨ ∀ j, x ∈ childrenD_660_i2 j := by decide +kernel +theorem required_exact_660_i2 : required_660_i2 = + ((Finset.univ.biUnion childrenC_660_i2) ∪ commonEnvelope childrenD_660_i2).erase (7, 5) := by + exact required_eq_combination childrenC_660_i2 childrenD_660_i2 (7, 5) required_660_i2 + (by decide +kernel) child_required_sub_660_i2 common_sub_660_i2 required_origin_660_i2 +theorem envelope_origin_660_i2 : ∀ x ∈ envelope_660_i2, + x = (7, 5) ∨ ∃ j, x ∈ childrenD_660_i2 j := by decide +kernel +theorem envelope_exact_660_i2 : envelope_660_i2 = + insert (7, 5) (Finset.univ.biUnion childrenD_660_i2) := by + exact envelope_eq_combination childrenD_660_i2 (7, 5) envelope_660_i2 + pivot_mem_660_i2 child_envelope_sub_660_i2 envelope_origin_660_i2 +def checked_660_i2 : CheckedCard where + required := required_660_i2 + envelope := envelope_660_i2 + height := height_660_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_660_i2 +def height_660_i0 : ℕ := 10 +def childrenH_660_i0 : Fin 4 → ℕ := ![height_9, height_660_i1, height_659, height_660_i2] +theorem height_exact_660_i0 : height_660_i0 = 1 + Finset.univ.sup childrenH_660_i0 := by decide +kernel +theorem required_origin_660_i0 : ∀ x ∈ required_660_i0, + (∃ j, x ∈ childrenC_660_i0 j) ∨ ∀ j, x ∈ childrenD_660_i0 j := by decide +kernel +theorem required_exact_660_i0 : required_660_i0 = + ((Finset.univ.biUnion childrenC_660_i0) ∪ commonEnvelope childrenD_660_i0).erase (6, 5) := by + exact required_eq_combination childrenC_660_i0 childrenD_660_i0 (6, 5) required_660_i0 + (by decide +kernel) child_required_sub_660_i0 common_sub_660_i0 required_origin_660_i0 +theorem envelope_origin_660_i0 : ∀ x ∈ envelope_660_i0, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_660_i0 j := by decide +kernel +theorem envelope_exact_660_i0 : envelope_660_i0 = + insert (6, 5) (Finset.univ.biUnion childrenD_660_i0) := by + exact envelope_eq_combination childrenD_660_i0 (6, 5) envelope_660_i0 + pivot_mem_660_i0 child_envelope_sub_660_i0 envelope_origin_660_i0 +def checked_660_i0 : CheckedCard where + required := required_660_i0 + envelope := envelope_660_i0 + height := height_660_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_660_i0 +def height_660 : ℕ := 11 +def childrenH_660 : Fin 4 → ℕ := ![height_13, height_137, height_332, height_660_i0] +theorem height_exact_660 : height_660 = 1 + Finset.univ.sup childrenH_660 := by decide +kernel +theorem required_origin_660 : ∀ x ∈ required_660, + (∃ j, x ∈ childrenC_660 j) ∨ ∀ j, x ∈ childrenD_660 j := by decide +kernel +theorem required_exact_660 : required_660 = + ((Finset.univ.biUnion childrenC_660) ∪ commonEnvelope childrenD_660).erase (3, 5) := by + exact required_eq_combination childrenC_660 childrenD_660 (3, 5) required_660 + (by decide +kernel) child_required_sub_660 common_sub_660 required_origin_660 +theorem envelope_origin_660 : ∀ x ∈ envelope_660, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_660 j := by decide +kernel +theorem envelope_exact_660 : envelope_660 = + insert (3, 5) (Finset.univ.biUnion childrenD_660) := by + exact envelope_eq_combination childrenD_660 (3, 5) envelope_660 + pivot_mem_660 child_envelope_sub_660 envelope_origin_660 +def checked_660 : CheckedCard where + required := required_660 + envelope := envelope_660 + height := height_660 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_660 +def height_663 : ℕ := 11 +def childrenH_663 : Fin 8 → ℕ := ![height_134, height_180, height_435, height_507, height_558, height_562, height_580, height_662] +theorem height_exact_663 : height_663 = 1 + Finset.univ.sup childrenH_663 := by decide +kernel +theorem required_origin_663 : ∀ x ∈ required_663, + (∃ j, x ∈ childrenC_663 j) ∨ ∀ j, x ∈ childrenD_663 j := by decide +kernel +theorem required_exact_663 : required_663 = + ((Finset.univ.biUnion childrenC_663) ∪ commonEnvelope childrenD_663).erase (4, 5) := by + exact required_eq_combination childrenC_663 childrenD_663 (4, 5) required_663 + (by decide +kernel) child_required_sub_663 common_sub_663 required_origin_663 +theorem envelope_origin_663 : ∀ x ∈ envelope_663, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_663 j := by decide +kernel +theorem envelope_exact_663 : envelope_663 = + insert (4, 5) (Finset.univ.biUnion childrenD_663) := by + exact envelope_eq_combination childrenD_663 (4, 5) envelope_663 + pivot_mem_663 child_envelope_sub_663 envelope_origin_663 +def checked_663 : CheckedCard where + required := required_663 + envelope := envelope_663 + height := height_663 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_663 +def height_664 : ℕ := 11 +def childrenH_664 : Fin 7 → ℕ := ![height_134, height_180, height_309, height_435, height_558, height_580, height_662] +theorem height_exact_664 : height_664 = 1 + Finset.univ.sup childrenH_664 := by decide +kernel +theorem required_origin_664 : ∀ x ∈ required_664, + (∃ j, x ∈ childrenC_664 j) ∨ ∀ j, x ∈ childrenD_664 j := by decide +kernel +theorem required_exact_664 : required_664 = + ((Finset.univ.biUnion childrenC_664) ∪ commonEnvelope childrenD_664).erase (6, 5) := by + exact required_eq_combination childrenC_664 childrenD_664 (6, 5) required_664 + (by decide +kernel) child_required_sub_664 common_sub_664 required_origin_664 +theorem envelope_origin_664 : ∀ x ∈ envelope_664, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_664 j := by decide +kernel +theorem envelope_exact_664 : envelope_664 = + insert (6, 5) (Finset.univ.biUnion childrenD_664) := by + exact envelope_eq_combination childrenD_664 (6, 5) envelope_664 + pivot_mem_664 child_envelope_sub_664 envelope_origin_664 +def checked_664 : CheckedCard where + required := required_664 + envelope := envelope_664 + height := height_664 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_664 +def height_676_i0 : ℕ := 10 +def childrenH_676_i0 : Fin 2 → ℕ := ![height_55, height_380] +theorem height_exact_676_i0 : height_676_i0 = 1 + Finset.univ.sup childrenH_676_i0 := by decide +kernel +theorem required_origin_676_i0 : ∀ x ∈ required_676_i0, + (∃ j, x ∈ childrenC_676_i0 j) ∨ ∀ j, x ∈ childrenD_676_i0 j := by decide +kernel +theorem required_exact_676_i0 : required_676_i0 = + ((Finset.univ.biUnion childrenC_676_i0) ∪ commonEnvelope childrenD_676_i0).erase (2, 4) := by + exact required_eq_combination childrenC_676_i0 childrenD_676_i0 (2, 4) required_676_i0 + (by decide +kernel) child_required_sub_676_i0 common_sub_676_i0 required_origin_676_i0 +theorem envelope_origin_676_i0 : ∀ x ∈ envelope_676_i0, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_676_i0 j := by decide +kernel +theorem envelope_exact_676_i0 : envelope_676_i0 = + insert (2, 4) (Finset.univ.biUnion childrenD_676_i0) := by + exact envelope_eq_combination childrenD_676_i0 (2, 4) envelope_676_i0 + pivot_mem_676_i0 child_envelope_sub_676_i0 envelope_origin_676_i0 +def checked_676_i0 : CheckedCard where + required := required_676_i0 + envelope := envelope_676_i0 + height := height_676_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_676_i0 +def height_676 : ℕ := 11 +def childrenH_676 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_676_i0] +theorem height_exact_676 : height_676 = 1 + Finset.univ.sup childrenH_676 := by decide +kernel +theorem required_origin_676 : ∀ x ∈ required_676, + (∃ j, x ∈ childrenC_676 j) ∨ ∀ j, x ∈ childrenD_676 j := by decide +kernel +theorem required_exact_676 : required_676 = + ((Finset.univ.biUnion childrenC_676) ∪ commonEnvelope childrenD_676).erase (4, 3) := by + exact required_eq_combination childrenC_676 childrenD_676 (4, 3) required_676 + (by decide +kernel) child_required_sub_676 common_sub_676 required_origin_676 +theorem envelope_origin_676 : ∀ x ∈ envelope_676, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_676 j := by decide +kernel +theorem envelope_exact_676 : envelope_676 = + insert (4, 3) (Finset.univ.biUnion childrenD_676) := by + exact envelope_eq_combination childrenD_676 (4, 3) envelope_676 + pivot_mem_676 child_envelope_sub_676 envelope_origin_676 +def checked_676 : CheckedCard where + required := required_676 + envelope := envelope_676 + height := height_676 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_676 +def height_685_i4 : ℕ := 6 +def childrenH_685_i4 : Fin 2 → ℕ := ![height_5, height_312] +theorem height_exact_685_i4 : height_685_i4 = 1 + Finset.univ.sup childrenH_685_i4 := by decide +kernel +theorem required_origin_685_i4 : ∀ x ∈ required_685_i4, + (∃ j, x ∈ childrenC_685_i4 j) ∨ ∀ j, x ∈ childrenD_685_i4 j := by decide +kernel +theorem required_exact_685_i4 : required_685_i4 = + ((Finset.univ.biUnion childrenC_685_i4) ∪ commonEnvelope childrenD_685_i4).erase (3, 1) := by + exact required_eq_combination childrenC_685_i4 childrenD_685_i4 (3, 1) required_685_i4 + (by decide +kernel) child_required_sub_685_i4 common_sub_685_i4 required_origin_685_i4 +theorem envelope_origin_685_i4 : ∀ x ∈ envelope_685_i4, + x = (3, 1) ∨ ∃ j, x ∈ childrenD_685_i4 j := by decide +kernel +theorem envelope_exact_685_i4 : envelope_685_i4 = + insert (3, 1) (Finset.univ.biUnion childrenD_685_i4) := by + exact envelope_eq_combination childrenD_685_i4 (3, 1) envelope_685_i4 + pivot_mem_685_i4 child_envelope_sub_685_i4 envelope_origin_685_i4 +def checked_685_i4 : CheckedCard where + required := required_685_i4 + envelope := envelope_685_i4 + height := height_685_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_685_i4 +def height_685_i3 : ℕ := 7 +def childrenH_685_i3 : Fin 2 → ℕ := ![height_4, height_685_i4] +theorem height_exact_685_i3 : height_685_i3 = 1 + Finset.univ.sup childrenH_685_i3 := by decide +kernel +theorem required_origin_685_i3 : ∀ x ∈ required_685_i3, + (∃ j, x ∈ childrenC_685_i3 j) ∨ ∀ j, x ∈ childrenD_685_i3 j := by decide +kernel +theorem required_exact_685_i3 : required_685_i3 = + ((Finset.univ.biUnion childrenC_685_i3) ∪ commonEnvelope childrenD_685_i3).erase (2, 1) := by + exact required_eq_combination childrenC_685_i3 childrenD_685_i3 (2, 1) required_685_i3 + (by decide +kernel) child_required_sub_685_i3 common_sub_685_i3 required_origin_685_i3 +theorem envelope_origin_685_i3 : ∀ x ∈ envelope_685_i3, + x = (2, 1) ∨ ∃ j, x ∈ childrenD_685_i3 j := by decide +kernel +theorem envelope_exact_685_i3 : envelope_685_i3 = + insert (2, 1) (Finset.univ.biUnion childrenD_685_i3) := by + exact envelope_eq_combination childrenD_685_i3 (2, 1) envelope_685_i3 + pivot_mem_685_i3 child_envelope_sub_685_i3 envelope_origin_685_i3 +def checked_685_i3 : CheckedCard where + required := required_685_i3 + envelope := envelope_685_i3 + height := height_685_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_685_i3 +def height_685_i2 : ℕ := 8 +def childrenH_685_i2 : Fin 2 → ℕ := ![height_351, height_685_i3] +theorem height_exact_685_i2 : height_685_i2 = 1 + Finset.univ.sup childrenH_685_i2 := by decide +kernel +theorem required_origin_685_i2 : ∀ x ∈ required_685_i2, + (∃ j, x ∈ childrenC_685_i2 j) ∨ ∀ j, x ∈ childrenD_685_i2 j := by decide +kernel +theorem required_exact_685_i2 : required_685_i2 = + ((Finset.univ.biUnion childrenC_685_i2) ∪ commonEnvelope childrenD_685_i2).erase (6, 2) := by + exact required_eq_combination childrenC_685_i2 childrenD_685_i2 (6, 2) required_685_i2 + (by decide +kernel) child_required_sub_685_i2 common_sub_685_i2 required_origin_685_i2 +theorem envelope_origin_685_i2 : ∀ x ∈ envelope_685_i2, + x = (6, 2) ∨ ∃ j, x ∈ childrenD_685_i2 j := by decide +kernel +theorem envelope_exact_685_i2 : envelope_685_i2 = + insert (6, 2) (Finset.univ.biUnion childrenD_685_i2) := by + exact envelope_eq_combination childrenD_685_i2 (6, 2) envelope_685_i2 + pivot_mem_685_i2 child_envelope_sub_685_i2 envelope_origin_685_i2 +def checked_685_i2 : CheckedCard where + required := required_685_i2 + envelope := envelope_685_i2 + height := height_685_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_685_i2 +def height_685_i1 : ℕ := 9 +def childrenH_685_i1 : Fin 2 → ℕ := ![height_96, height_685_i2] +theorem height_exact_685_i1 : height_685_i1 = 1 + Finset.univ.sup childrenH_685_i1 := by decide +kernel +theorem required_origin_685_i1 : ∀ x ∈ required_685_i1, + (∃ j, x ∈ childrenC_685_i1 j) ∨ ∀ j, x ∈ childrenD_685_i1 j := by decide +kernel +theorem required_exact_685_i1 : required_685_i1 = + ((Finset.univ.biUnion childrenC_685_i1) ∪ commonEnvelope childrenD_685_i1).erase (6, 4) := by + exact required_eq_combination childrenC_685_i1 childrenD_685_i1 (6, 4) required_685_i1 + (by decide +kernel) child_required_sub_685_i1 common_sub_685_i1 required_origin_685_i1 +theorem envelope_origin_685_i1 : ∀ x ∈ envelope_685_i1, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_685_i1 j := by decide +kernel +theorem envelope_exact_685_i1 : envelope_685_i1 = + insert (6, 4) (Finset.univ.biUnion childrenD_685_i1) := by + exact envelope_eq_combination childrenD_685_i1 (6, 4) envelope_685_i1 + pivot_mem_685_i1 child_envelope_sub_685_i1 envelope_origin_685_i1 +def checked_685_i1 : CheckedCard where + required := required_685_i1 + envelope := envelope_685_i1 + height := height_685_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_685_i1 +def height_685_i0 : ℕ := 10 +def childrenH_685_i0 : Fin 2 → ℕ := ![height_5, height_685_i1] +theorem height_exact_685_i0 : height_685_i0 = 1 + Finset.univ.sup childrenH_685_i0 := by decide +kernel +theorem required_origin_685_i0 : ∀ x ∈ required_685_i0, + (∃ j, x ∈ childrenC_685_i0 j) ∨ ∀ j, x ∈ childrenD_685_i0 j := by decide +kernel +theorem required_exact_685_i0 : required_685_i0 = + ((Finset.univ.biUnion childrenC_685_i0) ∪ commonEnvelope childrenD_685_i0).erase (3, 2) := by + exact required_eq_combination childrenC_685_i0 childrenD_685_i0 (3, 2) required_685_i0 + (by decide +kernel) child_required_sub_685_i0 common_sub_685_i0 required_origin_685_i0 +theorem envelope_origin_685_i0 : ∀ x ∈ envelope_685_i0, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_685_i0 j := by decide +kernel +theorem envelope_exact_685_i0 : envelope_685_i0 = + insert (3, 2) (Finset.univ.biUnion childrenD_685_i0) := by + exact envelope_eq_combination childrenD_685_i0 (3, 2) envelope_685_i0 + pivot_mem_685_i0 child_envelope_sub_685_i0 envelope_origin_685_i0 +def checked_685_i0 : CheckedCard where + required := required_685_i0 + envelope := envelope_685_i0 + height := height_685_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_685_i0 +def height_685 : ℕ := 11 +def childrenH_685 : Fin 6 → ℕ := ![height_67, height_175, height_228, height_435, height_531, height_685_i0] +theorem height_exact_685 : height_685 = 1 + Finset.univ.sup childrenH_685 := by decide +kernel +theorem required_origin_685 : ∀ x ∈ required_685, + (∃ j, x ∈ childrenC_685 j) ∨ ∀ j, x ∈ childrenD_685 j := by decide +kernel +theorem required_exact_685 : required_685 = + ((Finset.univ.biUnion childrenC_685) ∪ commonEnvelope childrenD_685).erase (5, 5) := by + exact required_eq_combination childrenC_685 childrenD_685 (5, 5) required_685 + (by decide +kernel) child_required_sub_685 common_sub_685 required_origin_685 +theorem envelope_origin_685 : ∀ x ∈ envelope_685, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_685 j := by decide +kernel +theorem envelope_exact_685 : envelope_685 = + insert (5, 5) (Finset.univ.biUnion childrenD_685) := by + exact envelope_eq_combination childrenD_685 (5, 5) envelope_685 + pivot_mem_685 child_envelope_sub_685 envelope_origin_685 +def checked_685 : CheckedCard where + required := required_685 + envelope := envelope_685 + height := height_685 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_685 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part06.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part06.lean new file mode 100644 index 0000000..3722477 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part06.lean @@ -0,0 +1,661 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part08 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_689_i0 : Finset Cell := ⟨(([(2, 4), (3, 4), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_689_i0 : Finset Cell := ⟨(([(0, 5), (0, 7), (0, 8), (0, 9), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 4), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_689_i0 : Fin 6 → Finset Cell := ![(placed21 2 (5, 2) required_67), (placed21 6 (5, 8) required_175), (placed21 1 (1, 3) required_228), (placed21 5 (5, 3) required_373), (placed21 5 (7, 3) required_435), (placed21 1 (0, 4) required_688)] +def childrenD_689_i0 : Fin 6 → Finset Cell := ![(placed21 2 (5, 2) envelope_67), (placed21 6 (5, 8) envelope_175), (placed21 1 (1, 3) envelope_228), (placed21 5 (5, 3) envelope_373), (placed21 5 (7, 3) envelope_435), (placed21 1 (0, 4) envelope_688)] +theorem common_sub_689_i0 : commonEnvelope childrenD_689_i0 ⊆ insert (4, 6) required_689_i0 := by decide +kernel +theorem child_required_sub_689_i0 : ∀ j, childrenC_689_i0 j ⊆ insert (4, 6) required_689_i0 := by decide +kernel +theorem child_envelope_sub_689_i0 : ∀ j, childrenD_689_i0 j ⊆ envelope_689_i0 := by decide +kernel +theorem pivot_mem_689_i0 : (4, 6) ∈ envelope_689_i0 := by decide +kernel +theorem children_work_689_i0 : ∀ j, Template HasSnaky 9 (childrenC_689_i0 j) (childrenD_689_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_67 2 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_175 6 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_228 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_373 5 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_688 1 (0, 4)).mono (by decide +kernel) +theorem row_works_689_i0 : Template HasSnaky 10 required_689_i0 envelope_689_i0 := by + refine compose HasSnaky 9 childrenC_689_i0 childrenD_689_i0 children_work_689_i0 (4, 6) + required_689_i0 envelope_689_i0 pivot_mem_689_i0 child_required_sub_689_i0 child_envelope_sub_689_i0 ?_ + intro b hb + exact common_sub_689_i0 (mem_commonEnvelope childrenD_689_i0 b hb) +def required_689 : Finset Cell := ⟨(([(2, 4), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_689 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 0), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_689 : Fin 4 → Finset Cell := ![(placed21 1 (1, 4) required_44), (placed21 2 (5, 0) required_324), (placed21 0 (0, 1) required_686), required_689_i0] +def childrenD_689 : Fin 4 → Finset Cell := ![(placed21 1 (1, 4) envelope_44), (placed21 2 (5, 0) envelope_324), (placed21 0 (0, 1) envelope_686), envelope_689_i0] +theorem common_sub_689 : commonEnvelope childrenD_689 ⊆ insert (4, 5) required_689 := by decide +kernel +theorem child_required_sub_689 : ∀ j, childrenC_689 j ⊆ insert (4, 5) required_689 := by decide +kernel +theorem child_envelope_sub_689 : ∀ j, childrenD_689 j ⊆ envelope_689 := by decide +kernel +theorem pivot_mem_689 : (4, 5) ∈ envelope_689 := by decide +kernel +theorem children_work_689 : ∀ j, Template HasSnaky 10 (childrenC_689 j) (childrenD_689 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_324 2 (5, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_686 0 (0, 1)).mono (by decide +kernel) + · exact row_works_689_i0.mono (by decide +kernel) +theorem row_works_689 : Template HasSnaky 11 required_689 envelope_689 := by + refine compose HasSnaky 10 childrenC_689 childrenD_689 children_work_689 (4, 5) + required_689 envelope_689 pivot_mem_689 child_required_sub_689 child_envelope_sub_689 ?_ + intro b hb + exact common_sub_689 (mem_commonEnvelope childrenD_689 b hb) +def required_700_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_700_i0 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7), (2, 8), (3, 5), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (6, 4), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_700_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 4) required_39), (placed21 0 (1, 2) required_52)] +def childrenD_700_i0 : Fin 2 → Finset Cell := ![(placed21 1 (0, 4) envelope_39), (placed21 0 (1, 2) envelope_52)] +theorem common_sub_700_i0 : commonEnvelope childrenD_700_i0 ⊆ insert (2, 5) required_700_i0 := by decide +kernel +theorem child_required_sub_700_i0 : ∀ j, childrenC_700_i0 j ⊆ insert (2, 5) required_700_i0 := by decide +kernel +theorem child_envelope_sub_700_i0 : ∀ j, childrenD_700_i0 j ⊆ envelope_700_i0 := by decide +kernel +theorem pivot_mem_700_i0 : (2, 5) ∈ envelope_700_i0 := by decide +kernel +theorem children_work_700_i0 : ∀ j, Template HasSnaky 4 (childrenC_700_i0 j) (childrenD_700_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_39 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (1, 2)).mono (by decide +kernel) +theorem row_works_700_i0 : Template HasSnaky 5 required_700_i0 envelope_700_i0 := by + refine compose HasSnaky 4 childrenC_700_i0 childrenD_700_i0 children_work_700_i0 (2, 5) + required_700_i0 envelope_700_i0 pivot_mem_700_i0 child_required_sub_700_i0 child_envelope_sub_700_i0 ?_ + intro b hb + exact common_sub_700_i0 (mem_commonEnvelope childrenD_700_i0 b hb) +def required_700_i3 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_700_i3 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 5), (2, 5), (2, 6), (3, 5), (3, 6), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_700_i3 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) required_5), (placed21 4 (1, 6) required_197)] +def childrenD_700_i3 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) envelope_5), (placed21 4 (1, 6) envelope_197)] +theorem common_sub_700_i3 : commonEnvelope childrenD_700_i3 ⊆ insert (3, 5) required_700_i3 := by decide +kernel +theorem child_required_sub_700_i3 : ∀ j, childrenC_700_i3 j ⊆ insert (3, 5) required_700_i3 := by decide +kernel +theorem child_envelope_sub_700_i3 : ∀ j, childrenD_700_i3 j ⊆ envelope_700_i3 := by decide +kernel +theorem pivot_mem_700_i3 : (3, 5) ∈ envelope_700_i3 := by decide +kernel +theorem children_work_700_i3 : ∀ j, Template HasSnaky 5 (childrenC_700_i3 j) (childrenD_700_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_197 4 (1, 6)).mono (by decide +kernel) +theorem row_works_700_i3 : Template HasSnaky 6 required_700_i3 envelope_700_i3 := by + refine compose HasSnaky 5 childrenC_700_i3 childrenD_700_i3 children_work_700_i3 (3, 5) + required_700_i3 envelope_700_i3 pivot_mem_700_i3 child_required_sub_700_i3 child_envelope_sub_700_i3 ?_ + intro b hb + exact common_sub_700_i3 (mem_commonEnvelope childrenD_700_i3 b hb) +def required_700_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 6), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_700_i2 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 5), (2, 6), (3, 5), (3, 6), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_700_i2 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) required_0), required_700_i3] +def childrenD_700_i2 : Fin 2 → Finset Cell := ![(placed21 1 (1, 2) envelope_0), envelope_700_i3] +theorem common_sub_700_i2 : commonEnvelope childrenD_700_i2 ⊆ insert (2, 5) required_700_i2 := by decide +kernel +theorem child_required_sub_700_i2 : ∀ j, childrenC_700_i2 j ⊆ insert (2, 5) required_700_i2 := by decide +kernel +theorem child_envelope_sub_700_i2 : ∀ j, childrenD_700_i2 j ⊆ envelope_700_i2 := by decide +kernel +theorem pivot_mem_700_i2 : (2, 5) ∈ envelope_700_i2 := by decide +kernel +theorem children_work_700_i2 : ∀ j, Template HasSnaky 6 (childrenC_700_i2 j) (childrenD_700_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (1, 2)).mono (by decide +kernel) + · exact row_works_700_i3.mono (by decide +kernel) +theorem row_works_700_i2 : Template HasSnaky 7 required_700_i2 envelope_700_i2 := by + refine compose HasSnaky 6 childrenC_700_i2 childrenD_700_i2 children_work_700_i2 (2, 5) + required_700_i2 envelope_700_i2 pivot_mem_700_i2 child_required_sub_700_i2 child_envelope_sub_700_i2 ?_ + intro b hb + exact common_sub_700_i2 (mem_commonEnvelope childrenD_700_i2 b hb) +def required_700_i1 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_700_i1 : Finset Cell := ⟨(([(0, 4), (0, 6), (0, 7), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7), (2, 8), (3, 5), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_700_i1 : Fin 3 → Finset Cell := ![(placed21 0 (1, 2) required_61), (placed21 1 (0, 3) required_348), required_700_i2] +def childrenD_700_i1 : Fin 3 → Finset Cell := ![(placed21 0 (1, 2) envelope_61), (placed21 1 (0, 3) envelope_348), envelope_700_i2] +theorem common_sub_700_i1 : commonEnvelope childrenD_700_i1 ⊆ insert (2, 6) required_700_i1 := by decide +kernel +theorem child_required_sub_700_i1 : ∀ j, childrenC_700_i1 j ⊆ insert (2, 6) required_700_i1 := by decide +kernel +theorem child_envelope_sub_700_i1 : ∀ j, childrenD_700_i1 j ⊆ envelope_700_i1 := by decide +kernel +theorem pivot_mem_700_i1 : (2, 6) ∈ envelope_700_i1 := by decide +kernel +theorem children_work_700_i1 : ∀ j, Template HasSnaky 7 (childrenC_700_i1 j) (childrenD_700_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_61 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_348 1 (0, 3)).mono (by decide +kernel) + · exact row_works_700_i2.mono (by decide +kernel) +theorem row_works_700_i1 : Template HasSnaky 8 required_700_i1 envelope_700_i1 := by + refine compose HasSnaky 7 childrenC_700_i1 childrenD_700_i1 children_work_700_i1 (2, 6) + required_700_i1 envelope_700_i1 pivot_mem_700_i1 child_required_sub_700_i1 child_envelope_sub_700_i1 ?_ + intro b hb + exact common_sub_700_i1 (mem_commonEnvelope childrenD_700_i1 b hb) +def required_700_i5 : Finset Cell := ⟨(([(4, 3), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_700_i5 : Finset Cell := ⟨(([(3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_700_i5 : Fin 3 → Finset Cell := ![(placed21 2 (4, 2) required_7), (placed21 3 (3, 6) required_8), (placed21 4 (3, 7) required_9)] +def childrenD_700_i5 : Fin 3 → Finset Cell := ![(placed21 2 (4, 2) envelope_7), (placed21 3 (3, 6) envelope_8), (placed21 4 (3, 7) envelope_9)] +theorem common_sub_700_i5 : commonEnvelope childrenD_700_i5 ⊆ insert (4, 4) required_700_i5 := by decide +kernel +theorem child_required_sub_700_i5 : ∀ j, childrenC_700_i5 j ⊆ insert (4, 4) required_700_i5 := by decide +kernel +theorem child_envelope_sub_700_i5 : ∀ j, childrenD_700_i5 j ⊆ envelope_700_i5 := by decide +kernel +theorem pivot_mem_700_i5 : (4, 4) ∈ envelope_700_i5 := by decide +kernel +theorem children_work_700_i5 : ∀ j, Template HasSnaky 3 (childrenC_700_i5 j) (childrenD_700_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_8 3 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_9 4 (3, 7)).mono (by decide +kernel) +theorem row_works_700_i5 : Template HasSnaky 4 required_700_i5 envelope_700_i5 := by + refine compose HasSnaky 3 childrenC_700_i5 childrenD_700_i5 children_work_700_i5 (4, 4) + required_700_i5 envelope_700_i5 pivot_mem_700_i5 child_required_sub_700_i5 child_envelope_sub_700_i5 ?_ + intro b hb + exact common_sub_700_i5 (mem_commonEnvelope childrenD_700_i5 b hb) +def required_700_i6 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_700_i6 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7), (2, 8), (3, 5), (4, 5), (4, 6), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_700_i6 : Fin 2 → Finset Cell := ![(placed21 1 (0, 4) required_40), (placed21 0 (1, 2) required_52)] +def childrenD_700_i6 : Fin 2 → Finset Cell := ![(placed21 1 (0, 4) envelope_40), (placed21 0 (1, 2) envelope_52)] +theorem common_sub_700_i6 : commonEnvelope childrenD_700_i6 ⊆ insert (2, 5) required_700_i6 := by decide +kernel +theorem child_required_sub_700_i6 : ∀ j, childrenC_700_i6 j ⊆ insert (2, 5) required_700_i6 := by decide +kernel +theorem child_envelope_sub_700_i6 : ∀ j, childrenD_700_i6 j ⊆ envelope_700_i6 := by decide +kernel +theorem pivot_mem_700_i6 : (2, 5) ∈ envelope_700_i6 := by decide +kernel +theorem children_work_700_i6 : ∀ j, Template HasSnaky 3 (childrenC_700_i6 j) (childrenD_700_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_40 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (1, 2)).mono (by decide +kernel) +theorem row_works_700_i6 : Template HasSnaky 4 required_700_i6 envelope_700_i6 := by + refine compose HasSnaky 3 childrenC_700_i6 childrenD_700_i6 children_work_700_i6 (2, 5) + required_700_i6 envelope_700_i6 pivot_mem_700_i6 child_required_sub_700_i6 child_envelope_sub_700_i6 ?_ + intro b hb + exact common_sub_700_i6 (mem_commonEnvelope childrenD_700_i6 b hb) +def required_700_i4 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_700_i4 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_700_i4 : Fin 3 → Finset Cell := ![(placed21 6 (5, 8) required_304), required_700_i5, required_700_i6] +def childrenD_700_i4 : Fin 3 → Finset Cell := ![(placed21 6 (5, 8) envelope_304), envelope_700_i5, envelope_700_i6] +theorem common_sub_700_i4 : commonEnvelope childrenD_700_i4 ⊆ insert (4, 6) required_700_i4 := by decide +kernel +theorem child_required_sub_700_i4 : ∀ j, childrenC_700_i4 j ⊆ insert (4, 6) required_700_i4 := by decide +kernel +theorem child_envelope_sub_700_i4 : ∀ j, childrenD_700_i4 j ⊆ envelope_700_i4 := by decide +kernel +theorem pivot_mem_700_i4 : (4, 6) ∈ envelope_700_i4 := by decide +kernel +theorem children_work_700_i4 : ∀ j, Template HasSnaky 4 (childrenC_700_i4 j) (childrenD_700_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_304 6 (5, 8)).mono (by decide +kernel) + · exact row_works_700_i5.mono (by decide +kernel) + · exact row_works_700_i6.mono (by decide +kernel) +theorem row_works_700_i4 : Template HasSnaky 5 required_700_i4 envelope_700_i4 := by + refine compose HasSnaky 4 childrenC_700_i4 childrenD_700_i4 children_work_700_i4 (4, 6) + required_700_i4 envelope_700_i4 pivot_mem_700_i4 child_required_sub_700_i4 child_envelope_sub_700_i4 ?_ + intro b hb + exact common_sub_700_i4 (mem_commonEnvelope childrenD_700_i4 b hb) +def required_700 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_700 : Finset Cell := ⟨(([(0, 4), (0, 6), (0, 7), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 1), (8, 2), (8, 3), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_700 : Fin 5 → Finset Cell := ![(placed21 4 (0, 8) required_204), required_700_i0, (placed21 0 (3, 0) required_460), required_700_i1, required_700_i4] +def childrenD_700 : Fin 5 → Finset Cell := ![(placed21 4 (0, 8) envelope_204), envelope_700_i0, (placed21 0 (3, 0) envelope_460), envelope_700_i1, envelope_700_i4] +theorem common_sub_700 : commonEnvelope childrenD_700 ⊆ insert (4, 5) required_700 := by decide +kernel +theorem child_required_sub_700 : ∀ j, childrenC_700 j ⊆ insert (4, 5) required_700 := by decide +kernel +theorem child_envelope_sub_700 : ∀ j, childrenD_700 j ⊆ envelope_700 := by decide +kernel +theorem pivot_mem_700 : (4, 5) ∈ envelope_700 := by decide +kernel +theorem children_work_700 : ∀ j, Template HasSnaky 10 (childrenC_700 j) (childrenD_700 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_204 4 (0, 8)).mono (by decide +kernel) + · exact row_works_700_i0.mono (by decide +kernel) + · exact (placed21_template row_works_460 0 (3, 0)).mono (by decide +kernel) + · exact row_works_700_i1.mono (by decide +kernel) + · exact row_works_700_i4.mono (by decide +kernel) +theorem row_works_700 : Template HasSnaky 11 required_700 envelope_700 := by + refine compose HasSnaky 10 childrenC_700 childrenD_700 children_work_700 (4, 5) + required_700 envelope_700 pivot_mem_700 child_required_sub_700 child_envelope_sub_700 ?_ + intro b hb + exact common_sub_700 (mem_commonEnvelope childrenD_700 b hb) +def required_710_i1 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_710_i1 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_710_i1 : Fin 2 → Finset Cell := ![(placed21 0 (3, 2) required_6), (placed21 3 (2, 6) required_196)] +def childrenD_710_i1 : Fin 2 → Finset Cell := ![(placed21 0 (3, 2) envelope_6), (placed21 3 (2, 6) envelope_196)] +theorem common_sub_710_i1 : commonEnvelope childrenD_710_i1 ⊆ insert (3, 2) required_710_i1 := by decide +kernel +theorem child_required_sub_710_i1 : ∀ j, childrenC_710_i1 j ⊆ insert (3, 2) required_710_i1 := by decide +kernel +theorem child_envelope_sub_710_i1 : ∀ j, childrenD_710_i1 j ⊆ envelope_710_i1 := by decide +kernel +theorem pivot_mem_710_i1 : (3, 2) ∈ envelope_710_i1 := by decide +kernel +theorem children_work_710_i1 : ∀ j, Template HasSnaky 4 (childrenC_710_i1 j) (childrenD_710_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_196 3 (2, 6)).mono (by decide +kernel) +theorem row_works_710_i1 : Template HasSnaky 5 required_710_i1 envelope_710_i1 := by + refine compose HasSnaky 4 childrenC_710_i1 childrenD_710_i1 children_work_710_i1 (3, 2) + required_710_i1 envelope_710_i1 pivot_mem_710_i1 child_required_sub_710_i1 child_envelope_sub_710_i1 ?_ + intro b hb + exact common_sub_710_i1 (mem_commonEnvelope childrenD_710_i1 b hb) +def required_710_i0 : Finset Cell := ⟨(([(3, 4), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_710_i0 : Finset Cell := ⟨(([(0, 4), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_710_i0 : Fin 4 → Finset Cell := ![(placed21 4 (3, 7) required_7), (placed21 3 (0, 6) required_115), required_710_i1, (placed21 1 (1, 2) required_577)] +def childrenD_710_i0 : Fin 4 → Finset Cell := ![(placed21 4 (3, 7) envelope_7), (placed21 3 (0, 6) envelope_115), envelope_710_i1, (placed21 1 (1, 2) envelope_577)] +theorem common_sub_710_i0 : commonEnvelope childrenD_710_i0 ⊆ insert (3, 3) required_710_i0 := by decide +kernel +theorem child_required_sub_710_i0 : ∀ j, childrenC_710_i0 j ⊆ insert (3, 3) required_710_i0 := by decide +kernel +theorem child_envelope_sub_710_i0 : ∀ j, childrenD_710_i0 j ⊆ envelope_710_i0 := by decide +kernel +theorem pivot_mem_710_i0 : (3, 3) ∈ envelope_710_i0 := by decide +kernel +theorem children_work_710_i0 : ∀ j, Template HasSnaky 9 (childrenC_710_i0 j) (childrenD_710_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_115 3 (0, 6)).mono (by decide +kernel) + · exact row_works_710_i1.mono (by decide +kernel) + · exact (placed21_template row_works_577 1 (1, 2)).mono (by decide +kernel) +theorem row_works_710_i0 : Template HasSnaky 10 required_710_i0 envelope_710_i0 := by + refine compose HasSnaky 9 childrenC_710_i0 childrenD_710_i0 children_work_710_i0 (3, 3) + required_710_i0 envelope_710_i0 pivot_mem_710_i0 child_required_sub_710_i0 child_envelope_sub_710_i0 ?_ + intro b hb + exact common_sub_710_i0 (mem_commonEnvelope childrenD_710_i0 b hb) +def required_710 : Finset Cell := ⟨(([(3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_710 : Finset Cell := ⟨(([(0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 3), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_710 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) required_13), (placed21 2 (4, 2) required_14), (placed21 1 (0, 3) required_117), required_710_i0] +def childrenD_710 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) envelope_13), (placed21 2 (4, 2) envelope_14), (placed21 1 (0, 3) envelope_117), envelope_710_i0] +theorem common_sub_710 : commonEnvelope childrenD_710 ⊆ insert (3, 6) required_710 := by decide +kernel +theorem child_required_sub_710 : ∀ j, childrenC_710 j ⊆ insert (3, 6) required_710 := by decide +kernel +theorem child_envelope_sub_710 : ∀ j, childrenD_710 j ⊆ envelope_710 := by decide +kernel +theorem pivot_mem_710 : (3, 6) ∈ envelope_710 := by decide +kernel +theorem children_work_710 : ∀ j, Template HasSnaky 10 (childrenC_710 j) (childrenD_710 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_14 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_117 1 (0, 3)).mono (by decide +kernel) + · exact row_works_710_i0.mono (by decide +kernel) +theorem row_works_710 : Template HasSnaky 11 required_710 envelope_710 := by + refine compose HasSnaky 10 childrenC_710 childrenD_710 children_work_710 (3, 6) + required_710 envelope_710 pivot_mem_710 child_required_sub_710 child_envelope_sub_710 ?_ + intro b hb + exact common_sub_710 (mem_commonEnvelope childrenD_710 b hb) +def required_716_i0 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_716_i0 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 5), (7, 6), (7, 7), (7, 8), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_716_i0 : Fin 2 → Finset Cell := ![(placed21 0 (4, 2) required_55), (placed21 2 (7, 0) required_659)] +def childrenD_716_i0 : Fin 2 → Finset Cell := ![(placed21 0 (4, 2) envelope_55), (placed21 2 (7, 0) envelope_659)] +theorem common_sub_716_i0 : commonEnvelope childrenD_716_i0 ⊆ insert (6, 4) required_716_i0 := by decide +kernel +theorem child_required_sub_716_i0 : ∀ j, childrenC_716_i0 j ⊆ insert (6, 4) required_716_i0 := by decide +kernel +theorem child_envelope_sub_716_i0 : ∀ j, childrenD_716_i0 j ⊆ envelope_716_i0 := by decide +kernel +theorem pivot_mem_716_i0 : (6, 4) ∈ envelope_716_i0 := by decide +kernel +theorem children_work_716_i0 : ∀ j, Template HasSnaky 9 (childrenC_716_i0 j) (childrenD_716_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_55 0 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_659 2 (7, 0)).mono (by decide +kernel) +theorem row_works_716_i0 : Template HasSnaky 10 required_716_i0 envelope_716_i0 := by + refine compose HasSnaky 9 childrenC_716_i0 childrenD_716_i0 children_work_716_i0 (6, 4) + required_716_i0 envelope_716_i0 pivot_mem_716_i0 child_required_sub_716_i0 child_envelope_sub_716_i0 ?_ + intro b hb + exact common_sub_716_i0 (mem_commonEnvelope childrenD_716_i0 b hb) +def required_716 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_716 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 5), (7, 6), (7, 7), (7, 8), (8, 4), (8, 5), (8, 6), (9, 4), (9, 5), (9, 6), (10, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_716 : Fin 4 → Finset Cell := ![(placed21 1 (3, 4) required_9), (placed21 4 (4, 6) required_49), (placed21 0 (3, 2) required_142), required_716_i0] +def childrenD_716 : Fin 4 → Finset Cell := ![(placed21 1 (3, 4) envelope_9), (placed21 4 (4, 6) envelope_49), (placed21 0 (3, 2) envelope_142), envelope_716_i0] +theorem common_sub_716 : commonEnvelope childrenD_716 ⊆ insert (7, 5) required_716 := by decide +kernel +theorem child_required_sub_716 : ∀ j, childrenC_716 j ⊆ insert (7, 5) required_716 := by decide +kernel +theorem child_envelope_sub_716 : ∀ j, childrenD_716 j ⊆ envelope_716 := by decide +kernel +theorem pivot_mem_716 : (7, 5) ∈ envelope_716 := by decide +kernel +theorem children_work_716 : ∀ j, Template HasSnaky 10 (childrenC_716 j) (childrenD_716 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 1 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_49 4 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_142 0 (3, 2)).mono (by decide +kernel) + · exact row_works_716_i0.mono (by decide +kernel) +theorem row_works_716 : Template HasSnaky 11 required_716 envelope_716 := by + refine compose HasSnaky 10 childrenC_716 childrenD_716 children_work_716 (7, 5) + required_716 envelope_716 pivot_mem_716 child_required_sub_716 child_envelope_sub_716 ?_ + intro b hb + exact common_sub_716 (mem_commonEnvelope childrenD_716 b hb) +def height_689_i0 : ℕ := 10 +def childrenH_689_i0 : Fin 6 → ℕ := ![height_67, height_175, height_228, height_373, height_435, height_688] +theorem height_exact_689_i0 : height_689_i0 = 1 + Finset.univ.sup childrenH_689_i0 := by decide +kernel +theorem required_origin_689_i0 : ∀ x ∈ required_689_i0, + (∃ j, x ∈ childrenC_689_i0 j) ∨ ∀ j, x ∈ childrenD_689_i0 j := by decide +kernel +theorem required_exact_689_i0 : required_689_i0 = + ((Finset.univ.biUnion childrenC_689_i0) ∪ commonEnvelope childrenD_689_i0).erase (4, 6) := by + exact required_eq_combination childrenC_689_i0 childrenD_689_i0 (4, 6) required_689_i0 + (by decide +kernel) child_required_sub_689_i0 common_sub_689_i0 required_origin_689_i0 +theorem envelope_origin_689_i0 : ∀ x ∈ envelope_689_i0, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_689_i0 j := by decide +kernel +theorem envelope_exact_689_i0 : envelope_689_i0 = + insert (4, 6) (Finset.univ.biUnion childrenD_689_i0) := by + exact envelope_eq_combination childrenD_689_i0 (4, 6) envelope_689_i0 + pivot_mem_689_i0 child_envelope_sub_689_i0 envelope_origin_689_i0 +def checked_689_i0 : CheckedCard where + required := required_689_i0 + envelope := envelope_689_i0 + height := height_689_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_689_i0 +def height_689 : ℕ := 11 +def childrenH_689 : Fin 4 → ℕ := ![height_44, height_324, height_686, height_689_i0] +theorem height_exact_689 : height_689 = 1 + Finset.univ.sup childrenH_689 := by decide +kernel +theorem required_origin_689 : ∀ x ∈ required_689, + (∃ j, x ∈ childrenC_689 j) ∨ ∀ j, x ∈ childrenD_689 j := by decide +kernel +theorem required_exact_689 : required_689 = + ((Finset.univ.biUnion childrenC_689) ∪ commonEnvelope childrenD_689).erase (4, 5) := by + exact required_eq_combination childrenC_689 childrenD_689 (4, 5) required_689 + (by decide +kernel) child_required_sub_689 common_sub_689 required_origin_689 +theorem envelope_origin_689 : ∀ x ∈ envelope_689, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_689 j := by decide +kernel +theorem envelope_exact_689 : envelope_689 = + insert (4, 5) (Finset.univ.biUnion childrenD_689) := by + exact envelope_eq_combination childrenD_689 (4, 5) envelope_689 + pivot_mem_689 child_envelope_sub_689 envelope_origin_689 +def checked_689 : CheckedCard where + required := required_689 + envelope := envelope_689 + height := height_689 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_689 +def height_700_i0 : ℕ := 5 +def childrenH_700_i0 : Fin 2 → ℕ := ![height_39, height_52] +theorem height_exact_700_i0 : height_700_i0 = 1 + Finset.univ.sup childrenH_700_i0 := by decide +kernel +theorem required_origin_700_i0 : ∀ x ∈ required_700_i0, + (∃ j, x ∈ childrenC_700_i0 j) ∨ ∀ j, x ∈ childrenD_700_i0 j := by decide +kernel +theorem required_exact_700_i0 : required_700_i0 = + ((Finset.univ.biUnion childrenC_700_i0) ∪ commonEnvelope childrenD_700_i0).erase (2, 5) := by + exact required_eq_combination childrenC_700_i0 childrenD_700_i0 (2, 5) required_700_i0 + (by decide +kernel) child_required_sub_700_i0 common_sub_700_i0 required_origin_700_i0 +theorem envelope_origin_700_i0 : ∀ x ∈ envelope_700_i0, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_700_i0 j := by decide +kernel +theorem envelope_exact_700_i0 : envelope_700_i0 = + insert (2, 5) (Finset.univ.biUnion childrenD_700_i0) := by + exact envelope_eq_combination childrenD_700_i0 (2, 5) envelope_700_i0 + pivot_mem_700_i0 child_envelope_sub_700_i0 envelope_origin_700_i0 +def checked_700_i0 : CheckedCard where + required := required_700_i0 + envelope := envelope_700_i0 + height := height_700_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_700_i0 +def height_700_i3 : ℕ := 6 +def childrenH_700_i3 : Fin 2 → ℕ := ![height_5, height_197] +theorem height_exact_700_i3 : height_700_i3 = 1 + Finset.univ.sup childrenH_700_i3 := by decide +kernel +theorem required_origin_700_i3 : ∀ x ∈ required_700_i3, + (∃ j, x ∈ childrenC_700_i3 j) ∨ ∀ j, x ∈ childrenD_700_i3 j := by decide +kernel +theorem required_exact_700_i3 : required_700_i3 = + ((Finset.univ.biUnion childrenC_700_i3) ∪ commonEnvelope childrenD_700_i3).erase (3, 5) := by + exact required_eq_combination childrenC_700_i3 childrenD_700_i3 (3, 5) required_700_i3 + (by decide +kernel) child_required_sub_700_i3 common_sub_700_i3 required_origin_700_i3 +theorem envelope_origin_700_i3 : ∀ x ∈ envelope_700_i3, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_700_i3 j := by decide +kernel +theorem envelope_exact_700_i3 : envelope_700_i3 = + insert (3, 5) (Finset.univ.biUnion childrenD_700_i3) := by + exact envelope_eq_combination childrenD_700_i3 (3, 5) envelope_700_i3 + pivot_mem_700_i3 child_envelope_sub_700_i3 envelope_origin_700_i3 +def checked_700_i3 : CheckedCard where + required := required_700_i3 + envelope := envelope_700_i3 + height := height_700_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_700_i3 +def height_700_i2 : ℕ := 7 +def childrenH_700_i2 : Fin 2 → ℕ := ![height_0, height_700_i3] +theorem height_exact_700_i2 : height_700_i2 = 1 + Finset.univ.sup childrenH_700_i2 := by decide +kernel +theorem required_origin_700_i2 : ∀ x ∈ required_700_i2, + (∃ j, x ∈ childrenC_700_i2 j) ∨ ∀ j, x ∈ childrenD_700_i2 j := by decide +kernel +theorem required_exact_700_i2 : required_700_i2 = + ((Finset.univ.biUnion childrenC_700_i2) ∪ commonEnvelope childrenD_700_i2).erase (2, 5) := by + exact required_eq_combination childrenC_700_i2 childrenD_700_i2 (2, 5) required_700_i2 + (by decide +kernel) child_required_sub_700_i2 common_sub_700_i2 required_origin_700_i2 +theorem envelope_origin_700_i2 : ∀ x ∈ envelope_700_i2, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_700_i2 j := by decide +kernel +theorem envelope_exact_700_i2 : envelope_700_i2 = + insert (2, 5) (Finset.univ.biUnion childrenD_700_i2) := by + exact envelope_eq_combination childrenD_700_i2 (2, 5) envelope_700_i2 + pivot_mem_700_i2 child_envelope_sub_700_i2 envelope_origin_700_i2 +def checked_700_i2 : CheckedCard where + required := required_700_i2 + envelope := envelope_700_i2 + height := height_700_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_700_i2 +def height_700_i1 : ℕ := 8 +def childrenH_700_i1 : Fin 3 → ℕ := ![height_61, height_348, height_700_i2] +theorem height_exact_700_i1 : height_700_i1 = 1 + Finset.univ.sup childrenH_700_i1 := by decide +kernel +theorem required_origin_700_i1 : ∀ x ∈ required_700_i1, + (∃ j, x ∈ childrenC_700_i1 j) ∨ ∀ j, x ∈ childrenD_700_i1 j := by decide +kernel +theorem required_exact_700_i1 : required_700_i1 = + ((Finset.univ.biUnion childrenC_700_i1) ∪ commonEnvelope childrenD_700_i1).erase (2, 6) := by + exact required_eq_combination childrenC_700_i1 childrenD_700_i1 (2, 6) required_700_i1 + (by decide +kernel) child_required_sub_700_i1 common_sub_700_i1 required_origin_700_i1 +theorem envelope_origin_700_i1 : ∀ x ∈ envelope_700_i1, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_700_i1 j := by decide +kernel +theorem envelope_exact_700_i1 : envelope_700_i1 = + insert (2, 6) (Finset.univ.biUnion childrenD_700_i1) := by + exact envelope_eq_combination childrenD_700_i1 (2, 6) envelope_700_i1 + pivot_mem_700_i1 child_envelope_sub_700_i1 envelope_origin_700_i1 +def checked_700_i1 : CheckedCard where + required := required_700_i1 + envelope := envelope_700_i1 + height := height_700_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_700_i1 +def height_700_i5 : ℕ := 4 +def childrenH_700_i5 : Fin 3 → ℕ := ![height_7, height_8, height_9] +theorem height_exact_700_i5 : height_700_i5 = 1 + Finset.univ.sup childrenH_700_i5 := by decide +kernel +theorem required_origin_700_i5 : ∀ x ∈ required_700_i5, + (∃ j, x ∈ childrenC_700_i5 j) ∨ ∀ j, x ∈ childrenD_700_i5 j := by decide +kernel +theorem required_exact_700_i5 : required_700_i5 = + ((Finset.univ.biUnion childrenC_700_i5) ∪ commonEnvelope childrenD_700_i5).erase (4, 4) := by + exact required_eq_combination childrenC_700_i5 childrenD_700_i5 (4, 4) required_700_i5 + (by decide +kernel) child_required_sub_700_i5 common_sub_700_i5 required_origin_700_i5 +theorem envelope_origin_700_i5 : ∀ x ∈ envelope_700_i5, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_700_i5 j := by decide +kernel +theorem envelope_exact_700_i5 : envelope_700_i5 = + insert (4, 4) (Finset.univ.biUnion childrenD_700_i5) := by + exact envelope_eq_combination childrenD_700_i5 (4, 4) envelope_700_i5 + pivot_mem_700_i5 child_envelope_sub_700_i5 envelope_origin_700_i5 +def checked_700_i5 : CheckedCard where + required := required_700_i5 + envelope := envelope_700_i5 + height := height_700_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_700_i5 +def height_700_i6 : ℕ := 4 +def childrenH_700_i6 : Fin 2 → ℕ := ![height_40, height_52] +theorem height_exact_700_i6 : height_700_i6 = 1 + Finset.univ.sup childrenH_700_i6 := by decide +kernel +theorem required_origin_700_i6 : ∀ x ∈ required_700_i6, + (∃ j, x ∈ childrenC_700_i6 j) ∨ ∀ j, x ∈ childrenD_700_i6 j := by decide +kernel +theorem required_exact_700_i6 : required_700_i6 = + ((Finset.univ.biUnion childrenC_700_i6) ∪ commonEnvelope childrenD_700_i6).erase (2, 5) := by + exact required_eq_combination childrenC_700_i6 childrenD_700_i6 (2, 5) required_700_i6 + (by decide +kernel) child_required_sub_700_i6 common_sub_700_i6 required_origin_700_i6 +theorem envelope_origin_700_i6 : ∀ x ∈ envelope_700_i6, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_700_i6 j := by decide +kernel +theorem envelope_exact_700_i6 : envelope_700_i6 = + insert (2, 5) (Finset.univ.biUnion childrenD_700_i6) := by + exact envelope_eq_combination childrenD_700_i6 (2, 5) envelope_700_i6 + pivot_mem_700_i6 child_envelope_sub_700_i6 envelope_origin_700_i6 +def checked_700_i6 : CheckedCard where + required := required_700_i6 + envelope := envelope_700_i6 + height := height_700_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_700_i6 +def height_700_i4 : ℕ := 5 +def childrenH_700_i4 : Fin 3 → ℕ := ![height_304, height_700_i5, height_700_i6] +theorem height_exact_700_i4 : height_700_i4 = 1 + Finset.univ.sup childrenH_700_i4 := by decide +kernel +theorem required_origin_700_i4 : ∀ x ∈ required_700_i4, + (∃ j, x ∈ childrenC_700_i4 j) ∨ ∀ j, x ∈ childrenD_700_i4 j := by decide +kernel +theorem required_exact_700_i4 : required_700_i4 = + ((Finset.univ.biUnion childrenC_700_i4) ∪ commonEnvelope childrenD_700_i4).erase (4, 6) := by + exact required_eq_combination childrenC_700_i4 childrenD_700_i4 (4, 6) required_700_i4 + (by decide +kernel) child_required_sub_700_i4 common_sub_700_i4 required_origin_700_i4 +theorem envelope_origin_700_i4 : ∀ x ∈ envelope_700_i4, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_700_i4 j := by decide +kernel +theorem envelope_exact_700_i4 : envelope_700_i4 = + insert (4, 6) (Finset.univ.biUnion childrenD_700_i4) := by + exact envelope_eq_combination childrenD_700_i4 (4, 6) envelope_700_i4 + pivot_mem_700_i4 child_envelope_sub_700_i4 envelope_origin_700_i4 +def checked_700_i4 : CheckedCard where + required := required_700_i4 + envelope := envelope_700_i4 + height := height_700_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_700_i4 +def height_700 : ℕ := 11 +def childrenH_700 : Fin 5 → ℕ := ![height_204, height_700_i0, height_460, height_700_i1, height_700_i4] +theorem height_exact_700 : height_700 = 1 + Finset.univ.sup childrenH_700 := by decide +kernel +theorem required_origin_700 : ∀ x ∈ required_700, + (∃ j, x ∈ childrenC_700 j) ∨ ∀ j, x ∈ childrenD_700 j := by decide +kernel +theorem required_exact_700 : required_700 = + ((Finset.univ.biUnion childrenC_700) ∪ commonEnvelope childrenD_700).erase (4, 5) := by + exact required_eq_combination childrenC_700 childrenD_700 (4, 5) required_700 + (by decide +kernel) child_required_sub_700 common_sub_700 required_origin_700 +theorem envelope_origin_700 : ∀ x ∈ envelope_700, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_700 j := by decide +kernel +theorem envelope_exact_700 : envelope_700 = + insert (4, 5) (Finset.univ.biUnion childrenD_700) := by + exact envelope_eq_combination childrenD_700 (4, 5) envelope_700 + pivot_mem_700 child_envelope_sub_700 envelope_origin_700 +def checked_700 : CheckedCard where + required := required_700 + envelope := envelope_700 + height := height_700 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_700 +def height_710_i1 : ℕ := 5 +def childrenH_710_i1 : Fin 2 → ℕ := ![height_6, height_196] +theorem height_exact_710_i1 : height_710_i1 = 1 + Finset.univ.sup childrenH_710_i1 := by decide +kernel +theorem required_origin_710_i1 : ∀ x ∈ required_710_i1, + (∃ j, x ∈ childrenC_710_i1 j) ∨ ∀ j, x ∈ childrenD_710_i1 j := by decide +kernel +theorem required_exact_710_i1 : required_710_i1 = + ((Finset.univ.biUnion childrenC_710_i1) ∪ commonEnvelope childrenD_710_i1).erase (3, 2) := by + exact required_eq_combination childrenC_710_i1 childrenD_710_i1 (3, 2) required_710_i1 + (by decide +kernel) child_required_sub_710_i1 common_sub_710_i1 required_origin_710_i1 +theorem envelope_origin_710_i1 : ∀ x ∈ envelope_710_i1, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_710_i1 j := by decide +kernel +theorem envelope_exact_710_i1 : envelope_710_i1 = + insert (3, 2) (Finset.univ.biUnion childrenD_710_i1) := by + exact envelope_eq_combination childrenD_710_i1 (3, 2) envelope_710_i1 + pivot_mem_710_i1 child_envelope_sub_710_i1 envelope_origin_710_i1 +def checked_710_i1 : CheckedCard where + required := required_710_i1 + envelope := envelope_710_i1 + height := height_710_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_710_i1 +def height_710_i0 : ℕ := 10 +def childrenH_710_i0 : Fin 4 → ℕ := ![height_7, height_115, height_710_i1, height_577] +theorem height_exact_710_i0 : height_710_i0 = 1 + Finset.univ.sup childrenH_710_i0 := by decide +kernel +theorem required_origin_710_i0 : ∀ x ∈ required_710_i0, + (∃ j, x ∈ childrenC_710_i0 j) ∨ ∀ j, x ∈ childrenD_710_i0 j := by decide +kernel +theorem required_exact_710_i0 : required_710_i0 = + ((Finset.univ.biUnion childrenC_710_i0) ∪ commonEnvelope childrenD_710_i0).erase (3, 3) := by + exact required_eq_combination childrenC_710_i0 childrenD_710_i0 (3, 3) required_710_i0 + (by decide +kernel) child_required_sub_710_i0 common_sub_710_i0 required_origin_710_i0 +theorem envelope_origin_710_i0 : ∀ x ∈ envelope_710_i0, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_710_i0 j := by decide +kernel +theorem envelope_exact_710_i0 : envelope_710_i0 = + insert (3, 3) (Finset.univ.biUnion childrenD_710_i0) := by + exact envelope_eq_combination childrenD_710_i0 (3, 3) envelope_710_i0 + pivot_mem_710_i0 child_envelope_sub_710_i0 envelope_origin_710_i0 +def checked_710_i0 : CheckedCard where + required := required_710_i0 + envelope := envelope_710_i0 + height := height_710_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_710_i0 +def height_710 : ℕ := 11 +def childrenH_710 : Fin 4 → ℕ := ![height_13, height_14, height_117, height_710_i0] +theorem height_exact_710 : height_710 = 1 + Finset.univ.sup childrenH_710 := by decide +kernel +theorem required_origin_710 : ∀ x ∈ required_710, + (∃ j, x ∈ childrenC_710 j) ∨ ∀ j, x ∈ childrenD_710 j := by decide +kernel +theorem required_exact_710 : required_710 = + ((Finset.univ.biUnion childrenC_710) ∪ commonEnvelope childrenD_710).erase (3, 6) := by + exact required_eq_combination childrenC_710 childrenD_710 (3, 6) required_710 + (by decide +kernel) child_required_sub_710 common_sub_710 required_origin_710 +theorem envelope_origin_710 : ∀ x ∈ envelope_710, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_710 j := by decide +kernel +theorem envelope_exact_710 : envelope_710 = + insert (3, 6) (Finset.univ.biUnion childrenD_710) := by + exact envelope_eq_combination childrenD_710 (3, 6) envelope_710 + pivot_mem_710 child_envelope_sub_710 envelope_origin_710 +def checked_710 : CheckedCard where + required := required_710 + envelope := envelope_710 + height := height_710 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_710 +def height_716_i0 : ℕ := 10 +def childrenH_716_i0 : Fin 2 → ℕ := ![height_55, height_659] +theorem height_exact_716_i0 : height_716_i0 = 1 + Finset.univ.sup childrenH_716_i0 := by decide +kernel +theorem required_origin_716_i0 : ∀ x ∈ required_716_i0, + (∃ j, x ∈ childrenC_716_i0 j) ∨ ∀ j, x ∈ childrenD_716_i0 j := by decide +kernel +theorem required_exact_716_i0 : required_716_i0 = + ((Finset.univ.biUnion childrenC_716_i0) ∪ commonEnvelope childrenD_716_i0).erase (6, 4) := by + exact required_eq_combination childrenC_716_i0 childrenD_716_i0 (6, 4) required_716_i0 + (by decide +kernel) child_required_sub_716_i0 common_sub_716_i0 required_origin_716_i0 +theorem envelope_origin_716_i0 : ∀ x ∈ envelope_716_i0, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_716_i0 j := by decide +kernel +theorem envelope_exact_716_i0 : envelope_716_i0 = + insert (6, 4) (Finset.univ.biUnion childrenD_716_i0) := by + exact envelope_eq_combination childrenD_716_i0 (6, 4) envelope_716_i0 + pivot_mem_716_i0 child_envelope_sub_716_i0 envelope_origin_716_i0 +def checked_716_i0 : CheckedCard where + required := required_716_i0 + envelope := envelope_716_i0 + height := height_716_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_716_i0 +def height_716 : ℕ := 11 +def childrenH_716 : Fin 4 → ℕ := ![height_9, height_49, height_142, height_716_i0] +theorem height_exact_716 : height_716 = 1 + Finset.univ.sup childrenH_716 := by decide +kernel +theorem required_origin_716 : ∀ x ∈ required_716, + (∃ j, x ∈ childrenC_716 j) ∨ ∀ j, x ∈ childrenD_716 j := by decide +kernel +theorem required_exact_716 : required_716 = + ((Finset.univ.biUnion childrenC_716) ∪ commonEnvelope childrenD_716).erase (7, 5) := by + exact required_eq_combination childrenC_716 childrenD_716 (7, 5) required_716 + (by decide +kernel) child_required_sub_716 common_sub_716 required_origin_716 +theorem envelope_origin_716 : ∀ x ∈ envelope_716, + x = (7, 5) ∨ ∃ j, x ∈ childrenD_716 j := by decide +kernel +theorem envelope_exact_716 : envelope_716 = + insert (7, 5) (Finset.univ.biUnion childrenD_716) := by + exact envelope_eq_combination childrenD_716 (7, 5) envelope_716 + pivot_mem_716 child_envelope_sub_716 envelope_origin_716 +def checked_716 : CheckedCard where + required := required_716 + envelope := envelope_716 + height := height_716 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_716 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part01.lean new file mode 100644 index 0000000..29f0fde --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part01.lean @@ -0,0 +1,962 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_428 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_428 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5), (6, 3), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_428 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) required_7), (placed21 1 (0, 1) required_8), (placed21 2 (2, 0) required_9), (placed21 4 (0, 5) required_427)] +def childrenD_428 : Fin 4 → Finset Cell := ![(placed21 0 (1, 0) envelope_7), (placed21 1 (0, 1) envelope_8), (placed21 2 (2, 0) envelope_9), (placed21 4 (0, 5) envelope_427)] +theorem common_sub_428 : commonEnvelope childrenD_428 ⊆ insert (1, 4) required_428 := by decide +kernel +theorem child_required_sub_428 : ∀ j, childrenC_428 j ⊆ insert (1, 4) required_428 := by decide +kernel +theorem child_envelope_sub_428 : ∀ j, childrenD_428 j ⊆ envelope_428 := by decide +kernel +theorem pivot_mem_428 : (1, 4) ∈ envelope_428 := by decide +kernel +theorem children_work_428 : ∀ j, Template HasSnaky 11 (childrenC_428 j) (childrenD_428 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_427 4 (0, 5)).mono (by decide +kernel) +theorem row_works_428 : Template HasSnaky 12 required_428 envelope_428 := by + refine compose HasSnaky 11 childrenC_428 childrenD_428 children_work_428 (1, 4) + required_428 envelope_428 pivot_mem_428 child_required_sub_428 child_envelope_sub_428 ?_ + intro b hb + exact common_sub_428 (mem_commonEnvelope childrenD_428 b hb) +def required_485_i0 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_485_i0 : Finset Cell := ⟨(([(0, 4), (0, 6), (0, 7), (0, 8), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4), (7, 5), (7, 6), (7, 7), (8, 5), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_485_i0 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) required_81), (placed21 4 (0, 8) required_204), required_353, (placed21 4 (2, 8) required_481)] +def childrenD_485_i0 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) envelope_81), (placed21 4 (0, 8) envelope_204), envelope_353, (placed21 4 (2, 8) envelope_481)] +theorem common_sub_485_i0 : commonEnvelope childrenD_485_i0 ⊆ insert (4, 5) required_485_i0 := by decide +kernel +theorem child_required_sub_485_i0 : ∀ j, childrenC_485_i0 j ⊆ insert (4, 5) required_485_i0 := by decide +kernel +theorem child_envelope_sub_485_i0 : ∀ j, childrenD_485_i0 j ⊆ envelope_485_i0 := by decide +kernel +theorem pivot_mem_485_i0 : (4, 5) ∈ envelope_485_i0 := by decide +kernel +theorem children_work_485_i0 : ∀ j, Template HasSnaky 10 (childrenC_485_i0 j) (childrenD_485_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_81 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_204 4 (0, 8)).mono (by decide +kernel) + · exact row_works_353.mono (by decide +kernel) + · exact (placed21_template row_works_481 4 (2, 8)).mono (by decide +kernel) +theorem row_works_485_i0 : Template HasSnaky 11 required_485_i0 envelope_485_i0 := by + refine compose HasSnaky 10 childrenC_485_i0 childrenD_485_i0 children_work_485_i0 (4, 5) + required_485_i0 envelope_485_i0 pivot_mem_485_i0 child_required_sub_485_i0 child_envelope_sub_485_i0 ?_ + intro b hb + exact common_sub_485_i0 (mem_commonEnvelope childrenD_485_i0 b hb) +def required_485_i2 : Finset Cell := ⟨(([(4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_485_i2 : Finset Cell := ⟨(([(2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4), (7, 5), (7, 6), (7, 7), (8, 5), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_485_i2 : Fin 6 → Finset Cell := ![(placed21 2 (5, 1) required_14), (placed21 0 (3, 1) required_189), (placed21 2 (5, 1) required_192), (placed21 2 (5, 1) required_193), (placed21 0 (3, 2) required_457), (placed21 3 (2, 6) required_477)] +def childrenD_485_i2 : Fin 6 → Finset Cell := ![(placed21 2 (5, 1) envelope_14), (placed21 0 (3, 1) envelope_189), (placed21 2 (5, 1) envelope_192), (placed21 2 (5, 1) envelope_193), (placed21 0 (3, 2) envelope_457), (placed21 3 (2, 6) envelope_477)] +theorem common_sub_485_i2 : commonEnvelope childrenD_485_i2 ⊆ insert (4, 4) required_485_i2 := by decide +kernel +theorem child_required_sub_485_i2 : ∀ j, childrenC_485_i2 j ⊆ insert (4, 4) required_485_i2 := by decide +kernel +theorem child_envelope_sub_485_i2 : ∀ j, childrenD_485_i2 j ⊆ envelope_485_i2 := by decide +kernel +theorem pivot_mem_485_i2 : (4, 4) ∈ envelope_485_i2 := by decide +kernel +theorem children_work_485_i2 : ∀ j, Template HasSnaky 9 (childrenC_485_i2 j) (childrenD_485_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 2 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_189 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_192 2 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_193 2 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_457 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_477 3 (2, 6)).mono (by decide +kernel) +theorem row_works_485_i2 : Template HasSnaky 10 required_485_i2 envelope_485_i2 := by + refine compose HasSnaky 9 childrenC_485_i2 childrenD_485_i2 children_work_485_i2 (4, 4) + required_485_i2 envelope_485_i2 pivot_mem_485_i2 child_required_sub_485_i2 child_envelope_sub_485_i2 ?_ + intro b hb + exact common_sub_485_i2 (mem_commonEnvelope childrenD_485_i2 b hb) +def required_485_i3 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_485_i3 : Finset Cell := ⟨(([(0, 6), (0, 7), (0, 8), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 4), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_485_i3 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) required_166), (placed21 5 (2, 2) required_314)] +def childrenD_485_i3 : Fin 2 → Finset Cell := ![(placed21 0 (1, 1) envelope_166), (placed21 5 (2, 2) envelope_314)] +theorem common_sub_485_i3 : commonEnvelope childrenD_485_i3 ⊆ insert (2, 4) required_485_i3 := by decide +kernel +theorem child_required_sub_485_i3 : ∀ j, childrenC_485_i3 j ⊆ insert (2, 4) required_485_i3 := by decide +kernel +theorem child_envelope_sub_485_i3 : ∀ j, childrenD_485_i3 j ⊆ envelope_485_i3 := by decide +kernel +theorem pivot_mem_485_i3 : (2, 4) ∈ envelope_485_i3 := by decide +kernel +theorem children_work_485_i3 : ∀ j, Template HasSnaky 6 (childrenC_485_i3 j) (childrenD_485_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_166 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_314 5 (2, 2)).mono (by decide +kernel) +theorem row_works_485_i3 : Template HasSnaky 7 required_485_i3 envelope_485_i3 := by + refine compose HasSnaky 6 childrenC_485_i3 childrenD_485_i3 children_work_485_i3 (2, 4) + required_485_i3 envelope_485_i3 pivot_mem_485_i3 child_required_sub_485_i3 child_envelope_sub_485_i3 ?_ + intro b hb + exact common_sub_485_i3 (mem_commonEnvelope childrenD_485_i3 b hb) +def required_485_i1 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_485_i1 : Finset Cell := ⟨(([(0, 4), (0, 6), (0, 7), (0, 8), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4), (7, 5), (7, 6), (7, 7), (8, 5), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_485_i1 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) required_81), (placed21 1 (0, 2) required_167), required_485_i2, required_485_i3] +def childrenD_485_i1 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) envelope_81), (placed21 1 (0, 2) envelope_167), envelope_485_i2, envelope_485_i3] +theorem common_sub_485_i1 : commonEnvelope childrenD_485_i1 ⊆ insert (4, 5) required_485_i1 := by decide +kernel +theorem child_required_sub_485_i1 : ∀ j, childrenC_485_i1 j ⊆ insert (4, 5) required_485_i1 := by decide +kernel +theorem child_envelope_sub_485_i1 : ∀ j, childrenD_485_i1 j ⊆ envelope_485_i1 := by decide +kernel +theorem pivot_mem_485_i1 : (4, 5) ∈ envelope_485_i1 := by decide +kernel +theorem children_work_485_i1 : ∀ j, Template HasSnaky 10 (childrenC_485_i1 j) (childrenD_485_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_81 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_167 1 (0, 2)).mono (by decide +kernel) + · exact row_works_485_i2.mono (by decide +kernel) + · exact row_works_485_i3.mono (by decide +kernel) +theorem row_works_485_i1 : Template HasSnaky 11 required_485_i1 envelope_485_i1 := by + refine compose HasSnaky 10 childrenC_485_i1 childrenD_485_i1 children_work_485_i1 (4, 5) + required_485_i1 envelope_485_i1 pivot_mem_485_i1 child_required_sub_485_i1 child_envelope_sub_485_i1 ?_ + intro b hb + exact common_sub_485_i1 (mem_commonEnvelope childrenD_485_i1 b hb) +def required_485 : Finset Cell := ⟨(([(1, 2), (1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_485 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 6), (0, 7), (0, 8), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4), (7, 5), (7, 6), (7, 7), (8, 5), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_485 : Fin 5 → Finset Cell := ![(placed21 3 (0, 5) required_313), (placed21 0 (0, 1) required_469), required_485_i0, required_485_i1, required_484] +def childrenD_485 : Fin 5 → Finset Cell := ![(placed21 3 (0, 5) envelope_313), (placed21 0 (0, 1) envelope_469), envelope_485_i0, envelope_485_i1, envelope_484] +theorem common_sub_485 : commonEnvelope childrenD_485 ⊆ insert (4, 3) required_485 := by decide +kernel +theorem child_required_sub_485 : ∀ j, childrenC_485 j ⊆ insert (4, 3) required_485 := by decide +kernel +theorem child_envelope_sub_485 : ∀ j, childrenD_485 j ⊆ envelope_485 := by decide +kernel +theorem pivot_mem_485 : (4, 3) ∈ envelope_485 := by decide +kernel +theorem children_work_485 : ∀ j, Template HasSnaky 11 (childrenC_485 j) (childrenD_485 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_313 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_469 0 (0, 1)).mono (by decide +kernel) + · exact row_works_485_i0.mono (by decide +kernel) + · exact row_works_485_i1.mono (by decide +kernel) + · exact row_works_484.mono (by decide +kernel) +theorem row_works_485 : Template HasSnaky 12 required_485 envelope_485 := by + refine compose HasSnaky 11 childrenC_485 childrenD_485 children_work_485 (4, 3) + required_485 envelope_485 pivot_mem_485 child_required_sub_485 child_envelope_sub_485 ?_ + intro b hb + exact common_sub_485 (mem_commonEnvelope childrenD_485 b hb) +def required_489_i1 : Finset Cell := ⟨(([(3, 8), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_489_i1 : Finset Cell := ⟨(([(2, 8), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 7), (6, 8), (6, 9), (6, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_489_i1 : Fin 4 → Finset Cell := ![(placed21 0 (4, 4) required_10), (placed21 6 (5, 8) required_44), (placed21 0 (4, 4) required_63), (placed21 3 (2, 8) required_486)] +def childrenD_489_i1 : Fin 4 → Finset Cell := ![(placed21 0 (4, 4) envelope_10), (placed21 6 (5, 8) envelope_44), (placed21 0 (4, 4) envelope_63), (placed21 3 (2, 8) envelope_486)] +theorem common_sub_489_i1 : commonEnvelope childrenD_489_i1 ⊆ insert (5, 7) required_489_i1 := by decide +kernel +theorem child_required_sub_489_i1 : ∀ j, childrenC_489_i1 j ⊆ insert (5, 7) required_489_i1 := by decide +kernel +theorem child_envelope_sub_489_i1 : ∀ j, childrenD_489_i1 j ⊆ envelope_489_i1 := by decide +kernel +theorem pivot_mem_489_i1 : (5, 7) ∈ envelope_489_i1 := by decide +kernel +theorem children_work_489_i1 : ∀ j, Template HasSnaky 6 (childrenC_489_i1 j) (childrenD_489_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 0 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_44 6 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_63 0 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_486 3 (2, 8)).mono (by decide +kernel) +theorem row_works_489_i1 : Template HasSnaky 7 required_489_i1 envelope_489_i1 := by + refine compose HasSnaky 6 childrenC_489_i1 childrenD_489_i1 children_work_489_i1 (5, 7) + required_489_i1 envelope_489_i1 pivot_mem_489_i1 child_required_sub_489_i1 child_envelope_sub_489_i1 ?_ + intro b hb + exact common_sub_489_i1 (mem_commonEnvelope childrenD_489_i1 b hb) +def required_489_i0 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 8), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_489_i0 : Finset Cell := ⟨(([(2, 5), (2, 8), (3, 5), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_489_i0 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) required_5), required_489_i1] +def childrenD_489_i0 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) envelope_5), envelope_489_i1] +theorem common_sub_489_i0 : commonEnvelope childrenD_489_i0 ⊆ insert (5, 6) required_489_i0 := by decide +kernel +theorem child_required_sub_489_i0 : ∀ j, childrenC_489_i0 j ⊆ insert (5, 6) required_489_i0 := by decide +kernel +theorem child_envelope_sub_489_i0 : ∀ j, childrenD_489_i0 j ⊆ envelope_489_i0 := by decide +kernel +theorem pivot_mem_489_i0 : (5, 6) ∈ envelope_489_i0 := by decide +kernel +theorem children_work_489_i0 : ∀ j, Template HasSnaky 7 (childrenC_489_i0 j) (childrenD_489_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (2, 5)).mono (by decide +kernel) + · exact row_works_489_i1.mono (by decide +kernel) +theorem row_works_489_i0 : Template HasSnaky 8 required_489_i0 envelope_489_i0 := by + refine compose HasSnaky 7 childrenC_489_i0 childrenD_489_i0 children_work_489_i0 (5, 6) + required_489_i0 envelope_489_i0 pivot_mem_489_i0 child_required_sub_489_i0 child_envelope_sub_489_i0 ?_ + intro b hb + exact common_sub_489_i0 (mem_commonEnvelope childrenD_489_i0 b hb) +def required_489_i2 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 8), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_489_i2 : Finset Cell := ⟨(([(0, 7), (0, 9), (1, 7), (1, 8), (1, 9), (2, 5), (2, 7), (2, 8), (2, 9), (3, 5), (3, 8), (3, 9), (3, 10), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 7), (8, 8), (8, 9), (9, 7), (9, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_489_i2 : Fin 4 → Finset Cell := ![(placed21 0 (2, 4) required_81), (placed21 0 (2, 4) required_167), (placed21 5 (8, 6) required_481), (placed21 1 (0, 4) required_488)] +def childrenD_489_i2 : Fin 4 → Finset Cell := ![(placed21 0 (2, 4) envelope_81), (placed21 0 (2, 4) envelope_167), (placed21 5 (8, 6) envelope_481), (placed21 1 (0, 4) envelope_488)] +theorem common_sub_489_i2 : commonEnvelope childrenD_489_i2 ⊆ insert (5, 8) required_489_i2 := by decide +kernel +theorem child_required_sub_489_i2 : ∀ j, childrenC_489_i2 j ⊆ insert (5, 8) required_489_i2 := by decide +kernel +theorem child_envelope_sub_489_i2 : ∀ j, childrenD_489_i2 j ⊆ envelope_489_i2 := by decide +kernel +theorem pivot_mem_489_i2 : (5, 8) ∈ envelope_489_i2 := by decide +kernel +theorem children_work_489_i2 : ∀ j, Template HasSnaky 10 (childrenC_489_i2 j) (childrenD_489_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_81 0 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_167 0 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_481 5 (8, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_488 1 (0, 4)).mono (by decide +kernel) +theorem row_works_489_i2 : Template HasSnaky 11 required_489_i2 envelope_489_i2 := by + refine compose HasSnaky 10 childrenC_489_i2 childrenD_489_i2 children_work_489_i2 (5, 8) + required_489_i2 envelope_489_i2 pivot_mem_489_i2 child_required_sub_489_i2 child_envelope_sub_489_i2 ?_ + intro b hb + exact common_sub_489_i2 (mem_commonEnvelope childrenD_489_i2 b hb) +def required_489 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_489 : Finset Cell := ⟨(([(0, 7), (0, 9), (1, 4), (1, 6), (1, 7), (1, 8), (1, 9), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 5), (3, 7), (3, 8), (3, 9), (3, 10), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 6), (8, 7), (8, 8), (8, 9), (9, 7), (9, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_489 : Fin 4 → Finset Cell := ![(placed21 2 (5, 4) required_313), (placed21 4 (1, 10) required_470), required_489_i0, required_489_i2] +def childrenD_489 : Fin 4 → Finset Cell := ![(placed21 2 (5, 4) envelope_313), (placed21 4 (1, 10) envelope_470), envelope_489_i0, envelope_489_i2] +theorem common_sub_489 : commonEnvelope childrenD_489 ⊆ insert (3, 8) required_489 := by decide +kernel +theorem child_required_sub_489 : ∀ j, childrenC_489 j ⊆ insert (3, 8) required_489 := by decide +kernel +theorem child_envelope_sub_489 : ∀ j, childrenD_489 j ⊆ envelope_489 := by decide +kernel +theorem pivot_mem_489 : (3, 8) ∈ envelope_489 := by decide +kernel +theorem children_work_489 : ∀ j, Template HasSnaky 11 (childrenC_489 j) (childrenD_489 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_313 2 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_470 4 (1, 10)).mono (by decide +kernel) + · exact row_works_489_i0.mono (by decide +kernel) + · exact row_works_489_i2.mono (by decide +kernel) +theorem row_works_489 : Template HasSnaky 12 required_489 envelope_489 := by + refine compose HasSnaky 11 childrenC_489 childrenD_489 children_work_489 (3, 8) + required_489 envelope_489 pivot_mem_489 child_required_sub_489 child_envelope_sub_489 ?_ + intro b hb + exact common_sub_489 (mem_commonEnvelope childrenD_489 b hb) +def required_543_i1 : Finset Cell := ⟨(([(2, 6), (2, 7), (2, 8), (2, 9), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i1 : Finset Cell := ⟨(([(1, 6), (1, 7), (1, 9), (1, 10), (1, 11), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 7), (3, 8), (3, 10), (3, 11), (3, 12), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i1 : Fin 2 → Finset Cell := ![(placed21 0 (4, 3) required_261), (placed21 1 (1, 6) required_370)] +def childrenD_543_i1 : Fin 2 → Finset Cell := ![(placed21 0 (4, 3) envelope_261), (placed21 1 (1, 6) envelope_370)] +theorem common_sub_543_i1 : commonEnvelope childrenD_543_i1 ⊆ insert (5, 7) required_543_i1 := by decide +kernel +theorem child_required_sub_543_i1 : ∀ j, childrenC_543_i1 j ⊆ insert (5, 7) required_543_i1 := by decide +kernel +theorem child_envelope_sub_543_i1 : ∀ j, childrenD_543_i1 j ⊆ envelope_543_i1 := by decide +kernel +theorem pivot_mem_543_i1 : (5, 7) ∈ envelope_543_i1 := by decide +kernel +theorem children_work_543_i1 : ∀ j, Template HasSnaky 5 (childrenC_543_i1 j) (childrenD_543_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_261 0 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_370 1 (1, 6)).mono (by decide +kernel) +theorem row_works_543_i1 : Template HasSnaky 6 required_543_i1 envelope_543_i1 := by + refine compose HasSnaky 5 childrenC_543_i1 childrenD_543_i1 children_work_543_i1 (5, 7) + required_543_i1 envelope_543_i1 pivot_mem_543_i1 child_required_sub_543_i1 child_envelope_sub_543_i1 ?_ + intro b hb + exact common_sub_543_i1 (mem_commonEnvelope childrenD_543_i1 b hb) +def required_543_i6 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (2, 6), (2, 7), (4, 3), (4, 4), (4, 5), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i6 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (2, 4), (2, 5), (2, 6), (2, 7), (3, 5), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i6 : Fin 2 → Finset Cell := ![(placed21 0 (4, 3) required_154), (placed21 0 (1, 3) required_170)] +def childrenD_543_i6 : Fin 2 → Finset Cell := ![(placed21 0 (4, 3) envelope_154), (placed21 0 (1, 3) envelope_170)] +theorem common_sub_543_i6 : commonEnvelope childrenD_543_i6 ⊆ insert (5, 5) required_543_i6 := by decide +kernel +theorem child_required_sub_543_i6 : ∀ j, childrenC_543_i6 j ⊆ insert (5, 5) required_543_i6 := by decide +kernel +theorem child_envelope_sub_543_i6 : ∀ j, childrenD_543_i6 j ⊆ envelope_543_i6 := by decide +kernel +theorem pivot_mem_543_i6 : (5, 5) ∈ envelope_543_i6 := by decide +kernel +theorem children_work_543_i6 : ∀ j, Template HasSnaky 2 (childrenC_543_i6 j) (childrenD_543_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_154 0 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_170 0 (1, 3)).mono (by decide +kernel) +theorem row_works_543_i6 : Template HasSnaky 3 required_543_i6 envelope_543_i6 := by + refine compose HasSnaky 2 childrenC_543_i6 childrenD_543_i6 children_work_543_i6 (5, 5) + required_543_i6 envelope_543_i6 pivot_mem_543_i6 child_required_sub_543_i6 child_envelope_sub_543_i6 ?_ + intro b hb + exact common_sub_543_i6 (mem_commonEnvelope childrenD_543_i6 b hb) +def required_543_i5 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (2, 6), (2, 7), (3, 7), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i5 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (2, 4), (2, 5), (2, 6), (2, 7), (3, 5), (3, 7), (4, 3), (4, 4), (4, 5), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i5 : Fin 2 → Finset Cell := ![(placed21 6 (5, 7) required_1), required_543_i6] +def childrenD_543_i5 : Fin 2 → Finset Cell := ![(placed21 6 (5, 7) envelope_1), envelope_543_i6] +theorem common_sub_543_i5 : commonEnvelope childrenD_543_i5 ⊆ insert (5, 7) required_543_i5 := by decide +kernel +theorem child_required_sub_543_i5 : ∀ j, childrenC_543_i5 j ⊆ insert (5, 7) required_543_i5 := by decide +kernel +theorem child_envelope_sub_543_i5 : ∀ j, childrenD_543_i5 j ⊆ envelope_543_i5 := by decide +kernel +theorem pivot_mem_543_i5 : (5, 7) ∈ envelope_543_i5 := by decide +kernel +theorem children_work_543_i5 : ∀ j, Template HasSnaky 3 (childrenC_543_i5 j) (childrenD_543_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 6 (5, 7)).mono (by decide +kernel) + · exact row_works_543_i6.mono (by decide +kernel) +theorem row_works_543_i5 : Template HasSnaky 4 required_543_i5 envelope_543_i5 := by + refine compose HasSnaky 3 childrenC_543_i5 childrenD_543_i5 children_work_543_i5 (5, 7) + required_543_i5 envelope_543_i5 pivot_mem_543_i5 child_required_sub_543_i5 child_envelope_sub_543_i5 ?_ + intro b hb + exact common_sub_543_i5 (mem_commonEnvelope childrenD_543_i5 b hb) +def required_543_i4 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i4 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 5), (3, 7), (3, 8), (3, 10), (3, 11), (3, 12), (4, 3), (4, 4), (4, 5), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i4 : Fin 2 → Finset Cell := ![(placed21 0 (2, 7) required_16), required_543_i5] +def childrenD_543_i4 : Fin 2 → Finset Cell := ![(placed21 0 (2, 7) envelope_16), envelope_543_i5] +theorem common_sub_543_i4 : commonEnvelope childrenD_543_i4 ⊆ insert (3, 7) required_543_i4 := by decide +kernel +theorem child_required_sub_543_i4 : ∀ j, childrenC_543_i4 j ⊆ insert (3, 7) required_543_i4 := by decide +kernel +theorem child_envelope_sub_543_i4 : ∀ j, childrenD_543_i4 j ⊆ envelope_543_i4 := by decide +kernel +theorem pivot_mem_543_i4 : (3, 7) ∈ envelope_543_i4 := by decide +kernel +theorem children_work_543_i4 : ∀ j, Template HasSnaky 4 (childrenC_543_i4 j) (childrenD_543_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_16 0 (2, 7)).mono (by decide +kernel) + · exact row_works_543_i5.mono (by decide +kernel) +theorem row_works_543_i4 : Template HasSnaky 5 required_543_i4 envelope_543_i4 := by + refine compose HasSnaky 4 childrenC_543_i4 childrenD_543_i4 children_work_543_i4 (3, 7) + required_543_i4 envelope_543_i4 pivot_mem_543_i4 child_required_sub_543_i4 child_envelope_sub_543_i4 ?_ + intro b hb + exact common_sub_543_i4 (mem_commonEnvelope childrenD_543_i4 b hb) +def required_543_i3 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i3 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 5), (3, 7), (3, 8), (3, 10), (3, 11), (3, 12), (4, 3), (4, 4), (4, 5), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i3 : Fin 2 → Finset Cell := ![(placed21 7 (2, 10) required_4), required_543_i4] +def childrenD_543_i3 : Fin 2 → Finset Cell := ![(placed21 7 (2, 10) envelope_4), envelope_543_i4] +theorem common_sub_543_i3 : commonEnvelope childrenD_543_i3 ⊆ insert (1, 6) required_543_i3 := by decide +kernel +theorem child_required_sub_543_i3 : ∀ j, childrenC_543_i3 j ⊆ insert (1, 6) required_543_i3 := by decide +kernel +theorem child_envelope_sub_543_i3 : ∀ j, childrenD_543_i3 j ⊆ envelope_543_i3 := by decide +kernel +theorem pivot_mem_543_i3 : (1, 6) ∈ envelope_543_i3 := by decide +kernel +theorem children_work_543_i3 : ∀ j, Template HasSnaky 5 (childrenC_543_i3 j) (childrenD_543_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (2, 10)).mono (by decide +kernel) + · exact row_works_543_i4.mono (by decide +kernel) +theorem row_works_543_i3 : Template HasSnaky 6 required_543_i3 envelope_543_i3 := by + refine compose HasSnaky 5 childrenC_543_i3 childrenD_543_i3 children_work_543_i3 (1, 6) + required_543_i3 envelope_543_i3 pivot_mem_543_i3 child_required_sub_543_i3 child_envelope_sub_543_i3 ?_ + intro b hb + exact common_sub_543_i3 (mem_commonEnvelope childrenD_543_i3 b hb) +def required_543_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 6), (2, 7), (2, 8), (2, 9), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i2 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (1, 7), (1, 9), (1, 10), (1, 11), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 5), (3, 7), (3, 8), (3, 10), (3, 11), (3, 12), (4, 3), (4, 4), (4, 5), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i2 : Fin 2 → Finset Cell := ![(placed21 2 (2, 6) required_6), required_543_i3] +def childrenD_543_i2 : Fin 2 → Finset Cell := ![(placed21 2 (2, 6) envelope_6), envelope_543_i3] +theorem common_sub_543_i2 : commonEnvelope childrenD_543_i2 ⊆ insert (2, 10) required_543_i2 := by decide +kernel +theorem child_required_sub_543_i2 : ∀ j, childrenC_543_i2 j ⊆ insert (2, 10) required_543_i2 := by decide +kernel +theorem child_envelope_sub_543_i2 : ∀ j, childrenD_543_i2 j ⊆ envelope_543_i2 := by decide +kernel +theorem pivot_mem_543_i2 : (2, 10) ∈ envelope_543_i2 := by decide +kernel +theorem children_work_543_i2 : ∀ j, Template HasSnaky 6 (childrenC_543_i2 j) (childrenD_543_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 2 (2, 6)).mono (by decide +kernel) + · exact row_works_543_i3.mono (by decide +kernel) +theorem row_works_543_i2 : Template HasSnaky 7 required_543_i2 envelope_543_i2 := by + refine compose HasSnaky 6 childrenC_543_i2 childrenD_543_i2 children_work_543_i2 (2, 10) + required_543_i2 envelope_543_i2 pivot_mem_543_i2 child_required_sub_543_i2 child_envelope_sub_543_i2 ?_ + intro b hb + exact common_sub_543_i2 (mem_commonEnvelope childrenD_543_i2 b hb) +def required_543_i7 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 6), (2, 7), (2, 8), (2, 9), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i7 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (1, 7), (1, 9), (1, 10), (1, 11), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 2), (3, 3), (3, 7), (3, 8), (3, 10), (3, 11), (3, 12), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i7 : Fin 2 → Finset Cell := ![(placed21 2 (2, 6) required_6), (placed21 0 (1, 2) required_539)] +def childrenD_543_i7 : Fin 2 → Finset Cell := ![(placed21 2 (2, 6) envelope_6), (placed21 0 (1, 2) envelope_539)] +theorem common_sub_543_i7 : commonEnvelope childrenD_543_i7 ⊆ insert (2, 10) required_543_i7 := by decide +kernel +theorem child_required_sub_543_i7 : ∀ j, childrenC_543_i7 j ⊆ insert (2, 10) required_543_i7 := by decide +kernel +theorem child_envelope_sub_543_i7 : ∀ j, childrenD_543_i7 j ⊆ envelope_543_i7 := by decide +kernel +theorem pivot_mem_543_i7 : (2, 10) ∈ envelope_543_i7 := by decide +kernel +theorem children_work_543_i7 : ∀ j, Template HasSnaky 9 (childrenC_543_i7 j) (childrenD_543_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 2 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_539 0 (1, 2)).mono (by decide +kernel) +theorem row_works_543_i7 : Template HasSnaky 10 required_543_i7 envelope_543_i7 := by + refine compose HasSnaky 9 childrenC_543_i7 childrenD_543_i7 children_work_543_i7 (2, 10) + required_543_i7 envelope_543_i7 pivot_mem_543_i7 child_required_sub_543_i7 child_envelope_sub_543_i7 ?_ + intro b hb + exact common_sub_543_i7 (mem_commonEnvelope childrenD_543_i7 b hb) +def required_543_i8 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 6), (2, 7), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i8 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i8 : Fin 3 → Finset Cell := ![(placed21 0 (4, 2) required_7), (placed21 0 (1, 2) required_86), (placed21 0 (1, 2) required_542)] +def childrenD_543_i8 : Fin 3 → Finset Cell := ![(placed21 0 (4, 2) envelope_7), (placed21 0 (1, 2) envelope_86), (placed21 0 (1, 2) envelope_542)] +theorem common_sub_543_i8 : commonEnvelope childrenD_543_i8 ⊆ insert (4, 6) required_543_i8 := by decide +kernel +theorem child_required_sub_543_i8 : ∀ j, childrenC_543_i8 j ⊆ insert (4, 6) required_543_i8 := by decide +kernel +theorem child_envelope_sub_543_i8 : ∀ j, childrenD_543_i8 j ⊆ envelope_543_i8 := by decide +kernel +theorem pivot_mem_543_i8 : (4, 6) ∈ envelope_543_i8 := by decide +kernel +theorem children_work_543_i8 : ∀ j, Template HasSnaky 7 (childrenC_543_i8 j) (childrenD_543_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_86 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_542 0 (1, 2)).mono (by decide +kernel) +theorem row_works_543_i8 : Template HasSnaky 8 required_543_i8 envelope_543_i8 := by + refine compose HasSnaky 7 childrenC_543_i8 childrenD_543_i8 children_work_543_i8 (4, 6) + required_543_i8 envelope_543_i8 pivot_mem_543_i8 child_required_sub_543_i8 child_envelope_sub_543_i8 ?_ + intro b hb + exact common_sub_543_i8 (mem_commonEnvelope childrenD_543_i8 b hb) +def required_543_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 6), (2, 7), (2, 8), (2, 9), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (1, 7), (1, 9), (1, 10), (1, 11), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 2), (3, 3), (3, 5), (3, 7), (3, 8), (3, 10), (3, 11), (3, 12), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 2), (7, 3), (7, 4), (8, 2), (8, 3), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i0 : Fin 7 → Finset Cell := ![(placed21 0 (1, 2) required_433), required_543_i1, required_543_i2, required_543_i7, (placed21 0 (1, 0) required_540), (placed21 0 (1, 2) required_541), required_543_i8] +def childrenD_543_i0 : Fin 7 → Finset Cell := ![(placed21 0 (1, 2) envelope_433), envelope_543_i1, envelope_543_i2, envelope_543_i7, (placed21 0 (1, 0) envelope_540), (placed21 0 (1, 2) envelope_541), envelope_543_i8] +theorem common_sub_543_i0 : commonEnvelope childrenD_543_i0 ⊆ insert (4, 5) required_543_i0 := by decide +kernel +theorem child_required_sub_543_i0 : ∀ j, childrenC_543_i0 j ⊆ insert (4, 5) required_543_i0 := by decide +kernel +theorem child_envelope_sub_543_i0 : ∀ j, childrenD_543_i0 j ⊆ envelope_543_i0 := by decide +kernel +theorem pivot_mem_543_i0 : (4, 5) ∈ envelope_543_i0 := by decide +kernel +theorem children_work_543_i0 : ∀ j, Template HasSnaky 10 (childrenC_543_i0 j) (childrenD_543_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_433 0 (1, 2)).mono (by decide +kernel) + · exact row_works_543_i1.mono (by decide +kernel) + · exact row_works_543_i2.mono (by decide +kernel) + · exact row_works_543_i7.mono (by decide +kernel) + · exact (placed21_template row_works_540 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_541 0 (1, 2)).mono (by decide +kernel) + · exact row_works_543_i8.mono (by decide +kernel) +theorem row_works_543_i0 : Template HasSnaky 11 required_543_i0 envelope_543_i0 := by + refine compose HasSnaky 10 childrenC_543_i0 childrenD_543_i0 children_work_543_i0 (4, 5) + required_543_i0 envelope_543_i0 pivot_mem_543_i0 child_required_sub_543_i0 child_envelope_sub_543_i0 ?_ + intro b hb + exact common_sub_543_i0 (mem_commonEnvelope childrenD_543_i0 b hb) +def required_543_i10 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 6), (2, 7), (2, 8), (3, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i10 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 8), (3, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i10 : Fin 2 → Finset Cell := ![(placed21 7 (2, 7) required_3), (placed21 1 (2, 5) required_5)] +def childrenD_543_i10 : Fin 2 → Finset Cell := ![(placed21 7 (2, 7) envelope_3), (placed21 1 (2, 5) envelope_5)] +theorem common_sub_543_i10 : commonEnvelope childrenD_543_i10 ⊆ insert (2, 5) required_543_i10 := by decide +kernel +theorem child_required_sub_543_i10 : ∀ j, childrenC_543_i10 j ⊆ insert (2, 5) required_543_i10 := by decide +kernel +theorem child_envelope_sub_543_i10 : ∀ j, childrenD_543_i10 j ⊆ envelope_543_i10 := by decide +kernel +theorem pivot_mem_543_i10 : (2, 5) ∈ envelope_543_i10 := by decide +kernel +theorem children_work_543_i10 : ∀ j, Template HasSnaky 1 (childrenC_543_i10 j) (childrenD_543_i10 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 7 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_5 1 (2, 5)).mono (by decide +kernel) +theorem row_works_543_i10 : Template HasSnaky 2 required_543_i10 envelope_543_i10 := by + refine compose HasSnaky 1 childrenC_543_i10 childrenD_543_i10 children_work_543_i10 (2, 5) + required_543_i10 envelope_543_i10 pivot_mem_543_i10 child_required_sub_543_i10 child_envelope_sub_543_i10 ?_ + intro b hb + exact common_sub_543_i10 (mem_commonEnvelope childrenD_543_i10 b hb) +def required_543_i9 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 6), (2, 7), (2, 8), (2, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543_i9 : Finset Cell := ⟨(([(0, 7), (1, 3), (1, 4), (1, 6), (1, 7), (1, 9), (1, 10), (1, 11), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 7), (3, 8), (3, 9), (4, 8), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543_i9 : Fin 2 → Finset Cell := ![(placed21 1 (0, 6) required_278), required_543_i10] +def childrenD_543_i9 : Fin 2 → Finset Cell := ![(placed21 1 (0, 6) envelope_278), envelope_543_i10] +theorem common_sub_543_i9 : commonEnvelope childrenD_543_i9 ⊆ insert (3, 8) required_543_i9 := by decide +kernel +theorem child_required_sub_543_i9 : ∀ j, childrenC_543_i9 j ⊆ insert (3, 8) required_543_i9 := by decide +kernel +theorem child_envelope_sub_543_i9 : ∀ j, childrenD_543_i9 j ⊆ envelope_543_i9 := by decide +kernel +theorem pivot_mem_543_i9 : (3, 8) ∈ envelope_543_i9 := by decide +kernel +theorem children_work_543_i9 : ∀ j, Template HasSnaky 5 (childrenC_543_i9 j) (childrenD_543_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_278 1 (0, 6)).mono (by decide +kernel) + · exact row_works_543_i10.mono (by decide +kernel) +theorem row_works_543_i9 : Template HasSnaky 6 required_543_i9 envelope_543_i9 := by + refine compose HasSnaky 5 childrenC_543_i9 childrenD_543_i9 children_work_543_i9 (3, 8) + required_543_i9 envelope_543_i9 pivot_mem_543_i9 child_required_sub_543_i9 child_envelope_sub_543_i9 ?_ + intro b hb + exact common_sub_543_i9 (mem_commonEnvelope childrenD_543_i9 b hb) +def required_543 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 6), (2, 7), (2, 8), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_543 : Finset Cell := ⟨(([(0, 7), (1, 3), (1, 4), (1, 6), (1, 7), (1, 9), (1, 10), (1, 11), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 2), (3, 3), (3, 5), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 2), (7, 3), (7, 4), (8, 2), (8, 3), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_543 : Fin 4 → Finset Cell := ![(placed21 1 (1, 6) required_8), (placed21 0 (1, 3) required_280), required_543_i0, required_543_i9] +def childrenD_543 : Fin 4 → Finset Cell := ![(placed21 1 (1, 6) envelope_8), (placed21 0 (1, 3) envelope_280), envelope_543_i0, envelope_543_i9] +theorem common_sub_543 : commonEnvelope childrenD_543 ⊆ insert (2, 9) required_543 := by decide +kernel +theorem child_required_sub_543 : ∀ j, childrenC_543 j ⊆ insert (2, 9) required_543 := by decide +kernel +theorem child_envelope_sub_543 : ∀ j, childrenD_543 j ⊆ envelope_543 := by decide +kernel +theorem pivot_mem_543 : (2, 9) ∈ envelope_543 := by decide +kernel +theorem children_work_543 : ∀ j, Template HasSnaky 11 (childrenC_543 j) (childrenD_543 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_280 0 (1, 3)).mono (by decide +kernel) + · exact row_works_543_i0.mono (by decide +kernel) + · exact row_works_543_i9.mono (by decide +kernel) +theorem row_works_543 : Template HasSnaky 12 required_543 envelope_543 := by + refine compose HasSnaky 11 childrenC_543 childrenD_543 children_work_543 (2, 9) + required_543 envelope_543 pivot_mem_543 child_required_sub_543 child_envelope_sub_543 ?_ + intro b hb + exact common_sub_543 (mem_commonEnvelope childrenD_543 b hb) +def height_428 : ℕ := 12 +def childrenH_428 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_427] +theorem height_exact_428 : height_428 = 1 + Finset.univ.sup childrenH_428 := by decide +kernel +theorem required_origin_428 : ∀ x ∈ required_428, + (∃ j, x ∈ childrenC_428 j) ∨ ∀ j, x ∈ childrenD_428 j := by decide +kernel +theorem required_exact_428 : required_428 = + ((Finset.univ.biUnion childrenC_428) ∪ commonEnvelope childrenD_428).erase (1, 4) := by + exact required_eq_combination childrenC_428 childrenD_428 (1, 4) required_428 + (by decide +kernel) child_required_sub_428 common_sub_428 required_origin_428 +theorem envelope_origin_428 : ∀ x ∈ envelope_428, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_428 j := by decide +kernel +theorem envelope_exact_428 : envelope_428 = + insert (1, 4) (Finset.univ.biUnion childrenD_428) := by + exact envelope_eq_combination childrenD_428 (1, 4) envelope_428 + pivot_mem_428 child_envelope_sub_428 envelope_origin_428 +def checked_428 : CheckedCard where + required := required_428 + envelope := envelope_428 + height := height_428 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_428 +def height_485_i0 : ℕ := 11 +def childrenH_485_i0 : Fin 4 → ℕ := ![height_81, height_204, height_353, height_481] +theorem height_exact_485_i0 : height_485_i0 = 1 + Finset.univ.sup childrenH_485_i0 := by decide +kernel +theorem required_origin_485_i0 : ∀ x ∈ required_485_i0, + (∃ j, x ∈ childrenC_485_i0 j) ∨ ∀ j, x ∈ childrenD_485_i0 j := by decide +kernel +theorem required_exact_485_i0 : required_485_i0 = + ((Finset.univ.biUnion childrenC_485_i0) ∪ commonEnvelope childrenD_485_i0).erase (4, 5) := by + exact required_eq_combination childrenC_485_i0 childrenD_485_i0 (4, 5) required_485_i0 + (by decide +kernel) child_required_sub_485_i0 common_sub_485_i0 required_origin_485_i0 +theorem envelope_origin_485_i0 : ∀ x ∈ envelope_485_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_485_i0 j := by decide +kernel +theorem envelope_exact_485_i0 : envelope_485_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_485_i0) := by + exact envelope_eq_combination childrenD_485_i0 (4, 5) envelope_485_i0 + pivot_mem_485_i0 child_envelope_sub_485_i0 envelope_origin_485_i0 +def checked_485_i0 : CheckedCard where + required := required_485_i0 + envelope := envelope_485_i0 + height := height_485_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_485_i0 +def height_485_i2 : ℕ := 10 +def childrenH_485_i2 : Fin 6 → ℕ := ![height_14, height_189, height_192, height_193, height_457, height_477] +theorem height_exact_485_i2 : height_485_i2 = 1 + Finset.univ.sup childrenH_485_i2 := by decide +kernel +theorem required_origin_485_i2 : ∀ x ∈ required_485_i2, + (∃ j, x ∈ childrenC_485_i2 j) ∨ ∀ j, x ∈ childrenD_485_i2 j := by decide +kernel +theorem required_exact_485_i2 : required_485_i2 = + ((Finset.univ.biUnion childrenC_485_i2) ∪ commonEnvelope childrenD_485_i2).erase (4, 4) := by + exact required_eq_combination childrenC_485_i2 childrenD_485_i2 (4, 4) required_485_i2 + (by decide +kernel) child_required_sub_485_i2 common_sub_485_i2 required_origin_485_i2 +theorem envelope_origin_485_i2 : ∀ x ∈ envelope_485_i2, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_485_i2 j := by decide +kernel +theorem envelope_exact_485_i2 : envelope_485_i2 = + insert (4, 4) (Finset.univ.biUnion childrenD_485_i2) := by + exact envelope_eq_combination childrenD_485_i2 (4, 4) envelope_485_i2 + pivot_mem_485_i2 child_envelope_sub_485_i2 envelope_origin_485_i2 +def checked_485_i2 : CheckedCard where + required := required_485_i2 + envelope := envelope_485_i2 + height := height_485_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_485_i2 +def height_485_i3 : ℕ := 7 +def childrenH_485_i3 : Fin 2 → ℕ := ![height_166, height_314] +theorem height_exact_485_i3 : height_485_i3 = 1 + Finset.univ.sup childrenH_485_i3 := by decide +kernel +theorem required_origin_485_i3 : ∀ x ∈ required_485_i3, + (∃ j, x ∈ childrenC_485_i3 j) ∨ ∀ j, x ∈ childrenD_485_i3 j := by decide +kernel +theorem required_exact_485_i3 : required_485_i3 = + ((Finset.univ.biUnion childrenC_485_i3) ∪ commonEnvelope childrenD_485_i3).erase (2, 4) := by + exact required_eq_combination childrenC_485_i3 childrenD_485_i3 (2, 4) required_485_i3 + (by decide +kernel) child_required_sub_485_i3 common_sub_485_i3 required_origin_485_i3 +theorem envelope_origin_485_i3 : ∀ x ∈ envelope_485_i3, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_485_i3 j := by decide +kernel +theorem envelope_exact_485_i3 : envelope_485_i3 = + insert (2, 4) (Finset.univ.biUnion childrenD_485_i3) := by + exact envelope_eq_combination childrenD_485_i3 (2, 4) envelope_485_i3 + pivot_mem_485_i3 child_envelope_sub_485_i3 envelope_origin_485_i3 +def checked_485_i3 : CheckedCard where + required := required_485_i3 + envelope := envelope_485_i3 + height := height_485_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_485_i3 +def height_485_i1 : ℕ := 11 +def childrenH_485_i1 : Fin 4 → ℕ := ![height_81, height_167, height_485_i2, height_485_i3] +theorem height_exact_485_i1 : height_485_i1 = 1 + Finset.univ.sup childrenH_485_i1 := by decide +kernel +theorem required_origin_485_i1 : ∀ x ∈ required_485_i1, + (∃ j, x ∈ childrenC_485_i1 j) ∨ ∀ j, x ∈ childrenD_485_i1 j := by decide +kernel +theorem required_exact_485_i1 : required_485_i1 = + ((Finset.univ.biUnion childrenC_485_i1) ∪ commonEnvelope childrenD_485_i1).erase (4, 5) := by + exact required_eq_combination childrenC_485_i1 childrenD_485_i1 (4, 5) required_485_i1 + (by decide +kernel) child_required_sub_485_i1 common_sub_485_i1 required_origin_485_i1 +theorem envelope_origin_485_i1 : ∀ x ∈ envelope_485_i1, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_485_i1 j := by decide +kernel +theorem envelope_exact_485_i1 : envelope_485_i1 = + insert (4, 5) (Finset.univ.biUnion childrenD_485_i1) := by + exact envelope_eq_combination childrenD_485_i1 (4, 5) envelope_485_i1 + pivot_mem_485_i1 child_envelope_sub_485_i1 envelope_origin_485_i1 +def checked_485_i1 : CheckedCard where + required := required_485_i1 + envelope := envelope_485_i1 + height := height_485_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_485_i1 +def height_485 : ℕ := 12 +def childrenH_485 : Fin 5 → ℕ := ![height_313, height_469, height_485_i0, height_485_i1, height_484] +theorem height_exact_485 : height_485 = 1 + Finset.univ.sup childrenH_485 := by decide +kernel +theorem required_origin_485 : ∀ x ∈ required_485, + (∃ j, x ∈ childrenC_485 j) ∨ ∀ j, x ∈ childrenD_485 j := by decide +kernel +theorem required_exact_485 : required_485 = + ((Finset.univ.biUnion childrenC_485) ∪ commonEnvelope childrenD_485).erase (4, 3) := by + exact required_eq_combination childrenC_485 childrenD_485 (4, 3) required_485 + (by decide +kernel) child_required_sub_485 common_sub_485 required_origin_485 +theorem envelope_origin_485 : ∀ x ∈ envelope_485, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_485 j := by decide +kernel +theorem envelope_exact_485 : envelope_485 = + insert (4, 3) (Finset.univ.biUnion childrenD_485) := by + exact envelope_eq_combination childrenD_485 (4, 3) envelope_485 + pivot_mem_485 child_envelope_sub_485 envelope_origin_485 +def checked_485 : CheckedCard where + required := required_485 + envelope := envelope_485 + height := height_485 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_485 +def height_489_i1 : ℕ := 7 +def childrenH_489_i1 : Fin 4 → ℕ := ![height_10, height_44, height_63, height_486] +theorem height_exact_489_i1 : height_489_i1 = 1 + Finset.univ.sup childrenH_489_i1 := by decide +kernel +theorem required_origin_489_i1 : ∀ x ∈ required_489_i1, + (∃ j, x ∈ childrenC_489_i1 j) ∨ ∀ j, x ∈ childrenD_489_i1 j := by decide +kernel +theorem required_exact_489_i1 : required_489_i1 = + ((Finset.univ.biUnion childrenC_489_i1) ∪ commonEnvelope childrenD_489_i1).erase (5, 7) := by + exact required_eq_combination childrenC_489_i1 childrenD_489_i1 (5, 7) required_489_i1 + (by decide +kernel) child_required_sub_489_i1 common_sub_489_i1 required_origin_489_i1 +theorem envelope_origin_489_i1 : ∀ x ∈ envelope_489_i1, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_489_i1 j := by decide +kernel +theorem envelope_exact_489_i1 : envelope_489_i1 = + insert (5, 7) (Finset.univ.biUnion childrenD_489_i1) := by + exact envelope_eq_combination childrenD_489_i1 (5, 7) envelope_489_i1 + pivot_mem_489_i1 child_envelope_sub_489_i1 envelope_origin_489_i1 +def checked_489_i1 : CheckedCard where + required := required_489_i1 + envelope := envelope_489_i1 + height := height_489_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_489_i1 +def height_489_i0 : ℕ := 8 +def childrenH_489_i0 : Fin 2 → ℕ := ![height_5, height_489_i1] +theorem height_exact_489_i0 : height_489_i0 = 1 + Finset.univ.sup childrenH_489_i0 := by decide +kernel +theorem required_origin_489_i0 : ∀ x ∈ required_489_i0, + (∃ j, x ∈ childrenC_489_i0 j) ∨ ∀ j, x ∈ childrenD_489_i0 j := by decide +kernel +theorem required_exact_489_i0 : required_489_i0 = + ((Finset.univ.biUnion childrenC_489_i0) ∪ commonEnvelope childrenD_489_i0).erase (5, 6) := by + exact required_eq_combination childrenC_489_i0 childrenD_489_i0 (5, 6) required_489_i0 + (by decide +kernel) child_required_sub_489_i0 common_sub_489_i0 required_origin_489_i0 +theorem envelope_origin_489_i0 : ∀ x ∈ envelope_489_i0, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_489_i0 j := by decide +kernel +theorem envelope_exact_489_i0 : envelope_489_i0 = + insert (5, 6) (Finset.univ.biUnion childrenD_489_i0) := by + exact envelope_eq_combination childrenD_489_i0 (5, 6) envelope_489_i0 + pivot_mem_489_i0 child_envelope_sub_489_i0 envelope_origin_489_i0 +def checked_489_i0 : CheckedCard where + required := required_489_i0 + envelope := envelope_489_i0 + height := height_489_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_489_i0 +def height_489_i2 : ℕ := 11 +def childrenH_489_i2 : Fin 4 → ℕ := ![height_81, height_167, height_481, height_488] +theorem height_exact_489_i2 : height_489_i2 = 1 + Finset.univ.sup childrenH_489_i2 := by decide +kernel +theorem required_origin_489_i2 : ∀ x ∈ required_489_i2, + (∃ j, x ∈ childrenC_489_i2 j) ∨ ∀ j, x ∈ childrenD_489_i2 j := by decide +kernel +theorem required_exact_489_i2 : required_489_i2 = + ((Finset.univ.biUnion childrenC_489_i2) ∪ commonEnvelope childrenD_489_i2).erase (5, 8) := by + exact required_eq_combination childrenC_489_i2 childrenD_489_i2 (5, 8) required_489_i2 + (by decide +kernel) child_required_sub_489_i2 common_sub_489_i2 required_origin_489_i2 +theorem envelope_origin_489_i2 : ∀ x ∈ envelope_489_i2, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_489_i2 j := by decide +kernel +theorem envelope_exact_489_i2 : envelope_489_i2 = + insert (5, 8) (Finset.univ.biUnion childrenD_489_i2) := by + exact envelope_eq_combination childrenD_489_i2 (5, 8) envelope_489_i2 + pivot_mem_489_i2 child_envelope_sub_489_i2 envelope_origin_489_i2 +def checked_489_i2 : CheckedCard where + required := required_489_i2 + envelope := envelope_489_i2 + height := height_489_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_489_i2 +def height_489 : ℕ := 12 +def childrenH_489 : Fin 4 → ℕ := ![height_313, height_470, height_489_i0, height_489_i2] +theorem height_exact_489 : height_489 = 1 + Finset.univ.sup childrenH_489 := by decide +kernel +theorem required_origin_489 : ∀ x ∈ required_489, + (∃ j, x ∈ childrenC_489 j) ∨ ∀ j, x ∈ childrenD_489 j := by decide +kernel +theorem required_exact_489 : required_489 = + ((Finset.univ.biUnion childrenC_489) ∪ commonEnvelope childrenD_489).erase (3, 8) := by + exact required_eq_combination childrenC_489 childrenD_489 (3, 8) required_489 + (by decide +kernel) child_required_sub_489 common_sub_489 required_origin_489 +theorem envelope_origin_489 : ∀ x ∈ envelope_489, + x = (3, 8) ∨ ∃ j, x ∈ childrenD_489 j := by decide +kernel +theorem envelope_exact_489 : envelope_489 = + insert (3, 8) (Finset.univ.biUnion childrenD_489) := by + exact envelope_eq_combination childrenD_489 (3, 8) envelope_489 + pivot_mem_489 child_envelope_sub_489 envelope_origin_489 +def checked_489 : CheckedCard where + required := required_489 + envelope := envelope_489 + height := height_489 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_489 +def height_543_i1 : ℕ := 6 +def childrenH_543_i1 : Fin 2 → ℕ := ![height_261, height_370] +theorem height_exact_543_i1 : height_543_i1 = 1 + Finset.univ.sup childrenH_543_i1 := by decide +kernel +theorem required_origin_543_i1 : ∀ x ∈ required_543_i1, + (∃ j, x ∈ childrenC_543_i1 j) ∨ ∀ j, x ∈ childrenD_543_i1 j := by decide +kernel +theorem required_exact_543_i1 : required_543_i1 = + ((Finset.univ.biUnion childrenC_543_i1) ∪ commonEnvelope childrenD_543_i1).erase (5, 7) := by + exact required_eq_combination childrenC_543_i1 childrenD_543_i1 (5, 7) required_543_i1 + (by decide +kernel) child_required_sub_543_i1 common_sub_543_i1 required_origin_543_i1 +theorem envelope_origin_543_i1 : ∀ x ∈ envelope_543_i1, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_543_i1 j := by decide +kernel +theorem envelope_exact_543_i1 : envelope_543_i1 = + insert (5, 7) (Finset.univ.biUnion childrenD_543_i1) := by + exact envelope_eq_combination childrenD_543_i1 (5, 7) envelope_543_i1 + pivot_mem_543_i1 child_envelope_sub_543_i1 envelope_origin_543_i1 +def checked_543_i1 : CheckedCard where + required := required_543_i1 + envelope := envelope_543_i1 + height := height_543_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i1 +def height_543_i6 : ℕ := 3 +def childrenH_543_i6 : Fin 2 → ℕ := ![height_154, height_170] +theorem height_exact_543_i6 : height_543_i6 = 1 + Finset.univ.sup childrenH_543_i6 := by decide +kernel +theorem required_origin_543_i6 : ∀ x ∈ required_543_i6, + (∃ j, x ∈ childrenC_543_i6 j) ∨ ∀ j, x ∈ childrenD_543_i6 j := by decide +kernel +theorem required_exact_543_i6 : required_543_i6 = + ((Finset.univ.biUnion childrenC_543_i6) ∪ commonEnvelope childrenD_543_i6).erase (5, 5) := by + exact required_eq_combination childrenC_543_i6 childrenD_543_i6 (5, 5) required_543_i6 + (by decide +kernel) child_required_sub_543_i6 common_sub_543_i6 required_origin_543_i6 +theorem envelope_origin_543_i6 : ∀ x ∈ envelope_543_i6, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_543_i6 j := by decide +kernel +theorem envelope_exact_543_i6 : envelope_543_i6 = + insert (5, 5) (Finset.univ.biUnion childrenD_543_i6) := by + exact envelope_eq_combination childrenD_543_i6 (5, 5) envelope_543_i6 + pivot_mem_543_i6 child_envelope_sub_543_i6 envelope_origin_543_i6 +def checked_543_i6 : CheckedCard where + required := required_543_i6 + envelope := envelope_543_i6 + height := height_543_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i6 +def height_543_i5 : ℕ := 4 +def childrenH_543_i5 : Fin 2 → ℕ := ![height_1, height_543_i6] +theorem height_exact_543_i5 : height_543_i5 = 1 + Finset.univ.sup childrenH_543_i5 := by decide +kernel +theorem required_origin_543_i5 : ∀ x ∈ required_543_i5, + (∃ j, x ∈ childrenC_543_i5 j) ∨ ∀ j, x ∈ childrenD_543_i5 j := by decide +kernel +theorem required_exact_543_i5 : required_543_i5 = + ((Finset.univ.biUnion childrenC_543_i5) ∪ commonEnvelope childrenD_543_i5).erase (5, 7) := by + exact required_eq_combination childrenC_543_i5 childrenD_543_i5 (5, 7) required_543_i5 + (by decide +kernel) child_required_sub_543_i5 common_sub_543_i5 required_origin_543_i5 +theorem envelope_origin_543_i5 : ∀ x ∈ envelope_543_i5, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_543_i5 j := by decide +kernel +theorem envelope_exact_543_i5 : envelope_543_i5 = + insert (5, 7) (Finset.univ.biUnion childrenD_543_i5) := by + exact envelope_eq_combination childrenD_543_i5 (5, 7) envelope_543_i5 + pivot_mem_543_i5 child_envelope_sub_543_i5 envelope_origin_543_i5 +def checked_543_i5 : CheckedCard where + required := required_543_i5 + envelope := envelope_543_i5 + height := height_543_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i5 +def height_543_i4 : ℕ := 5 +def childrenH_543_i4 : Fin 2 → ℕ := ![height_16, height_543_i5] +theorem height_exact_543_i4 : height_543_i4 = 1 + Finset.univ.sup childrenH_543_i4 := by decide +kernel +theorem required_origin_543_i4 : ∀ x ∈ required_543_i4, + (∃ j, x ∈ childrenC_543_i4 j) ∨ ∀ j, x ∈ childrenD_543_i4 j := by decide +kernel +theorem required_exact_543_i4 : required_543_i4 = + ((Finset.univ.biUnion childrenC_543_i4) ∪ commonEnvelope childrenD_543_i4).erase (3, 7) := by + exact required_eq_combination childrenC_543_i4 childrenD_543_i4 (3, 7) required_543_i4 + (by decide +kernel) child_required_sub_543_i4 common_sub_543_i4 required_origin_543_i4 +theorem envelope_origin_543_i4 : ∀ x ∈ envelope_543_i4, + x = (3, 7) ∨ ∃ j, x ∈ childrenD_543_i4 j := by decide +kernel +theorem envelope_exact_543_i4 : envelope_543_i4 = + insert (3, 7) (Finset.univ.biUnion childrenD_543_i4) := by + exact envelope_eq_combination childrenD_543_i4 (3, 7) envelope_543_i4 + pivot_mem_543_i4 child_envelope_sub_543_i4 envelope_origin_543_i4 +def checked_543_i4 : CheckedCard where + required := required_543_i4 + envelope := envelope_543_i4 + height := height_543_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i4 +def height_543_i3 : ℕ := 6 +def childrenH_543_i3 : Fin 2 → ℕ := ![height_4, height_543_i4] +theorem height_exact_543_i3 : height_543_i3 = 1 + Finset.univ.sup childrenH_543_i3 := by decide +kernel +theorem required_origin_543_i3 : ∀ x ∈ required_543_i3, + (∃ j, x ∈ childrenC_543_i3 j) ∨ ∀ j, x ∈ childrenD_543_i3 j := by decide +kernel +theorem required_exact_543_i3 : required_543_i3 = + ((Finset.univ.biUnion childrenC_543_i3) ∪ commonEnvelope childrenD_543_i3).erase (1, 6) := by + exact required_eq_combination childrenC_543_i3 childrenD_543_i3 (1, 6) required_543_i3 + (by decide +kernel) child_required_sub_543_i3 common_sub_543_i3 required_origin_543_i3 +theorem envelope_origin_543_i3 : ∀ x ∈ envelope_543_i3, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_543_i3 j := by decide +kernel +theorem envelope_exact_543_i3 : envelope_543_i3 = + insert (1, 6) (Finset.univ.biUnion childrenD_543_i3) := by + exact envelope_eq_combination childrenD_543_i3 (1, 6) envelope_543_i3 + pivot_mem_543_i3 child_envelope_sub_543_i3 envelope_origin_543_i3 +def checked_543_i3 : CheckedCard where + required := required_543_i3 + envelope := envelope_543_i3 + height := height_543_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i3 +def height_543_i2 : ℕ := 7 +def childrenH_543_i2 : Fin 2 → ℕ := ![height_6, height_543_i3] +theorem height_exact_543_i2 : height_543_i2 = 1 + Finset.univ.sup childrenH_543_i2 := by decide +kernel +theorem required_origin_543_i2 : ∀ x ∈ required_543_i2, + (∃ j, x ∈ childrenC_543_i2 j) ∨ ∀ j, x ∈ childrenD_543_i2 j := by decide +kernel +theorem required_exact_543_i2 : required_543_i2 = + ((Finset.univ.biUnion childrenC_543_i2) ∪ commonEnvelope childrenD_543_i2).erase (2, 10) := by + exact required_eq_combination childrenC_543_i2 childrenD_543_i2 (2, 10) required_543_i2 + (by decide +kernel) child_required_sub_543_i2 common_sub_543_i2 required_origin_543_i2 +theorem envelope_origin_543_i2 : ∀ x ∈ envelope_543_i2, + x = (2, 10) ∨ ∃ j, x ∈ childrenD_543_i2 j := by decide +kernel +theorem envelope_exact_543_i2 : envelope_543_i2 = + insert (2, 10) (Finset.univ.biUnion childrenD_543_i2) := by + exact envelope_eq_combination childrenD_543_i2 (2, 10) envelope_543_i2 + pivot_mem_543_i2 child_envelope_sub_543_i2 envelope_origin_543_i2 +def checked_543_i2 : CheckedCard where + required := required_543_i2 + envelope := envelope_543_i2 + height := height_543_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i2 +def height_543_i7 : ℕ := 10 +def childrenH_543_i7 : Fin 2 → ℕ := ![height_6, height_539] +theorem height_exact_543_i7 : height_543_i7 = 1 + Finset.univ.sup childrenH_543_i7 := by decide +kernel +theorem required_origin_543_i7 : ∀ x ∈ required_543_i7, + (∃ j, x ∈ childrenC_543_i7 j) ∨ ∀ j, x ∈ childrenD_543_i7 j := by decide +kernel +theorem required_exact_543_i7 : required_543_i7 = + ((Finset.univ.biUnion childrenC_543_i7) ∪ commonEnvelope childrenD_543_i7).erase (2, 10) := by + exact required_eq_combination childrenC_543_i7 childrenD_543_i7 (2, 10) required_543_i7 + (by decide +kernel) child_required_sub_543_i7 common_sub_543_i7 required_origin_543_i7 +theorem envelope_origin_543_i7 : ∀ x ∈ envelope_543_i7, + x = (2, 10) ∨ ∃ j, x ∈ childrenD_543_i7 j := by decide +kernel +theorem envelope_exact_543_i7 : envelope_543_i7 = + insert (2, 10) (Finset.univ.biUnion childrenD_543_i7) := by + exact envelope_eq_combination childrenD_543_i7 (2, 10) envelope_543_i7 + pivot_mem_543_i7 child_envelope_sub_543_i7 envelope_origin_543_i7 +def checked_543_i7 : CheckedCard where + required := required_543_i7 + envelope := envelope_543_i7 + height := height_543_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i7 +def height_543_i8 : ℕ := 8 +def childrenH_543_i8 : Fin 3 → ℕ := ![height_7, height_86, height_542] +theorem height_exact_543_i8 : height_543_i8 = 1 + Finset.univ.sup childrenH_543_i8 := by decide +kernel +theorem required_origin_543_i8 : ∀ x ∈ required_543_i8, + (∃ j, x ∈ childrenC_543_i8 j) ∨ ∀ j, x ∈ childrenD_543_i8 j := by decide +kernel +theorem required_exact_543_i8 : required_543_i8 = + ((Finset.univ.biUnion childrenC_543_i8) ∪ commonEnvelope childrenD_543_i8).erase (4, 6) := by + exact required_eq_combination childrenC_543_i8 childrenD_543_i8 (4, 6) required_543_i8 + (by decide +kernel) child_required_sub_543_i8 common_sub_543_i8 required_origin_543_i8 +theorem envelope_origin_543_i8 : ∀ x ∈ envelope_543_i8, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_543_i8 j := by decide +kernel +theorem envelope_exact_543_i8 : envelope_543_i8 = + insert (4, 6) (Finset.univ.biUnion childrenD_543_i8) := by + exact envelope_eq_combination childrenD_543_i8 (4, 6) envelope_543_i8 + pivot_mem_543_i8 child_envelope_sub_543_i8 envelope_origin_543_i8 +def checked_543_i8 : CheckedCard where + required := required_543_i8 + envelope := envelope_543_i8 + height := height_543_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i8 +def height_543_i0 : ℕ := 11 +def childrenH_543_i0 : Fin 7 → ℕ := ![height_433, height_543_i1, height_543_i2, height_543_i7, height_540, height_541, height_543_i8] +theorem height_exact_543_i0 : height_543_i0 = 1 + Finset.univ.sup childrenH_543_i0 := by decide +kernel +theorem required_origin_543_i0 : ∀ x ∈ required_543_i0, + (∃ j, x ∈ childrenC_543_i0 j) ∨ ∀ j, x ∈ childrenD_543_i0 j := by decide +kernel +theorem required_exact_543_i0 : required_543_i0 = + ((Finset.univ.biUnion childrenC_543_i0) ∪ commonEnvelope childrenD_543_i0).erase (4, 5) := by + exact required_eq_combination childrenC_543_i0 childrenD_543_i0 (4, 5) required_543_i0 + (by decide +kernel) child_required_sub_543_i0 common_sub_543_i0 required_origin_543_i0 +theorem envelope_origin_543_i0 : ∀ x ∈ envelope_543_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_543_i0 j := by decide +kernel +theorem envelope_exact_543_i0 : envelope_543_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_543_i0) := by + exact envelope_eq_combination childrenD_543_i0 (4, 5) envelope_543_i0 + pivot_mem_543_i0 child_envelope_sub_543_i0 envelope_origin_543_i0 +def checked_543_i0 : CheckedCard where + required := required_543_i0 + envelope := envelope_543_i0 + height := height_543_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i0 +def height_543_i10 : ℕ := 2 +def childrenH_543_i10 : Fin 2 → ℕ := ![height_3, height_5] +theorem height_exact_543_i10 : height_543_i10 = 1 + Finset.univ.sup childrenH_543_i10 := by decide +kernel +theorem required_origin_543_i10 : ∀ x ∈ required_543_i10, + (∃ j, x ∈ childrenC_543_i10 j) ∨ ∀ j, x ∈ childrenD_543_i10 j := by decide +kernel +theorem required_exact_543_i10 : required_543_i10 = + ((Finset.univ.biUnion childrenC_543_i10) ∪ commonEnvelope childrenD_543_i10).erase (2, 5) := by + exact required_eq_combination childrenC_543_i10 childrenD_543_i10 (2, 5) required_543_i10 + (by decide +kernel) child_required_sub_543_i10 common_sub_543_i10 required_origin_543_i10 +theorem envelope_origin_543_i10 : ∀ x ∈ envelope_543_i10, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_543_i10 j := by decide +kernel +theorem envelope_exact_543_i10 : envelope_543_i10 = + insert (2, 5) (Finset.univ.biUnion childrenD_543_i10) := by + exact envelope_eq_combination childrenD_543_i10 (2, 5) envelope_543_i10 + pivot_mem_543_i10 child_envelope_sub_543_i10 envelope_origin_543_i10 +def checked_543_i10 : CheckedCard where + required := required_543_i10 + envelope := envelope_543_i10 + height := height_543_i10 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i10 +def height_543_i9 : ℕ := 6 +def childrenH_543_i9 : Fin 2 → ℕ := ![height_278, height_543_i10] +theorem height_exact_543_i9 : height_543_i9 = 1 + Finset.univ.sup childrenH_543_i9 := by decide +kernel +theorem required_origin_543_i9 : ∀ x ∈ required_543_i9, + (∃ j, x ∈ childrenC_543_i9 j) ∨ ∀ j, x ∈ childrenD_543_i9 j := by decide +kernel +theorem required_exact_543_i9 : required_543_i9 = + ((Finset.univ.biUnion childrenC_543_i9) ∪ commonEnvelope childrenD_543_i9).erase (3, 8) := by + exact required_eq_combination childrenC_543_i9 childrenD_543_i9 (3, 8) required_543_i9 + (by decide +kernel) child_required_sub_543_i9 common_sub_543_i9 required_origin_543_i9 +theorem envelope_origin_543_i9 : ∀ x ∈ envelope_543_i9, + x = (3, 8) ∨ ∃ j, x ∈ childrenD_543_i9 j := by decide +kernel +theorem envelope_exact_543_i9 : envelope_543_i9 = + insert (3, 8) (Finset.univ.biUnion childrenD_543_i9) := by + exact envelope_eq_combination childrenD_543_i9 (3, 8) envelope_543_i9 + pivot_mem_543_i9 child_envelope_sub_543_i9 envelope_origin_543_i9 +def checked_543_i9 : CheckedCard where + required := required_543_i9 + envelope := envelope_543_i9 + height := height_543_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543_i9 +def height_543 : ℕ := 12 +def childrenH_543 : Fin 4 → ℕ := ![height_8, height_280, height_543_i0, height_543_i9] +theorem height_exact_543 : height_543 = 1 + Finset.univ.sup childrenH_543 := by decide +kernel +theorem required_origin_543 : ∀ x ∈ required_543, + (∃ j, x ∈ childrenC_543 j) ∨ ∀ j, x ∈ childrenD_543 j := by decide +kernel +theorem required_exact_543 : required_543 = + ((Finset.univ.biUnion childrenC_543) ∪ commonEnvelope childrenD_543).erase (2, 9) := by + exact required_eq_combination childrenC_543 childrenD_543 (2, 9) required_543 + (by decide +kernel) child_required_sub_543 common_sub_543 required_origin_543 +theorem envelope_origin_543 : ∀ x ∈ envelope_543, + x = (2, 9) ∨ ∃ j, x ∈ childrenD_543 j := by decide +kernel +theorem envelope_exact_543 : envelope_543 = + insert (2, 9) (Finset.univ.biUnion childrenD_543) := by + exact envelope_eq_combination childrenD_543 (2, 9) envelope_543 + pivot_mem_543 child_envelope_sub_543 envelope_origin_543 +def checked_543 : CheckedCard where + required := required_543 + envelope := envelope_543 + height := height_543 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_543 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part02.lean new file mode 100644 index 0000000..5c0ed55 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part02.lean @@ -0,0 +1,989 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_551_i7 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 5), (2, 6), (4, 3), (5, 3), (6, 3), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_551_i7 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (3, 2), (3, 3), (4, 2), (4, 3), (5, 3), (6, 3), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_551_i7 : Fin 2 → Finset Cell := ![(placed21 7 (7, 3) required_6), (placed21 2 (4, 2) required_78)] +def childrenD_551_i7 : Fin 2 → Finset Cell := ![(placed21 7 (7, 3) envelope_6), (placed21 2 (4, 2) envelope_78)] +theorem common_sub_551_i7 : commonEnvelope childrenD_551_i7 ⊆ insert (3, 3) required_551_i7 := by decide +kernel +theorem child_required_sub_551_i7 : ∀ j, childrenC_551_i7 j ⊆ insert (3, 3) required_551_i7 := by decide +kernel +theorem child_envelope_sub_551_i7 : ∀ j, childrenD_551_i7 j ⊆ envelope_551_i7 := by decide +kernel +theorem pivot_mem_551_i7 : (3, 3) ∈ envelope_551_i7 := by decide +kernel +theorem children_work_551_i7 : ∀ j, Template HasSnaky 3 (childrenC_551_i7 j) (childrenD_551_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 7 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_78 2 (4, 2)).mono (by decide +kernel) +theorem row_works_551_i7 : Template HasSnaky 4 required_551_i7 envelope_551_i7 := by + refine compose HasSnaky 3 childrenC_551_i7 childrenD_551_i7 children_work_551_i7 (3, 3) + required_551_i7 envelope_551_i7 pivot_mem_551_i7 child_required_sub_551_i7 child_envelope_sub_551_i7 ?_ + intro b hb + exact common_sub_551_i7 (mem_commonEnvelope childrenD_551_i7 b hb) +def required_551_i8 : Finset Cell := ⟨(([(1, 3), (2, 3), (4, 3), (5, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_551_i8 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3), (4, 3), (5, 3), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_551_i8 : Fin 2 → Finset Cell := ![(placed21 0 (2, 3) required_4), (placed21 7 (5, 3) required_6)] +def childrenD_551_i8 : Fin 2 → Finset Cell := ![(placed21 0 (2, 3) envelope_4), (placed21 7 (5, 3) envelope_6)] +theorem common_sub_551_i8 : commonEnvelope childrenD_551_i8 ⊆ insert (3, 3) required_551_i8 := by decide +kernel +theorem child_required_sub_551_i8 : ∀ j, childrenC_551_i8 j ⊆ insert (3, 3) required_551_i8 := by decide +kernel +theorem child_envelope_sub_551_i8 : ∀ j, childrenD_551_i8 j ⊆ envelope_551_i8 := by decide +kernel +theorem pivot_mem_551_i8 : (3, 3) ∈ envelope_551_i8 := by decide +kernel +theorem children_work_551_i8 : ∀ j, Template HasSnaky 2 (childrenC_551_i8 j) (childrenD_551_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 0 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_6 7 (5, 3)).mono (by decide +kernel) +theorem row_works_551_i8 : Template HasSnaky 3 required_551_i8 envelope_551_i8 := by + refine compose HasSnaky 2 childrenC_551_i8 childrenD_551_i8 children_work_551_i8 (3, 3) + required_551_i8 envelope_551_i8 pivot_mem_551_i8 child_required_sub_551_i8 child_envelope_sub_551_i8 ?_ + intro b hb + exact common_sub_551_i8 (mem_commonEnvelope childrenD_551_i8 b hb) +def required_551_i6 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 5), (2, 6), (5, 3), (5, 5), (5, 6), (6, 3), (6, 4), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_551_i6 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (3, 2), (3, 3), (4, 2), (4, 3), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_551_i6 : Fin 3 → Finset Cell := ![(placed21 2 (7, 2) required_25), required_551_i7, required_551_i8] +def childrenD_551_i6 : Fin 3 → Finset Cell := ![(placed21 2 (7, 2) envelope_25), envelope_551_i7, envelope_551_i8] +theorem common_sub_551_i6 : commonEnvelope childrenD_551_i6 ⊆ insert (4, 3) required_551_i6 := by decide +kernel +theorem child_required_sub_551_i6 : ∀ j, childrenC_551_i6 j ⊆ insert (4, 3) required_551_i6 := by decide +kernel +theorem child_envelope_sub_551_i6 : ∀ j, childrenD_551_i6 j ⊆ envelope_551_i6 := by decide +kernel +theorem pivot_mem_551_i6 : (4, 3) ∈ envelope_551_i6 := by decide +kernel +theorem children_work_551_i6 : ∀ j, Template HasSnaky 4 (childrenC_551_i6 j) (childrenD_551_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_25 2 (7, 2)).mono (by decide +kernel) + · exact row_works_551_i7.mono (by decide +kernel) + · exact row_works_551_i8.mono (by decide +kernel) +theorem row_works_551_i6 : Template HasSnaky 5 required_551_i6 envelope_551_i6 := by + refine compose HasSnaky 4 childrenC_551_i6 childrenD_551_i6 children_work_551_i6 (4, 3) + required_551_i6 envelope_551_i6 pivot_mem_551_i6 child_required_sub_551_i6 child_envelope_sub_551_i6 ?_ + intro b hb + exact common_sub_551_i6 (mem_commonEnvelope childrenD_551_i6 b hb) +def required_551_i5 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 5), (2, 6), (5, 3), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_551_i5 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (3, 2), (3, 3), (4, 2), (4, 3), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_551_i5 : Fin 2 → Finset Cell := ![(placed21 3 (6, 6) required_5), required_551_i6] +def childrenD_551_i5 : Fin 2 → Finset Cell := ![(placed21 3 (6, 6) envelope_5), envelope_551_i6] +theorem common_sub_551_i5 : commonEnvelope childrenD_551_i5 ⊆ insert (7, 3) required_551_i5 := by decide +kernel +theorem child_required_sub_551_i5 : ∀ j, childrenC_551_i5 j ⊆ insert (7, 3) required_551_i5 := by decide +kernel +theorem child_envelope_sub_551_i5 : ∀ j, childrenD_551_i5 j ⊆ envelope_551_i5 := by decide +kernel +theorem pivot_mem_551_i5 : (7, 3) ∈ envelope_551_i5 := by decide +kernel +theorem children_work_551_i5 : ∀ j, Template HasSnaky 5 (childrenC_551_i5 j) (childrenD_551_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (6, 6)).mono (by decide +kernel) + · exact row_works_551_i6.mono (by decide +kernel) +theorem row_works_551_i5 : Template HasSnaky 6 required_551_i5 envelope_551_i5 := by + refine compose HasSnaky 5 childrenC_551_i5 childrenD_551_i5 children_work_551_i5 (7, 3) + required_551_i5 envelope_551_i5 pivot_mem_551_i5 child_required_sub_551_i5 child_envelope_sub_551_i5 ?_ + intro b hb + exact common_sub_551_i5 (mem_commonEnvelope childrenD_551_i5 b hb) +def required_551_i4 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 5), (2, 6), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_551_i4 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (3, 2), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_551_i4 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) required_5), required_551_i5] +def childrenD_551_i4 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) envelope_5), envelope_551_i5] +theorem common_sub_551_i4 : commonEnvelope childrenD_551_i4 ⊆ insert (5, 3) required_551_i4 := by decide +kernel +theorem child_required_sub_551_i4 : ∀ j, childrenC_551_i4 j ⊆ insert (5, 3) required_551_i4 := by decide +kernel +theorem child_envelope_sub_551_i4 : ∀ j, childrenD_551_i4 j ⊆ envelope_551_i4 := by decide +kernel +theorem pivot_mem_551_i4 : (5, 3) ∈ envelope_551_i4 := by decide +kernel +theorem children_work_551_i4 : ∀ j, Template HasSnaky 6 (childrenC_551_i4 j) (childrenD_551_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (6, 6)).mono (by decide +kernel) + · exact row_works_551_i5.mono (by decide +kernel) +theorem row_works_551_i4 : Template HasSnaky 7 required_551_i4 envelope_551_i4 := by + refine compose HasSnaky 6 childrenC_551_i4 childrenD_551_i4 children_work_551_i4 (5, 3) + required_551_i4 envelope_551_i4 pivot_mem_551_i4 child_required_sub_551_i4 child_envelope_sub_551_i4 ?_ + intro b hb + exact common_sub_551_i4 (mem_commonEnvelope childrenD_551_i4 b hb) +def required_551_i3 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 6), (4, 5), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_551_i3 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (3, 2), (3, 3), (3, 5), (4, 2), (4, 3), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_551_i3 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) required_1), required_551_i4] +def childrenD_551_i3 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) envelope_1), envelope_551_i4] +theorem common_sub_551_i3 : commonEnvelope childrenD_551_i3 ⊆ insert (2, 5) required_551_i3 := by decide +kernel +theorem child_required_sub_551_i3 : ∀ j, childrenC_551_i3 j ⊆ insert (2, 5) required_551_i3 := by decide +kernel +theorem child_envelope_sub_551_i3 : ∀ j, childrenD_551_i3 j ⊆ envelope_551_i3 := by decide +kernel +theorem pivot_mem_551_i3 : (2, 5) ∈ envelope_551_i3 := by decide +kernel +theorem children_work_551_i3 : ∀ j, Template HasSnaky 7 (childrenC_551_i3 j) (childrenD_551_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (2, 5)).mono (by decide +kernel) + · exact row_works_551_i4.mono (by decide +kernel) +theorem row_works_551_i3 : Template HasSnaky 8 required_551_i3 envelope_551_i3 := by + refine compose HasSnaky 7 childrenC_551_i3 childrenD_551_i3 children_work_551_i3 (2, 5) + required_551_i3 envelope_551_i3 pivot_mem_551_i3 child_required_sub_551_i3 child_envelope_sub_551_i3 ?_ + intro b hb + exact common_sub_551_i3 (mem_commonEnvelope childrenD_551_i3 b hb) +def required_551_i2 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 6), (4, 5), (5, 5), (6, 3), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_551_i2 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (3, 2), (3, 3), (3, 5), (4, 2), (4, 3), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_551_i2 : Fin 2 → Finset Cell := ![(placed21 5 (6, 3) required_5), required_551_i3] +def childrenD_551_i2 : Fin 2 → Finset Cell := ![(placed21 5 (6, 3) envelope_5), envelope_551_i3] +theorem common_sub_551_i2 : commonEnvelope childrenD_551_i2 ⊆ insert (5, 6) required_551_i2 := by decide +kernel +theorem child_required_sub_551_i2 : ∀ j, childrenC_551_i2 j ⊆ insert (5, 6) required_551_i2 := by decide +kernel +theorem child_envelope_sub_551_i2 : ∀ j, childrenD_551_i2 j ⊆ envelope_551_i2 := by decide +kernel +theorem pivot_mem_551_i2 : (5, 6) ∈ envelope_551_i2 := by decide +kernel +theorem children_work_551_i2 : ∀ j, Template HasSnaky 8 (childrenC_551_i2 j) (childrenD_551_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (6, 3)).mono (by decide +kernel) + · exact row_works_551_i3.mono (by decide +kernel) +theorem row_works_551_i2 : Template HasSnaky 9 required_551_i2 envelope_551_i2 := by + refine compose HasSnaky 8 childrenC_551_i2 childrenD_551_i2 children_work_551_i2 (5, 6) + required_551_i2 envelope_551_i2 pivot_mem_551_i2 child_required_sub_551_i2 child_envelope_sub_551_i2 ?_ + intro b hb + exact common_sub_551_i2 (mem_commonEnvelope childrenD_551_i2 b hb) +def required_551_i1 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 6), (4, 5), (5, 5), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_551_i1 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (3, 2), (3, 3), (3, 5), (4, 2), (4, 3), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 7), (7, 8), (7, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_551_i1 : Fin 4 → Finset Cell := ![(placed21 0 (5, 2) required_19), (placed21 0 (5, 2) required_84), (placed21 1 (5, 3) required_314), required_551_i2] +def childrenD_551_i1 : Fin 4 → Finset Cell := ![(placed21 0 (5, 2) envelope_19), (placed21 0 (5, 2) envelope_84), (placed21 1 (5, 3) envelope_314), envelope_551_i2] +theorem common_sub_551_i1 : commonEnvelope childrenD_551_i1 ⊆ insert (6, 6) required_551_i1 := by decide +kernel +theorem child_required_sub_551_i1 : ∀ j, childrenC_551_i1 j ⊆ insert (6, 6) required_551_i1 := by decide +kernel +theorem child_envelope_sub_551_i1 : ∀ j, childrenD_551_i1 j ⊆ envelope_551_i1 := by decide +kernel +theorem pivot_mem_551_i1 : (6, 6) ∈ envelope_551_i1 := by decide +kernel +theorem children_work_551_i1 : ∀ j, Template HasSnaky 9 (childrenC_551_i1 j) (childrenD_551_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 0 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_84 0 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_314 1 (5, 3)).mono (by decide +kernel) + · exact row_works_551_i2.mono (by decide +kernel) +theorem row_works_551_i1 : Template HasSnaky 10 required_551_i1 envelope_551_i1 := by + refine compose HasSnaky 9 childrenC_551_i1 childrenD_551_i1 children_work_551_i1 (6, 6) + required_551_i1 envelope_551_i1 pivot_mem_551_i1 child_required_sub_551_i1 child_envelope_sub_551_i1 ?_ + intro b hb + exact common_sub_551_i1 (mem_commonEnvelope childrenD_551_i1 b hb) +def required_551_i0 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 6), (4, 5), (5, 5), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_551_i0 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (3, 2), (3, 3), (3, 5), (4, 2), (4, 3), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 7), (7, 8), (7, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_551_i0 : Fin 4 → Finset Cell := ![(placed21 4 (5, 6) required_10), (placed21 2 (6, 2) required_44), (placed21 4 (5, 6) required_63), required_551_i1] +def childrenD_551_i0 : Fin 4 → Finset Cell := ![(placed21 4 (5, 6) envelope_10), (placed21 2 (6, 2) envelope_44), (placed21 4 (5, 6) envelope_63), envelope_551_i1] +theorem common_sub_551_i0 : commonEnvelope childrenD_551_i0 ⊆ insert (6, 3) required_551_i0 := by decide +kernel +theorem child_required_sub_551_i0 : ∀ j, childrenC_551_i0 j ⊆ insert (6, 3) required_551_i0 := by decide +kernel +theorem child_envelope_sub_551_i0 : ∀ j, childrenD_551_i0 j ⊆ envelope_551_i0 := by decide +kernel +theorem pivot_mem_551_i0 : (6, 3) ∈ envelope_551_i0 := by decide +kernel +theorem children_work_551_i0 : ∀ j, Template HasSnaky 10 (childrenC_551_i0 j) (childrenD_551_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 4 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_44 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_63 4 (5, 6)).mono (by decide +kernel) + · exact row_works_551_i1.mono (by decide +kernel) +theorem row_works_551_i0 : Template HasSnaky 11 required_551_i0 envelope_551_i0 := by + refine compose HasSnaky 10 childrenC_551_i0 childrenD_551_i0 children_work_551_i0 (6, 3) + required_551_i0 envelope_551_i0 pivot_mem_551_i0 child_required_sub_551_i0 child_envelope_sub_551_i0 ?_ + intro b hb + exact common_sub_551_i0 (mem_commonEnvelope childrenD_551_i0 b hb) +def required_551 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 6), (4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_551 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (3, 2), (3, 3), (3, 5), (4, 2), (4, 3), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 7), (7, 8), (7, 9), (8, 4), (9, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_551 : Fin 3 → Finset Cell := ![(placed21 3 (3, 5) required_52), (placed21 0 (3, 1) required_523), required_551_i0] +def childrenD_551 : Fin 3 → Finset Cell := ![(placed21 3 (3, 5) envelope_52), (placed21 0 (3, 1) envelope_523), envelope_551_i0] +theorem common_sub_551 : commonEnvelope childrenD_551 ⊆ insert (6, 4) required_551 := by decide +kernel +theorem child_required_sub_551 : ∀ j, childrenC_551 j ⊆ insert (6, 4) required_551 := by decide +kernel +theorem child_envelope_sub_551 : ∀ j, childrenD_551 j ⊆ envelope_551 := by decide +kernel +theorem pivot_mem_551 : (6, 4) ∈ envelope_551 := by decide +kernel +theorem children_work_551 : ∀ j, Template HasSnaky 11 (childrenC_551 j) (childrenD_551 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 3 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_523 0 (3, 1)).mono (by decide +kernel) + · exact row_works_551_i0.mono (by decide +kernel) +theorem row_works_551 : Template HasSnaky 12 required_551 envelope_551 := by + refine compose HasSnaky 11 childrenC_551 childrenD_551 children_work_551 (6, 4) + required_551 envelope_551 pivot_mem_551 child_required_sub_551 child_envelope_sub_551 ?_ + intro b hb + exact common_sub_551 (mem_commonEnvelope childrenD_551 b hb) +def required_571_i1 : Finset Cell := ⟨(([(0, 3), (3, 3), (3, 4), (3, 6), (4, 4), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571_i1 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 7), (3, 3), (3, 4), (3, 6), (3, 7), (4, 4), (4, 6), (4, 7), (4, 8), (4, 9), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571_i1 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) required_287), (placed21 1 (0, 3) required_288), (placed21 0 (2, 4) required_345), (placed21 1 (2, 5) required_457)] +def childrenD_571_i1 : Fin 4 → Finset Cell := ![(placed21 1 (0, 3) envelope_287), (placed21 1 (0, 3) envelope_288), (placed21 0 (2, 4) envelope_345), (placed21 1 (2, 5) envelope_457)] +theorem common_sub_571_i1 : commonEnvelope childrenD_571_i1 ⊆ insert (5, 6) required_571_i1 := by decide +kernel +theorem child_required_sub_571_i1 : ∀ j, childrenC_571_i1 j ⊆ insert (5, 6) required_571_i1 := by decide +kernel +theorem child_envelope_sub_571_i1 : ∀ j, childrenD_571_i1 j ⊆ envelope_571_i1 := by decide +kernel +theorem pivot_mem_571_i1 : (5, 6) ∈ envelope_571_i1 := by decide +kernel +theorem children_work_571_i1 : ∀ j, Template HasSnaky 9 (childrenC_571_i1 j) (childrenD_571_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_287 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_288 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_345 0 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_457 1 (2, 5)).mono (by decide +kernel) +theorem row_works_571_i1 : Template HasSnaky 10 required_571_i1 envelope_571_i1 := by + refine compose HasSnaky 9 childrenC_571_i1 childrenD_571_i1 children_work_571_i1 (5, 6) + required_571_i1 envelope_571_i1 pivot_mem_571_i1 child_required_sub_571_i1 child_envelope_sub_571_i1 ?_ + intro b hb + exact common_sub_571_i1 (mem_commonEnvelope childrenD_571_i1 b hb) +def required_571_i0 : Finset Cell := ⟨(([(0, 3), (3, 3), (3, 4), (3, 6), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571_i0 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 7), (3, 3), (3, 4), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571_i0 : Fin 2 → Finset Cell := ![(placed21 7 (4, 7) required_2), required_571_i1] +def childrenD_571_i0 : Fin 2 → Finset Cell := ![(placed21 7 (4, 7) envelope_2), envelope_571_i1] +theorem common_sub_571_i0 : commonEnvelope childrenD_571_i0 ⊆ insert (4, 7) required_571_i0 := by decide +kernel +theorem child_required_sub_571_i0 : ∀ j, childrenC_571_i0 j ⊆ insert (4, 7) required_571_i0 := by decide +kernel +theorem child_envelope_sub_571_i0 : ∀ j, childrenD_571_i0 j ⊆ envelope_571_i0 := by decide +kernel +theorem pivot_mem_571_i0 : (4, 7) ∈ envelope_571_i0 := by decide +kernel +theorem children_work_571_i0 : ∀ j, Template HasSnaky 10 (childrenC_571_i0 j) (childrenD_571_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 7 (4, 7)).mono (by decide +kernel) + · exact row_works_571_i1.mono (by decide +kernel) +theorem row_works_571_i0 : Template HasSnaky 11 required_571_i0 envelope_571_i0 := by + refine compose HasSnaky 10 childrenC_571_i0 childrenD_571_i0 children_work_571_i0 (4, 7) + required_571_i0 envelope_571_i0 pivot_mem_571_i0 child_required_sub_571_i0 child_envelope_sub_571_i0 ?_ + intro b hb + exact common_sub_571_i0 (mem_commonEnvelope childrenD_571_i0 b hb) +def required_571_i3 : Finset Cell := ⟨(([(3, 6), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571_i3 : Finset Cell := ⟨(([(3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571_i3 : Fin 2 → Finset Cell := ![(placed21 5 (4, 3) required_5), (placed21 4 (3, 9) required_446)] +def childrenD_571_i3 : Fin 2 → Finset Cell := ![(placed21 5 (4, 3) envelope_5), (placed21 4 (3, 9) envelope_446)] +theorem common_sub_571_i3 : commonEnvelope childrenD_571_i3 ⊆ insert (4, 3) required_571_i3 := by decide +kernel +theorem child_required_sub_571_i3 : ∀ j, childrenC_571_i3 j ⊆ insert (4, 3) required_571_i3 := by decide +kernel +theorem child_envelope_sub_571_i3 : ∀ j, childrenD_571_i3 j ⊆ envelope_571_i3 := by decide +kernel +theorem pivot_mem_571_i3 : (4, 3) ∈ envelope_571_i3 := by decide +kernel +theorem children_work_571_i3 : ∀ j, Template HasSnaky 7 (childrenC_571_i3 j) (childrenD_571_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_446 4 (3, 9)).mono (by decide +kernel) +theorem row_works_571_i3 : Template HasSnaky 8 required_571_i3 envelope_571_i3 := by + refine compose HasSnaky 7 childrenC_571_i3 childrenD_571_i3 children_work_571_i3 (4, 3) + required_571_i3 envelope_571_i3 pivot_mem_571_i3 child_required_sub_571_i3 child_envelope_sub_571_i3 ?_ + intro b hb + exact common_sub_571_i3 (mem_commonEnvelope childrenD_571_i3 b hb) +def required_571_i2 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 6), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571_i2 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571_i2 : Fin 2 → Finset Cell := ![(placed21 7 (4, 7) required_0), required_571_i3] +def childrenD_571_i2 : Fin 2 → Finset Cell := ![(placed21 7 (4, 7) envelope_0), envelope_571_i3] +theorem common_sub_571_i2 : commonEnvelope childrenD_571_i2 ⊆ insert (4, 5) required_571_i2 := by decide +kernel +theorem child_required_sub_571_i2 : ∀ j, childrenC_571_i2 j ⊆ insert (4, 5) required_571_i2 := by decide +kernel +theorem child_envelope_sub_571_i2 : ∀ j, childrenD_571_i2 j ⊆ envelope_571_i2 := by decide +kernel +theorem pivot_mem_571_i2 : (4, 5) ∈ envelope_571_i2 := by decide +kernel +theorem children_work_571_i2 : ∀ j, Template HasSnaky 8 (childrenC_571_i2 j) (childrenD_571_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (4, 7)).mono (by decide +kernel) + · exact row_works_571_i3.mono (by decide +kernel) +theorem row_works_571_i2 : Template HasSnaky 9 required_571_i2 envelope_571_i2 := by + refine compose HasSnaky 8 childrenC_571_i2 childrenD_571_i2 children_work_571_i2 (4, 5) + required_571_i2 envelope_571_i2 pivot_mem_571_i2 child_required_sub_571_i2 child_envelope_sub_571_i2 ?_ + intro b hb + exact common_sub_571_i2 (mem_commonEnvelope childrenD_571_i2 b hb) +def required_571_i5 : Finset Cell := ⟨(([(0, 3), (3, 3), (3, 4), (3, 6), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571_i5 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3), (3, 4), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571_i5 : Fin 2 → Finset Cell := ![(placed21 5 (4, 3) required_5), (placed21 0 (0, 1) required_283)] +def childrenD_571_i5 : Fin 2 → Finset Cell := ![(placed21 5 (4, 3) envelope_5), (placed21 0 (0, 1) envelope_283)] +theorem common_sub_571_i5 : commonEnvelope childrenD_571_i5 ⊆ insert (4, 3) required_571_i5 := by decide +kernel +theorem child_required_sub_571_i5 : ∀ j, childrenC_571_i5 j ⊆ insert (4, 3) required_571_i5 := by decide +kernel +theorem child_envelope_sub_571_i5 : ∀ j, childrenD_571_i5 j ⊆ envelope_571_i5 := by decide +kernel +theorem pivot_mem_571_i5 : (4, 3) ∈ envelope_571_i5 := by decide +kernel +theorem children_work_571_i5 : ∀ j, Template HasSnaky 6 (childrenC_571_i5 j) (childrenD_571_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_283 0 (0, 1)).mono (by decide +kernel) +theorem row_works_571_i5 : Template HasSnaky 7 required_571_i5 envelope_571_i5 := by + refine compose HasSnaky 6 childrenC_571_i5 childrenD_571_i5 children_work_571_i5 (4, 3) + required_571_i5 envelope_571_i5 pivot_mem_571_i5 child_required_sub_571_i5 child_envelope_sub_571_i5 ?_ + intro b hb + exact common_sub_571_i5 (mem_commonEnvelope childrenD_571_i5 b hb) +def required_571_i4 : Finset Cell := ⟨(([(0, 3), (3, 3), (3, 4), (3, 6), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571_i4 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3), (3, 4), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571_i4 : Fin 2 → Finset Cell := ![(placed21 7 (4, 7) required_0), required_571_i5] +def childrenD_571_i4 : Fin 2 → Finset Cell := ![(placed21 7 (4, 7) envelope_0), envelope_571_i5] +theorem common_sub_571_i4 : commonEnvelope childrenD_571_i4 ⊆ insert (4, 5) required_571_i4 := by decide +kernel +theorem child_required_sub_571_i4 : ∀ j, childrenC_571_i4 j ⊆ insert (4, 5) required_571_i4 := by decide +kernel +theorem child_envelope_sub_571_i4 : ∀ j, childrenD_571_i4 j ⊆ envelope_571_i4 := by decide +kernel +theorem pivot_mem_571_i4 : (4, 5) ∈ envelope_571_i4 := by decide +kernel +theorem children_work_571_i4 : ∀ j, Template HasSnaky 7 (childrenC_571_i4 j) (childrenD_571_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (4, 7)).mono (by decide +kernel) + · exact row_works_571_i5.mono (by decide +kernel) +theorem row_works_571_i4 : Template HasSnaky 8 required_571_i4 envelope_571_i4 := by + refine compose HasSnaky 7 childrenC_571_i4 childrenD_571_i4 children_work_571_i4 (4, 5) + required_571_i4 envelope_571_i4 pivot_mem_571_i4 child_required_sub_571_i4 child_envelope_sub_571_i4 ?_ + intro b hb + exact common_sub_571_i4 (mem_commonEnvelope childrenD_571_i4 b hb) +def required_571_i9 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571_i9 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (6, 3), (6, 4), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571_i9 : Fin 2 → Finset Cell := ![(placed21 3 (4, 6) required_5), (placed21 1 (2, 3) required_29)] +def childrenD_571_i9 : Fin 2 → Finset Cell := ![(placed21 3 (4, 6) envelope_5), (placed21 1 (2, 3) envelope_29)] +theorem common_sub_571_i9 : commonEnvelope childrenD_571_i9 ⊆ insert (5, 3) required_571_i9 := by decide +kernel +theorem child_required_sub_571_i9 : ∀ j, childrenC_571_i9 j ⊆ insert (5, 3) required_571_i9 := by decide +kernel +theorem child_envelope_sub_571_i9 : ∀ j, childrenD_571_i9 j ⊆ envelope_571_i9 := by decide +kernel +theorem pivot_mem_571_i9 : (5, 3) ∈ envelope_571_i9 := by decide +kernel +theorem children_work_571_i9 : ∀ j, Template HasSnaky 3 (childrenC_571_i9 j) (childrenD_571_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_29 1 (2, 3)).mono (by decide +kernel) +theorem row_works_571_i9 : Template HasSnaky 4 required_571_i9 envelope_571_i9 := by + refine compose HasSnaky 3 childrenC_571_i9 childrenD_571_i9 children_work_571_i9 (5, 3) + required_571_i9 envelope_571_i9 pivot_mem_571_i9 child_required_sub_571_i9 child_envelope_sub_571_i9 ?_ + intro b hb + exact common_sub_571_i9 (mem_commonEnvelope childrenD_571_i9 b hb) +def required_571_i8 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (3, 6), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571_i8 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571_i8 : Fin 3 → Finset Cell := ![(placed21 4 (4, 7) required_7), required_571_i9, (placed21 4 (3, 9) required_446)] +def childrenD_571_i8 : Fin 3 → Finset Cell := ![(placed21 4 (4, 7) envelope_7), envelope_571_i9, (placed21 4 (3, 9) envelope_446)] +theorem common_sub_571_i8 : commonEnvelope childrenD_571_i8 ⊆ insert (4, 3) required_571_i8 := by decide +kernel +theorem child_required_sub_571_i8 : ∀ j, childrenC_571_i8 j ⊆ insert (4, 3) required_571_i8 := by decide +kernel +theorem child_envelope_sub_571_i8 : ∀ j, childrenD_571_i8 j ⊆ envelope_571_i8 := by decide +kernel +theorem pivot_mem_571_i8 : (4, 3) ∈ envelope_571_i8 := by decide +kernel +theorem children_work_571_i8 : ∀ j, Template HasSnaky 7 (childrenC_571_i8 j) (childrenD_571_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (4, 7)).mono (by decide +kernel) + · exact row_works_571_i9.mono (by decide +kernel) + · exact (placed21_template row_works_446 4 (3, 9)).mono (by decide +kernel) +theorem row_works_571_i8 : Template HasSnaky 8 required_571_i8 envelope_571_i8 := by + refine compose HasSnaky 7 childrenC_571_i8 childrenD_571_i8 children_work_571_i8 (4, 3) + required_571_i8 envelope_571_i8 pivot_mem_571_i8 child_required_sub_571_i8 child_envelope_sub_571_i8 ?_ + intro b hb + exact common_sub_571_i8 (mem_commonEnvelope childrenD_571_i8 b hb) +def required_571_i7 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (3, 6), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571_i7 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571_i7 : Fin 2 → Finset Cell := ![(placed21 7 (4, 7) required_0), required_571_i8] +def childrenD_571_i7 : Fin 2 → Finset Cell := ![(placed21 7 (4, 7) envelope_0), envelope_571_i8] +theorem common_sub_571_i7 : commonEnvelope childrenD_571_i7 ⊆ insert (4, 5) required_571_i7 := by decide +kernel +theorem child_required_sub_571_i7 : ∀ j, childrenC_571_i7 j ⊆ insert (4, 5) required_571_i7 := by decide +kernel +theorem child_envelope_sub_571_i7 : ∀ j, childrenD_571_i7 j ⊆ envelope_571_i7 := by decide +kernel +theorem pivot_mem_571_i7 : (4, 5) ∈ envelope_571_i7 := by decide +kernel +theorem children_work_571_i7 : ∀ j, Template HasSnaky 8 (childrenC_571_i7 j) (childrenD_571_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (4, 7)).mono (by decide +kernel) + · exact row_works_571_i8.mono (by decide +kernel) +theorem row_works_571_i7 : Template HasSnaky 9 required_571_i7 envelope_571_i7 := by + refine compose HasSnaky 8 childrenC_571_i7 childrenD_571_i7 children_work_571_i7 (4, 5) + required_571_i7 envelope_571_i7 pivot_mem_571_i7 child_required_sub_571_i7 child_envelope_sub_571_i7 ?_ + intro b hb + exact common_sub_571_i7 (mem_commonEnvelope childrenD_571_i7 b hb) +def required_571_i6 : Finset Cell := ⟨(([(0, 3), (3, 3), (3, 4), (3, 6), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571_i6 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (3, 3), (3, 4), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571_i6 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_1), required_571_i7] +def childrenD_571_i6 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_1), envelope_571_i7] +theorem common_sub_571_i6 : commonEnvelope childrenD_571_i6 ⊆ insert (2, 3) required_571_i6 := by decide +kernel +theorem child_required_sub_571_i6 : ∀ j, childrenC_571_i6 j ⊆ insert (2, 3) required_571_i6 := by decide +kernel +theorem child_envelope_sub_571_i6 : ∀ j, childrenD_571_i6 j ⊆ envelope_571_i6 := by decide +kernel +theorem pivot_mem_571_i6 : (2, 3) ∈ envelope_571_i6 := by decide +kernel +theorem children_work_571_i6 : ∀ j, Template HasSnaky 9 (childrenC_571_i6 j) (childrenD_571_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (0, 3)).mono (by decide +kernel) + · exact row_works_571_i7.mono (by decide +kernel) +theorem row_works_571_i6 : Template HasSnaky 10 required_571_i6 envelope_571_i6 := by + refine compose HasSnaky 9 childrenC_571_i6 childrenD_571_i6 children_work_571_i6 (2, 3) + required_571_i6 envelope_571_i6 pivot_mem_571_i6 child_required_sub_571_i6 child_envelope_sub_571_i6 ?_ + intro b hb + exact common_sub_571_i6 (mem_commonEnvelope childrenD_571_i6 b hb) +def required_571 : Finset Cell := ⟨(([(0, 3), (3, 3), (3, 4), (3, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_571 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 3), (2, 7), (3, 3), (3, 4), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_571 : Fin 7 → Finset Cell := ![(placed21 4 (3, 7) required_250), (placed21 0 (0, 1) required_569), required_571_i0, required_571_i2, required_571_i4, required_570, required_571_i6] +def childrenD_571 : Fin 7 → Finset Cell := ![(placed21 4 (3, 7) envelope_250), (placed21 0 (0, 1) envelope_569), envelope_571_i0, envelope_571_i2, envelope_571_i4, envelope_570, envelope_571_i6] +theorem common_sub_571 : commonEnvelope childrenD_571 ⊆ insert (4, 4) required_571 := by decide +kernel +theorem child_required_sub_571 : ∀ j, childrenC_571 j ⊆ insert (4, 4) required_571 := by decide +kernel +theorem child_envelope_sub_571 : ∀ j, childrenD_571 j ⊆ envelope_571 := by decide +kernel +theorem pivot_mem_571 : (4, 4) ∈ envelope_571 := by decide +kernel +theorem children_work_571 : ∀ j, Template HasSnaky 11 (childrenC_571 j) (childrenD_571 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_250 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_569 0 (0, 1)).mono (by decide +kernel) + · exact row_works_571_i0.mono (by decide +kernel) + · exact row_works_571_i2.mono (by decide +kernel) + · exact row_works_571_i4.mono (by decide +kernel) + · exact row_works_570.mono (by decide +kernel) + · exact row_works_571_i6.mono (by decide +kernel) +theorem row_works_571 : Template HasSnaky 12 required_571 envelope_571 := by + refine compose HasSnaky 11 childrenC_571 childrenD_571 children_work_571 (4, 4) + required_571 envelope_571 pivot_mem_571 child_required_sub_571 child_envelope_sub_571 ?_ + intro b hb + exact common_sub_571 (mem_commonEnvelope childrenD_571 b hb) +def required_587 : Finset Cell := ⟨(([(2, 3), (2, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_587 : Finset Cell := ⟨(([(0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_587 : Fin 6 → Finset Cell := ![(placed21 0 (1, 1) required_12), (placed21 2 (3, 1) required_12), (placed21 4 (1, 7) required_12), (placed21 6 (3, 7) required_12), (placed21 1 (0, 2) required_586), (placed21 3 (0, 6) required_586)] +def childrenD_587 : Fin 6 → Finset Cell := ![(placed21 0 (1, 1) envelope_12), (placed21 2 (3, 1) envelope_12), (placed21 4 (1, 7) envelope_12), (placed21 6 (3, 7) envelope_12), (placed21 1 (0, 2) envelope_586), (placed21 3 (0, 6) envelope_586)] +theorem common_sub_587 : commonEnvelope childrenD_587 ⊆ insert (2, 5) required_587 := by decide +kernel +theorem child_required_sub_587 : ∀ j, childrenC_587 j ⊆ insert (2, 5) required_587 := by decide +kernel +theorem child_envelope_sub_587 : ∀ j, childrenD_587 j ⊆ envelope_587 := by decide +kernel +theorem pivot_mem_587 : (2, 5) ∈ envelope_587 := by decide +kernel +theorem children_work_587 : ∀ j, Template HasSnaky 11 (childrenC_587 j) (childrenD_587 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_12 2 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_12 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_12 6 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_586 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_586 3 (0, 6)).mono (by decide +kernel) +theorem row_works_587 : Template HasSnaky 12 required_587 envelope_587 := by + refine compose HasSnaky 11 childrenC_587 childrenD_587 children_work_587 (2, 5) + required_587 envelope_587 pivot_mem_587 child_required_sub_587 child_envelope_sub_587 ?_ + intro b hb + exact common_sub_587 (mem_commonEnvelope childrenD_587 b hb) +def required_588 : Finset Cell := ⟨(([(1, 2), (1, 3), (2, 3), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_588 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_588 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) required_42), (placed21 3 (0, 3) required_289), (placed21 0 (1, 0) required_291), (placed21 1 (2, 0) required_586)] +def childrenD_588 : Fin 4 → Finset Cell := ![(placed21 1 (0, 2) envelope_42), (placed21 3 (0, 3) envelope_289), (placed21 0 (1, 0) envelope_291), (placed21 1 (2, 0) envelope_586)] +theorem common_sub_588 : commonEnvelope childrenD_588 ⊆ insert (4, 3) required_588 := by decide +kernel +theorem child_required_sub_588 : ∀ j, childrenC_588 j ⊆ insert (4, 3) required_588 := by decide +kernel +theorem child_envelope_sub_588 : ∀ j, childrenD_588 j ⊆ envelope_588 := by decide +kernel +theorem pivot_mem_588 : (4, 3) ∈ envelope_588 := by decide +kernel +theorem children_work_588 : ∀ j, Template HasSnaky 11 (childrenC_588 j) (childrenD_588 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_42 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_289 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_291 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_586 1 (2, 0)).mono (by decide +kernel) +theorem row_works_588 : Template HasSnaky 12 required_588 envelope_588 := by + refine compose HasSnaky 11 childrenC_588 childrenD_588 children_work_588 (4, 3) + required_588 envelope_588 pivot_mem_588 child_required_sub_588 child_envelope_sub_588 ?_ + intro b hb + exact common_sub_588 (mem_commonEnvelope childrenD_588 b hb) +def height_551_i7 : ℕ := 4 +def childrenH_551_i7 : Fin 2 → ℕ := ![height_6, height_78] +theorem height_exact_551_i7 : height_551_i7 = 1 + Finset.univ.sup childrenH_551_i7 := by decide +kernel +theorem required_origin_551_i7 : ∀ x ∈ required_551_i7, + (∃ j, x ∈ childrenC_551_i7 j) ∨ ∀ j, x ∈ childrenD_551_i7 j := by decide +kernel +theorem required_exact_551_i7 : required_551_i7 = + ((Finset.univ.biUnion childrenC_551_i7) ∪ commonEnvelope childrenD_551_i7).erase (3, 3) := by + exact required_eq_combination childrenC_551_i7 childrenD_551_i7 (3, 3) required_551_i7 + (by decide +kernel) child_required_sub_551_i7 common_sub_551_i7 required_origin_551_i7 +theorem envelope_origin_551_i7 : ∀ x ∈ envelope_551_i7, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_551_i7 j := by decide +kernel +theorem envelope_exact_551_i7 : envelope_551_i7 = + insert (3, 3) (Finset.univ.biUnion childrenD_551_i7) := by + exact envelope_eq_combination childrenD_551_i7 (3, 3) envelope_551_i7 + pivot_mem_551_i7 child_envelope_sub_551_i7 envelope_origin_551_i7 +def checked_551_i7 : CheckedCard where + required := required_551_i7 + envelope := envelope_551_i7 + height := height_551_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_551_i7 +def height_551_i8 : ℕ := 3 +def childrenH_551_i8 : Fin 2 → ℕ := ![height_4, height_6] +theorem height_exact_551_i8 : height_551_i8 = 1 + Finset.univ.sup childrenH_551_i8 := by decide +kernel +theorem required_origin_551_i8 : ∀ x ∈ required_551_i8, + (∃ j, x ∈ childrenC_551_i8 j) ∨ ∀ j, x ∈ childrenD_551_i8 j := by decide +kernel +theorem required_exact_551_i8 : required_551_i8 = + ((Finset.univ.biUnion childrenC_551_i8) ∪ commonEnvelope childrenD_551_i8).erase (3, 3) := by + exact required_eq_combination childrenC_551_i8 childrenD_551_i8 (3, 3) required_551_i8 + (by decide +kernel) child_required_sub_551_i8 common_sub_551_i8 required_origin_551_i8 +theorem envelope_origin_551_i8 : ∀ x ∈ envelope_551_i8, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_551_i8 j := by decide +kernel +theorem envelope_exact_551_i8 : envelope_551_i8 = + insert (3, 3) (Finset.univ.biUnion childrenD_551_i8) := by + exact envelope_eq_combination childrenD_551_i8 (3, 3) envelope_551_i8 + pivot_mem_551_i8 child_envelope_sub_551_i8 envelope_origin_551_i8 +def checked_551_i8 : CheckedCard where + required := required_551_i8 + envelope := envelope_551_i8 + height := height_551_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_551_i8 +def height_551_i6 : ℕ := 5 +def childrenH_551_i6 : Fin 3 → ℕ := ![height_25, height_551_i7, height_551_i8] +theorem height_exact_551_i6 : height_551_i6 = 1 + Finset.univ.sup childrenH_551_i6 := by decide +kernel +theorem required_origin_551_i6 : ∀ x ∈ required_551_i6, + (∃ j, x ∈ childrenC_551_i6 j) ∨ ∀ j, x ∈ childrenD_551_i6 j := by decide +kernel +theorem required_exact_551_i6 : required_551_i6 = + ((Finset.univ.biUnion childrenC_551_i6) ∪ commonEnvelope childrenD_551_i6).erase (4, 3) := by + exact required_eq_combination childrenC_551_i6 childrenD_551_i6 (4, 3) required_551_i6 + (by decide +kernel) child_required_sub_551_i6 common_sub_551_i6 required_origin_551_i6 +theorem envelope_origin_551_i6 : ∀ x ∈ envelope_551_i6, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_551_i6 j := by decide +kernel +theorem envelope_exact_551_i6 : envelope_551_i6 = + insert (4, 3) (Finset.univ.biUnion childrenD_551_i6) := by + exact envelope_eq_combination childrenD_551_i6 (4, 3) envelope_551_i6 + pivot_mem_551_i6 child_envelope_sub_551_i6 envelope_origin_551_i6 +def checked_551_i6 : CheckedCard where + required := required_551_i6 + envelope := envelope_551_i6 + height := height_551_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_551_i6 +def height_551_i5 : ℕ := 6 +def childrenH_551_i5 : Fin 2 → ℕ := ![height_5, height_551_i6] +theorem height_exact_551_i5 : height_551_i5 = 1 + Finset.univ.sup childrenH_551_i5 := by decide +kernel +theorem required_origin_551_i5 : ∀ x ∈ required_551_i5, + (∃ j, x ∈ childrenC_551_i5 j) ∨ ∀ j, x ∈ childrenD_551_i5 j := by decide +kernel +theorem required_exact_551_i5 : required_551_i5 = + ((Finset.univ.biUnion childrenC_551_i5) ∪ commonEnvelope childrenD_551_i5).erase (7, 3) := by + exact required_eq_combination childrenC_551_i5 childrenD_551_i5 (7, 3) required_551_i5 + (by decide +kernel) child_required_sub_551_i5 common_sub_551_i5 required_origin_551_i5 +theorem envelope_origin_551_i5 : ∀ x ∈ envelope_551_i5, + x = (7, 3) ∨ ∃ j, x ∈ childrenD_551_i5 j := by decide +kernel +theorem envelope_exact_551_i5 : envelope_551_i5 = + insert (7, 3) (Finset.univ.biUnion childrenD_551_i5) := by + exact envelope_eq_combination childrenD_551_i5 (7, 3) envelope_551_i5 + pivot_mem_551_i5 child_envelope_sub_551_i5 envelope_origin_551_i5 +def checked_551_i5 : CheckedCard where + required := required_551_i5 + envelope := envelope_551_i5 + height := height_551_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_551_i5 +def height_551_i4 : ℕ := 7 +def childrenH_551_i4 : Fin 2 → ℕ := ![height_5, height_551_i5] +theorem height_exact_551_i4 : height_551_i4 = 1 + Finset.univ.sup childrenH_551_i4 := by decide +kernel +theorem required_origin_551_i4 : ∀ x ∈ required_551_i4, + (∃ j, x ∈ childrenC_551_i4 j) ∨ ∀ j, x ∈ childrenD_551_i4 j := by decide +kernel +theorem required_exact_551_i4 : required_551_i4 = + ((Finset.univ.biUnion childrenC_551_i4) ∪ commonEnvelope childrenD_551_i4).erase (5, 3) := by + exact required_eq_combination childrenC_551_i4 childrenD_551_i4 (5, 3) required_551_i4 + (by decide +kernel) child_required_sub_551_i4 common_sub_551_i4 required_origin_551_i4 +theorem envelope_origin_551_i4 : ∀ x ∈ envelope_551_i4, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_551_i4 j := by decide +kernel +theorem envelope_exact_551_i4 : envelope_551_i4 = + insert (5, 3) (Finset.univ.biUnion childrenD_551_i4) := by + exact envelope_eq_combination childrenD_551_i4 (5, 3) envelope_551_i4 + pivot_mem_551_i4 child_envelope_sub_551_i4 envelope_origin_551_i4 +def checked_551_i4 : CheckedCard where + required := required_551_i4 + envelope := envelope_551_i4 + height := height_551_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_551_i4 +def height_551_i3 : ℕ := 8 +def childrenH_551_i3 : Fin 2 → ℕ := ![height_1, height_551_i4] +theorem height_exact_551_i3 : height_551_i3 = 1 + Finset.univ.sup childrenH_551_i3 := by decide +kernel +theorem required_origin_551_i3 : ∀ x ∈ required_551_i3, + (∃ j, x ∈ childrenC_551_i3 j) ∨ ∀ j, x ∈ childrenD_551_i3 j := by decide +kernel +theorem required_exact_551_i3 : required_551_i3 = + ((Finset.univ.biUnion childrenC_551_i3) ∪ commonEnvelope childrenD_551_i3).erase (2, 5) := by + exact required_eq_combination childrenC_551_i3 childrenD_551_i3 (2, 5) required_551_i3 + (by decide +kernel) child_required_sub_551_i3 common_sub_551_i3 required_origin_551_i3 +theorem envelope_origin_551_i3 : ∀ x ∈ envelope_551_i3, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_551_i3 j := by decide +kernel +theorem envelope_exact_551_i3 : envelope_551_i3 = + insert (2, 5) (Finset.univ.biUnion childrenD_551_i3) := by + exact envelope_eq_combination childrenD_551_i3 (2, 5) envelope_551_i3 + pivot_mem_551_i3 child_envelope_sub_551_i3 envelope_origin_551_i3 +def checked_551_i3 : CheckedCard where + required := required_551_i3 + envelope := envelope_551_i3 + height := height_551_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_551_i3 +def height_551_i2 : ℕ := 9 +def childrenH_551_i2 : Fin 2 → ℕ := ![height_5, height_551_i3] +theorem height_exact_551_i2 : height_551_i2 = 1 + Finset.univ.sup childrenH_551_i2 := by decide +kernel +theorem required_origin_551_i2 : ∀ x ∈ required_551_i2, + (∃ j, x ∈ childrenC_551_i2 j) ∨ ∀ j, x ∈ childrenD_551_i2 j := by decide +kernel +theorem required_exact_551_i2 : required_551_i2 = + ((Finset.univ.biUnion childrenC_551_i2) ∪ commonEnvelope childrenD_551_i2).erase (5, 6) := by + exact required_eq_combination childrenC_551_i2 childrenD_551_i2 (5, 6) required_551_i2 + (by decide +kernel) child_required_sub_551_i2 common_sub_551_i2 required_origin_551_i2 +theorem envelope_origin_551_i2 : ∀ x ∈ envelope_551_i2, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_551_i2 j := by decide +kernel +theorem envelope_exact_551_i2 : envelope_551_i2 = + insert (5, 6) (Finset.univ.biUnion childrenD_551_i2) := by + exact envelope_eq_combination childrenD_551_i2 (5, 6) envelope_551_i2 + pivot_mem_551_i2 child_envelope_sub_551_i2 envelope_origin_551_i2 +def checked_551_i2 : CheckedCard where + required := required_551_i2 + envelope := envelope_551_i2 + height := height_551_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_551_i2 +def height_551_i1 : ℕ := 10 +def childrenH_551_i1 : Fin 4 → ℕ := ![height_19, height_84, height_314, height_551_i2] +theorem height_exact_551_i1 : height_551_i1 = 1 + Finset.univ.sup childrenH_551_i1 := by decide +kernel +theorem required_origin_551_i1 : ∀ x ∈ required_551_i1, + (∃ j, x ∈ childrenC_551_i1 j) ∨ ∀ j, x ∈ childrenD_551_i1 j := by decide +kernel +theorem required_exact_551_i1 : required_551_i1 = + ((Finset.univ.biUnion childrenC_551_i1) ∪ commonEnvelope childrenD_551_i1).erase (6, 6) := by + exact required_eq_combination childrenC_551_i1 childrenD_551_i1 (6, 6) required_551_i1 + (by decide +kernel) child_required_sub_551_i1 common_sub_551_i1 required_origin_551_i1 +theorem envelope_origin_551_i1 : ∀ x ∈ envelope_551_i1, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_551_i1 j := by decide +kernel +theorem envelope_exact_551_i1 : envelope_551_i1 = + insert (6, 6) (Finset.univ.biUnion childrenD_551_i1) := by + exact envelope_eq_combination childrenD_551_i1 (6, 6) envelope_551_i1 + pivot_mem_551_i1 child_envelope_sub_551_i1 envelope_origin_551_i1 +def checked_551_i1 : CheckedCard where + required := required_551_i1 + envelope := envelope_551_i1 + height := height_551_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_551_i1 +def height_551_i0 : ℕ := 11 +def childrenH_551_i0 : Fin 4 → ℕ := ![height_10, height_44, height_63, height_551_i1] +theorem height_exact_551_i0 : height_551_i0 = 1 + Finset.univ.sup childrenH_551_i0 := by decide +kernel +theorem required_origin_551_i0 : ∀ x ∈ required_551_i0, + (∃ j, x ∈ childrenC_551_i0 j) ∨ ∀ j, x ∈ childrenD_551_i0 j := by decide +kernel +theorem required_exact_551_i0 : required_551_i0 = + ((Finset.univ.biUnion childrenC_551_i0) ∪ commonEnvelope childrenD_551_i0).erase (6, 3) := by + exact required_eq_combination childrenC_551_i0 childrenD_551_i0 (6, 3) required_551_i0 + (by decide +kernel) child_required_sub_551_i0 common_sub_551_i0 required_origin_551_i0 +theorem envelope_origin_551_i0 : ∀ x ∈ envelope_551_i0, + x = (6, 3) ∨ ∃ j, x ∈ childrenD_551_i0 j := by decide +kernel +theorem envelope_exact_551_i0 : envelope_551_i0 = + insert (6, 3) (Finset.univ.biUnion childrenD_551_i0) := by + exact envelope_eq_combination childrenD_551_i0 (6, 3) envelope_551_i0 + pivot_mem_551_i0 child_envelope_sub_551_i0 envelope_origin_551_i0 +def checked_551_i0 : CheckedCard where + required := required_551_i0 + envelope := envelope_551_i0 + height := height_551_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_551_i0 +def height_551 : ℕ := 12 +def childrenH_551 : Fin 3 → ℕ := ![height_52, height_523, height_551_i0] +theorem height_exact_551 : height_551 = 1 + Finset.univ.sup childrenH_551 := by decide +kernel +theorem required_origin_551 : ∀ x ∈ required_551, + (∃ j, x ∈ childrenC_551 j) ∨ ∀ j, x ∈ childrenD_551 j := by decide +kernel +theorem required_exact_551 : required_551 = + ((Finset.univ.biUnion childrenC_551) ∪ commonEnvelope childrenD_551).erase (6, 4) := by + exact required_eq_combination childrenC_551 childrenD_551 (6, 4) required_551 + (by decide +kernel) child_required_sub_551 common_sub_551 required_origin_551 +theorem envelope_origin_551 : ∀ x ∈ envelope_551, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_551 j := by decide +kernel +theorem envelope_exact_551 : envelope_551 = + insert (6, 4) (Finset.univ.biUnion childrenD_551) := by + exact envelope_eq_combination childrenD_551 (6, 4) envelope_551 + pivot_mem_551 child_envelope_sub_551 envelope_origin_551 +def checked_551 : CheckedCard where + required := required_551 + envelope := envelope_551 + height := height_551 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_551 +def height_571_i1 : ℕ := 10 +def childrenH_571_i1 : Fin 4 → ℕ := ![height_287, height_288, height_345, height_457] +theorem height_exact_571_i1 : height_571_i1 = 1 + Finset.univ.sup childrenH_571_i1 := by decide +kernel +theorem required_origin_571_i1 : ∀ x ∈ required_571_i1, + (∃ j, x ∈ childrenC_571_i1 j) ∨ ∀ j, x ∈ childrenD_571_i1 j := by decide +kernel +theorem required_exact_571_i1 : required_571_i1 = + ((Finset.univ.biUnion childrenC_571_i1) ∪ commonEnvelope childrenD_571_i1).erase (5, 6) := by + exact required_eq_combination childrenC_571_i1 childrenD_571_i1 (5, 6) required_571_i1 + (by decide +kernel) child_required_sub_571_i1 common_sub_571_i1 required_origin_571_i1 +theorem envelope_origin_571_i1 : ∀ x ∈ envelope_571_i1, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_571_i1 j := by decide +kernel +theorem envelope_exact_571_i1 : envelope_571_i1 = + insert (5, 6) (Finset.univ.biUnion childrenD_571_i1) := by + exact envelope_eq_combination childrenD_571_i1 (5, 6) envelope_571_i1 + pivot_mem_571_i1 child_envelope_sub_571_i1 envelope_origin_571_i1 +def checked_571_i1 : CheckedCard where + required := required_571_i1 + envelope := envelope_571_i1 + height := height_571_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571_i1 +def height_571_i0 : ℕ := 11 +def childrenH_571_i0 : Fin 2 → ℕ := ![height_2, height_571_i1] +theorem height_exact_571_i0 : height_571_i0 = 1 + Finset.univ.sup childrenH_571_i0 := by decide +kernel +theorem required_origin_571_i0 : ∀ x ∈ required_571_i0, + (∃ j, x ∈ childrenC_571_i0 j) ∨ ∀ j, x ∈ childrenD_571_i0 j := by decide +kernel +theorem required_exact_571_i0 : required_571_i0 = + ((Finset.univ.biUnion childrenC_571_i0) ∪ commonEnvelope childrenD_571_i0).erase (4, 7) := by + exact required_eq_combination childrenC_571_i0 childrenD_571_i0 (4, 7) required_571_i0 + (by decide +kernel) child_required_sub_571_i0 common_sub_571_i0 required_origin_571_i0 +theorem envelope_origin_571_i0 : ∀ x ∈ envelope_571_i0, + x = (4, 7) ∨ ∃ j, x ∈ childrenD_571_i0 j := by decide +kernel +theorem envelope_exact_571_i0 : envelope_571_i0 = + insert (4, 7) (Finset.univ.biUnion childrenD_571_i0) := by + exact envelope_eq_combination childrenD_571_i0 (4, 7) envelope_571_i0 + pivot_mem_571_i0 child_envelope_sub_571_i0 envelope_origin_571_i0 +def checked_571_i0 : CheckedCard where + required := required_571_i0 + envelope := envelope_571_i0 + height := height_571_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571_i0 +def height_571_i3 : ℕ := 8 +def childrenH_571_i3 : Fin 2 → ℕ := ![height_5, height_446] +theorem height_exact_571_i3 : height_571_i3 = 1 + Finset.univ.sup childrenH_571_i3 := by decide +kernel +theorem required_origin_571_i3 : ∀ x ∈ required_571_i3, + (∃ j, x ∈ childrenC_571_i3 j) ∨ ∀ j, x ∈ childrenD_571_i3 j := by decide +kernel +theorem required_exact_571_i3 : required_571_i3 = + ((Finset.univ.biUnion childrenC_571_i3) ∪ commonEnvelope childrenD_571_i3).erase (4, 3) := by + exact required_eq_combination childrenC_571_i3 childrenD_571_i3 (4, 3) required_571_i3 + (by decide +kernel) child_required_sub_571_i3 common_sub_571_i3 required_origin_571_i3 +theorem envelope_origin_571_i3 : ∀ x ∈ envelope_571_i3, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_571_i3 j := by decide +kernel +theorem envelope_exact_571_i3 : envelope_571_i3 = + insert (4, 3) (Finset.univ.biUnion childrenD_571_i3) := by + exact envelope_eq_combination childrenD_571_i3 (4, 3) envelope_571_i3 + pivot_mem_571_i3 child_envelope_sub_571_i3 envelope_origin_571_i3 +def checked_571_i3 : CheckedCard where + required := required_571_i3 + envelope := envelope_571_i3 + height := height_571_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571_i3 +def height_571_i2 : ℕ := 9 +def childrenH_571_i2 : Fin 2 → ℕ := ![height_0, height_571_i3] +theorem height_exact_571_i2 : height_571_i2 = 1 + Finset.univ.sup childrenH_571_i2 := by decide +kernel +theorem required_origin_571_i2 : ∀ x ∈ required_571_i2, + (∃ j, x ∈ childrenC_571_i2 j) ∨ ∀ j, x ∈ childrenD_571_i2 j := by decide +kernel +theorem required_exact_571_i2 : required_571_i2 = + ((Finset.univ.biUnion childrenC_571_i2) ∪ commonEnvelope childrenD_571_i2).erase (4, 5) := by + exact required_eq_combination childrenC_571_i2 childrenD_571_i2 (4, 5) required_571_i2 + (by decide +kernel) child_required_sub_571_i2 common_sub_571_i2 required_origin_571_i2 +theorem envelope_origin_571_i2 : ∀ x ∈ envelope_571_i2, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_571_i2 j := by decide +kernel +theorem envelope_exact_571_i2 : envelope_571_i2 = + insert (4, 5) (Finset.univ.biUnion childrenD_571_i2) := by + exact envelope_eq_combination childrenD_571_i2 (4, 5) envelope_571_i2 + pivot_mem_571_i2 child_envelope_sub_571_i2 envelope_origin_571_i2 +def checked_571_i2 : CheckedCard where + required := required_571_i2 + envelope := envelope_571_i2 + height := height_571_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571_i2 +def height_571_i5 : ℕ := 7 +def childrenH_571_i5 : Fin 2 → ℕ := ![height_5, height_283] +theorem height_exact_571_i5 : height_571_i5 = 1 + Finset.univ.sup childrenH_571_i5 := by decide +kernel +theorem required_origin_571_i5 : ∀ x ∈ required_571_i5, + (∃ j, x ∈ childrenC_571_i5 j) ∨ ∀ j, x ∈ childrenD_571_i5 j := by decide +kernel +theorem required_exact_571_i5 : required_571_i5 = + ((Finset.univ.biUnion childrenC_571_i5) ∪ commonEnvelope childrenD_571_i5).erase (4, 3) := by + exact required_eq_combination childrenC_571_i5 childrenD_571_i5 (4, 3) required_571_i5 + (by decide +kernel) child_required_sub_571_i5 common_sub_571_i5 required_origin_571_i5 +theorem envelope_origin_571_i5 : ∀ x ∈ envelope_571_i5, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_571_i5 j := by decide +kernel +theorem envelope_exact_571_i5 : envelope_571_i5 = + insert (4, 3) (Finset.univ.biUnion childrenD_571_i5) := by + exact envelope_eq_combination childrenD_571_i5 (4, 3) envelope_571_i5 + pivot_mem_571_i5 child_envelope_sub_571_i5 envelope_origin_571_i5 +def checked_571_i5 : CheckedCard where + required := required_571_i5 + envelope := envelope_571_i5 + height := height_571_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571_i5 +def height_571_i4 : ℕ := 8 +def childrenH_571_i4 : Fin 2 → ℕ := ![height_0, height_571_i5] +theorem height_exact_571_i4 : height_571_i4 = 1 + Finset.univ.sup childrenH_571_i4 := by decide +kernel +theorem required_origin_571_i4 : ∀ x ∈ required_571_i4, + (∃ j, x ∈ childrenC_571_i4 j) ∨ ∀ j, x ∈ childrenD_571_i4 j := by decide +kernel +theorem required_exact_571_i4 : required_571_i4 = + ((Finset.univ.biUnion childrenC_571_i4) ∪ commonEnvelope childrenD_571_i4).erase (4, 5) := by + exact required_eq_combination childrenC_571_i4 childrenD_571_i4 (4, 5) required_571_i4 + (by decide +kernel) child_required_sub_571_i4 common_sub_571_i4 required_origin_571_i4 +theorem envelope_origin_571_i4 : ∀ x ∈ envelope_571_i4, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_571_i4 j := by decide +kernel +theorem envelope_exact_571_i4 : envelope_571_i4 = + insert (4, 5) (Finset.univ.biUnion childrenD_571_i4) := by + exact envelope_eq_combination childrenD_571_i4 (4, 5) envelope_571_i4 + pivot_mem_571_i4 child_envelope_sub_571_i4 envelope_origin_571_i4 +def checked_571_i4 : CheckedCard where + required := required_571_i4 + envelope := envelope_571_i4 + height := height_571_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571_i4 +def height_571_i9 : ℕ := 4 +def childrenH_571_i9 : Fin 2 → ℕ := ![height_5, height_29] +theorem height_exact_571_i9 : height_571_i9 = 1 + Finset.univ.sup childrenH_571_i9 := by decide +kernel +theorem required_origin_571_i9 : ∀ x ∈ required_571_i9, + (∃ j, x ∈ childrenC_571_i9 j) ∨ ∀ j, x ∈ childrenD_571_i9 j := by decide +kernel +theorem required_exact_571_i9 : required_571_i9 = + ((Finset.univ.biUnion childrenC_571_i9) ∪ commonEnvelope childrenD_571_i9).erase (5, 3) := by + exact required_eq_combination childrenC_571_i9 childrenD_571_i9 (5, 3) required_571_i9 + (by decide +kernel) child_required_sub_571_i9 common_sub_571_i9 required_origin_571_i9 +theorem envelope_origin_571_i9 : ∀ x ∈ envelope_571_i9, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_571_i9 j := by decide +kernel +theorem envelope_exact_571_i9 : envelope_571_i9 = + insert (5, 3) (Finset.univ.biUnion childrenD_571_i9) := by + exact envelope_eq_combination childrenD_571_i9 (5, 3) envelope_571_i9 + pivot_mem_571_i9 child_envelope_sub_571_i9 envelope_origin_571_i9 +def checked_571_i9 : CheckedCard where + required := required_571_i9 + envelope := envelope_571_i9 + height := height_571_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571_i9 +def height_571_i8 : ℕ := 8 +def childrenH_571_i8 : Fin 3 → ℕ := ![height_7, height_571_i9, height_446] +theorem height_exact_571_i8 : height_571_i8 = 1 + Finset.univ.sup childrenH_571_i8 := by decide +kernel +theorem required_origin_571_i8 : ∀ x ∈ required_571_i8, + (∃ j, x ∈ childrenC_571_i8 j) ∨ ∀ j, x ∈ childrenD_571_i8 j := by decide +kernel +theorem required_exact_571_i8 : required_571_i8 = + ((Finset.univ.biUnion childrenC_571_i8) ∪ commonEnvelope childrenD_571_i8).erase (4, 3) := by + exact required_eq_combination childrenC_571_i8 childrenD_571_i8 (4, 3) required_571_i8 + (by decide +kernel) child_required_sub_571_i8 common_sub_571_i8 required_origin_571_i8 +theorem envelope_origin_571_i8 : ∀ x ∈ envelope_571_i8, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_571_i8 j := by decide +kernel +theorem envelope_exact_571_i8 : envelope_571_i8 = + insert (4, 3) (Finset.univ.biUnion childrenD_571_i8) := by + exact envelope_eq_combination childrenD_571_i8 (4, 3) envelope_571_i8 + pivot_mem_571_i8 child_envelope_sub_571_i8 envelope_origin_571_i8 +def checked_571_i8 : CheckedCard where + required := required_571_i8 + envelope := envelope_571_i8 + height := height_571_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571_i8 +def height_571_i7 : ℕ := 9 +def childrenH_571_i7 : Fin 2 → ℕ := ![height_0, height_571_i8] +theorem height_exact_571_i7 : height_571_i7 = 1 + Finset.univ.sup childrenH_571_i7 := by decide +kernel +theorem required_origin_571_i7 : ∀ x ∈ required_571_i7, + (∃ j, x ∈ childrenC_571_i7 j) ∨ ∀ j, x ∈ childrenD_571_i7 j := by decide +kernel +theorem required_exact_571_i7 : required_571_i7 = + ((Finset.univ.biUnion childrenC_571_i7) ∪ commonEnvelope childrenD_571_i7).erase (4, 5) := by + exact required_eq_combination childrenC_571_i7 childrenD_571_i7 (4, 5) required_571_i7 + (by decide +kernel) child_required_sub_571_i7 common_sub_571_i7 required_origin_571_i7 +theorem envelope_origin_571_i7 : ∀ x ∈ envelope_571_i7, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_571_i7 j := by decide +kernel +theorem envelope_exact_571_i7 : envelope_571_i7 = + insert (4, 5) (Finset.univ.biUnion childrenD_571_i7) := by + exact envelope_eq_combination childrenD_571_i7 (4, 5) envelope_571_i7 + pivot_mem_571_i7 child_envelope_sub_571_i7 envelope_origin_571_i7 +def checked_571_i7 : CheckedCard where + required := required_571_i7 + envelope := envelope_571_i7 + height := height_571_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571_i7 +def height_571_i6 : ℕ := 10 +def childrenH_571_i6 : Fin 2 → ℕ := ![height_1, height_571_i7] +theorem height_exact_571_i6 : height_571_i6 = 1 + Finset.univ.sup childrenH_571_i6 := by decide +kernel +theorem required_origin_571_i6 : ∀ x ∈ required_571_i6, + (∃ j, x ∈ childrenC_571_i6 j) ∨ ∀ j, x ∈ childrenD_571_i6 j := by decide +kernel +theorem required_exact_571_i6 : required_571_i6 = + ((Finset.univ.biUnion childrenC_571_i6) ∪ commonEnvelope childrenD_571_i6).erase (2, 3) := by + exact required_eq_combination childrenC_571_i6 childrenD_571_i6 (2, 3) required_571_i6 + (by decide +kernel) child_required_sub_571_i6 common_sub_571_i6 required_origin_571_i6 +theorem envelope_origin_571_i6 : ∀ x ∈ envelope_571_i6, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_571_i6 j := by decide +kernel +theorem envelope_exact_571_i6 : envelope_571_i6 = + insert (2, 3) (Finset.univ.biUnion childrenD_571_i6) := by + exact envelope_eq_combination childrenD_571_i6 (2, 3) envelope_571_i6 + pivot_mem_571_i6 child_envelope_sub_571_i6 envelope_origin_571_i6 +def checked_571_i6 : CheckedCard where + required := required_571_i6 + envelope := envelope_571_i6 + height := height_571_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571_i6 +def height_571 : ℕ := 12 +def childrenH_571 : Fin 7 → ℕ := ![height_250, height_569, height_571_i0, height_571_i2, height_571_i4, height_570, height_571_i6] +theorem height_exact_571 : height_571 = 1 + Finset.univ.sup childrenH_571 := by decide +kernel +theorem required_origin_571 : ∀ x ∈ required_571, + (∃ j, x ∈ childrenC_571 j) ∨ ∀ j, x ∈ childrenD_571 j := by decide +kernel +theorem required_exact_571 : required_571 = + ((Finset.univ.biUnion childrenC_571) ∪ commonEnvelope childrenD_571).erase (4, 4) := by + exact required_eq_combination childrenC_571 childrenD_571 (4, 4) required_571 + (by decide +kernel) child_required_sub_571 common_sub_571 required_origin_571 +theorem envelope_origin_571 : ∀ x ∈ envelope_571, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_571 j := by decide +kernel +theorem envelope_exact_571 : envelope_571 = + insert (4, 4) (Finset.univ.biUnion childrenD_571) := by + exact envelope_eq_combination childrenD_571 (4, 4) envelope_571 + pivot_mem_571 child_envelope_sub_571 envelope_origin_571 +def checked_571 : CheckedCard where + required := required_571 + envelope := envelope_571 + height := height_571 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_571 +def height_587 : ℕ := 12 +def childrenH_587 : Fin 6 → ℕ := ![height_12, height_12, height_12, height_12, height_586, height_586] +theorem height_exact_587 : height_587 = 1 + Finset.univ.sup childrenH_587 := by decide +kernel +theorem required_origin_587 : ∀ x ∈ required_587, + (∃ j, x ∈ childrenC_587 j) ∨ ∀ j, x ∈ childrenD_587 j := by decide +kernel +theorem required_exact_587 : required_587 = + ((Finset.univ.biUnion childrenC_587) ∪ commonEnvelope childrenD_587).erase (2, 5) := by + exact required_eq_combination childrenC_587 childrenD_587 (2, 5) required_587 + (by decide +kernel) child_required_sub_587 common_sub_587 required_origin_587 +theorem envelope_origin_587 : ∀ x ∈ envelope_587, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_587 j := by decide +kernel +theorem envelope_exact_587 : envelope_587 = + insert (2, 5) (Finset.univ.biUnion childrenD_587) := by + exact envelope_eq_combination childrenD_587 (2, 5) envelope_587 + pivot_mem_587 child_envelope_sub_587 envelope_origin_587 +def checked_587 : CheckedCard where + required := required_587 + envelope := envelope_587 + height := height_587 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_587 +def height_588 : ℕ := 12 +def childrenH_588 : Fin 4 → ℕ := ![height_42, height_289, height_291, height_586] +theorem height_exact_588 : height_588 = 1 + Finset.univ.sup childrenH_588 := by decide +kernel +theorem required_origin_588 : ∀ x ∈ required_588, + (∃ j, x ∈ childrenC_588 j) ∨ ∀ j, x ∈ childrenD_588 j := by decide +kernel +theorem required_exact_588 : required_588 = + ((Finset.univ.biUnion childrenC_588) ∪ commonEnvelope childrenD_588).erase (4, 3) := by + exact required_eq_combination childrenC_588 childrenD_588 (4, 3) required_588 + (by decide +kernel) child_required_sub_588 common_sub_588 required_origin_588 +theorem envelope_origin_588 : ∀ x ∈ envelope_588, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_588 j := by decide +kernel +theorem envelope_exact_588 : envelope_588 = + insert (4, 3) (Finset.univ.biUnion childrenD_588) := by + exact envelope_eq_combination childrenD_588 (4, 3) envelope_588 + pivot_mem_588 child_envelope_sub_588 envelope_origin_588 +def checked_588 : CheckedCard where + required := required_588 + envelope := envelope_588 + height := height_588 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_588 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part03.lean new file mode 100644 index 0000000..3862e72 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part03.lean @@ -0,0 +1,963 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_599_i6 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 3), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_599_i6 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_599_i6 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) required_5), (placed21 0 (4, 2) required_64)] +def childrenD_599_i6 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) envelope_5), (placed21 0 (4, 2) envelope_64)] +theorem common_sub_599_i6 : commonEnvelope childrenD_599_i6 ⊆ insert (5, 6) required_599_i6 := by decide +kernel +theorem child_required_sub_599_i6 : ∀ j, childrenC_599_i6 j ⊆ insert (5, 6) required_599_i6 := by decide +kernel +theorem child_envelope_sub_599_i6 : ∀ j, childrenD_599_i6 j ⊆ envelope_599_i6 := by decide +kernel +theorem pivot_mem_599_i6 : (5, 6) ∈ envelope_599_i6 := by decide +kernel +theorem children_work_599_i6 : ∀ j, Template HasSnaky 3 (childrenC_599_i6 j) (childrenD_599_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_64 0 (4, 2)).mono (by decide +kernel) +theorem row_works_599_i6 : Template HasSnaky 4 required_599_i6 envelope_599_i6 := by + refine compose HasSnaky 3 childrenC_599_i6 childrenD_599_i6 children_work_599_i6 (5, 6) + required_599_i6 envelope_599_i6 pivot_mem_599_i6 child_required_sub_599_i6 child_envelope_sub_599_i6 ?_ + intro b hb + exact common_sub_599_i6 (mem_commonEnvelope childrenD_599_i6 b hb) +def required_599_i8 : Finset Cell := ⟨(([(3, 4), (4, 3), (4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_599_i8 : Finset Cell := ⟨(([(3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_599_i8 : Fin 2 → Finset Cell := ![(placed21 6 (7, 5) required_0), (placed21 0 (4, 2) required_44)] +def childrenD_599_i8 : Fin 2 → Finset Cell := ![(placed21 6 (7, 5) envelope_0), (placed21 0 (4, 2) envelope_44)] +theorem common_sub_599_i8 : commonEnvelope childrenD_599_i8 ⊆ insert (4, 4) required_599_i8 := by decide +kernel +theorem child_required_sub_599_i8 : ∀ j, childrenC_599_i8 j ⊆ insert (4, 4) required_599_i8 := by decide +kernel +theorem child_envelope_sub_599_i8 : ∀ j, childrenD_599_i8 j ⊆ envelope_599_i8 := by decide +kernel +theorem pivot_mem_599_i8 : (4, 4) ∈ envelope_599_i8 := by decide +kernel +theorem children_work_599_i8 : ∀ j, Template HasSnaky 3 (childrenC_599_i8 j) (childrenD_599_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_44 0 (4, 2)).mono (by decide +kernel) +theorem row_works_599_i8 : Template HasSnaky 4 required_599_i8 envelope_599_i8 := by + refine compose HasSnaky 3 childrenC_599_i8 childrenD_599_i8 children_work_599_i8 (4, 4) + required_599_i8 envelope_599_i8 pivot_mem_599_i8 child_required_sub_599_i8 child_envelope_sub_599_i8 ?_ + intro b hb + exact common_sub_599_i8 (mem_commonEnvelope childrenD_599_i8 b hb) +def required_599_i7 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5), (4, 3), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_599_i7 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (7, 4), (7, 5), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_599_i7 : Fin 3 → Finset Cell := ![(placed21 3 (2, 5) required_6), (placed21 3 (3, 5) required_16), required_599_i8] +def childrenD_599_i7 : Fin 3 → Finset Cell := ![(placed21 3 (2, 5) envelope_6), (placed21 3 (3, 5) envelope_16), envelope_599_i8] +theorem common_sub_599_i7 : commonEnvelope childrenD_599_i7 ⊆ insert (6, 5) required_599_i7 := by decide +kernel +theorem child_required_sub_599_i7 : ∀ j, childrenC_599_i7 j ⊆ insert (6, 5) required_599_i7 := by decide +kernel +theorem child_envelope_sub_599_i7 : ∀ j, childrenD_599_i7 j ⊆ envelope_599_i7 := by decide +kernel +theorem pivot_mem_599_i7 : (6, 5) ∈ envelope_599_i7 := by decide +kernel +theorem children_work_599_i7 : ∀ j, Template HasSnaky 4 (childrenC_599_i7 j) (childrenD_599_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_16 3 (3, 5)).mono (by decide +kernel) + · exact row_works_599_i8.mono (by decide +kernel) +theorem row_works_599_i7 : Template HasSnaky 5 required_599_i7 envelope_599_i7 := by + refine compose HasSnaky 4 childrenC_599_i7 childrenD_599_i7 children_work_599_i7 (6, 5) + required_599_i7 envelope_599_i7 pivot_mem_599_i7 child_required_sub_599_i7 child_envelope_sub_599_i7 ?_ + intro b hb + exact common_sub_599_i7 (mem_commonEnvelope childrenD_599_i7 b hb) +def required_599_i5 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_599_i5 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_599_i5 : Fin 5 → Finset Cell := ![(placed21 0 (2, 4) required_8), (placed21 1 (2, 4) required_17), (placed21 1 (2, 4) required_41), required_599_i6, required_599_i7] +def childrenD_599_i5 : Fin 5 → Finset Cell := ![(placed21 0 (2, 4) envelope_8), (placed21 1 (2, 4) envelope_17), (placed21 1 (2, 4) envelope_41), envelope_599_i6, envelope_599_i7] +theorem common_sub_599_i5 : commonEnvelope childrenD_599_i5 ⊆ insert (5, 5) required_599_i5 := by decide +kernel +theorem child_required_sub_599_i5 : ∀ j, childrenC_599_i5 j ⊆ insert (5, 5) required_599_i5 := by decide +kernel +theorem child_envelope_sub_599_i5 : ∀ j, childrenD_599_i5 j ⊆ envelope_599_i5 := by decide +kernel +theorem pivot_mem_599_i5 : (5, 5) ∈ envelope_599_i5 := by decide +kernel +theorem children_work_599_i5 : ∀ j, Template HasSnaky 5 (childrenC_599_i5 j) (childrenD_599_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_17 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_41 1 (2, 4)).mono (by decide +kernel) + · exact row_works_599_i6.mono (by decide +kernel) + · exact row_works_599_i7.mono (by decide +kernel) +theorem row_works_599_i5 : Template HasSnaky 6 required_599_i5 envelope_599_i5 := by + refine compose HasSnaky 5 childrenC_599_i5 childrenD_599_i5 children_work_599_i5 (5, 5) + required_599_i5 envelope_599_i5 pivot_mem_599_i5 child_required_sub_599_i5 child_envelope_sub_599_i5 ?_ + intro b hb + exact common_sub_599_i5 (mem_commonEnvelope childrenD_599_i5 b hb) +def required_599_i4 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_599_i4 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_599_i4 : Fin 2 → Finset Cell := ![(placed21 5 (3, 2) required_5), required_599_i5] +def childrenD_599_i4 : Fin 2 → Finset Cell := ![(placed21 5 (3, 2) envelope_5), envelope_599_i5] +theorem common_sub_599_i4 : commonEnvelope childrenD_599_i4 ⊆ insert (2, 5) required_599_i4 := by decide +kernel +theorem child_required_sub_599_i4 : ∀ j, childrenC_599_i4 j ⊆ insert (2, 5) required_599_i4 := by decide +kernel +theorem child_envelope_sub_599_i4 : ∀ j, childrenD_599_i4 j ⊆ envelope_599_i4 := by decide +kernel +theorem pivot_mem_599_i4 : (2, 5) ∈ envelope_599_i4 := by decide +kernel +theorem children_work_599_i4 : ∀ j, Template HasSnaky 6 (childrenC_599_i4 j) (childrenD_599_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (3, 2)).mono (by decide +kernel) + · exact row_works_599_i5.mono (by decide +kernel) +theorem row_works_599_i4 : Template HasSnaky 7 required_599_i4 envelope_599_i4 := by + refine compose HasSnaky 6 childrenC_599_i4 childrenD_599_i4 children_work_599_i4 (2, 5) + required_599_i4 envelope_599_i4 pivot_mem_599_i4 child_required_sub_599_i4 child_envelope_sub_599_i4 ?_ + intro b hb + exact common_sub_599_i4 (mem_commonEnvelope childrenD_599_i4 b hb) +def required_599_i3 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_599_i3 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_599_i3 : Fin 2 → Finset Cell := ![(placed21 1 (3, 2) required_5), required_599_i4] +def childrenD_599_i3 : Fin 2 → Finset Cell := ![(placed21 1 (3, 2) envelope_5), envelope_599_i4] +theorem common_sub_599_i3 : commonEnvelope childrenD_599_i3 ⊆ insert (4, 5) required_599_i3 := by decide +kernel +theorem child_required_sub_599_i3 : ∀ j, childrenC_599_i3 j ⊆ insert (4, 5) required_599_i3 := by decide +kernel +theorem child_envelope_sub_599_i3 : ∀ j, childrenD_599_i3 j ⊆ envelope_599_i3 := by decide +kernel +theorem pivot_mem_599_i3 : (4, 5) ∈ envelope_599_i3 := by decide +kernel +theorem children_work_599_i3 : ∀ j, Template HasSnaky 7 (childrenC_599_i3 j) (childrenD_599_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 2)).mono (by decide +kernel) + · exact row_works_599_i4.mono (by decide +kernel) +theorem row_works_599_i3 : Template HasSnaky 8 required_599_i3 envelope_599_i3 := by + refine compose HasSnaky 7 childrenC_599_i3 childrenD_599_i3 children_work_599_i3 (4, 5) + required_599_i3 envelope_599_i3 pivot_mem_599_i3 child_required_sub_599_i3 child_envelope_sub_599_i3 ?_ + intro b hb + exact common_sub_599_i3 (mem_commonEnvelope childrenD_599_i3 b hb) +def required_599_i2 : Finset Cell := ⟨(([(0, 1), (1, 1), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_599_i2 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (2, 2), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_599_i2 : Fin 3 → Finset Cell := ![(placed21 6 (4, 6) required_9), (placed21 7 (4, 5) required_251), required_599_i3] +def childrenD_599_i2 : Fin 3 → Finset Cell := ![(placed21 6 (4, 6) envelope_9), (placed21 7 (4, 5) envelope_251), envelope_599_i3] +theorem common_sub_599_i2 : commonEnvelope childrenD_599_i2 ⊆ insert (3, 2) required_599_i2 := by decide +kernel +theorem child_required_sub_599_i2 : ∀ j, childrenC_599_i2 j ⊆ insert (3, 2) required_599_i2 := by decide +kernel +theorem child_envelope_sub_599_i2 : ∀ j, childrenD_599_i2 j ⊆ envelope_599_i2 := by decide +kernel +theorem pivot_mem_599_i2 : (3, 2) ∈ envelope_599_i2 := by decide +kernel +theorem children_work_599_i2 : ∀ j, Template HasSnaky 8 (childrenC_599_i2 j) (childrenD_599_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_251 7 (4, 5)).mono (by decide +kernel) + · exact row_works_599_i3.mono (by decide +kernel) +theorem row_works_599_i2 : Template HasSnaky 9 required_599_i2 envelope_599_i2 := by + refine compose HasSnaky 8 childrenC_599_i2 childrenD_599_i2 children_work_599_i2 (3, 2) + required_599_i2 envelope_599_i2 pivot_mem_599_i2 child_required_sub_599_i2 child_envelope_sub_599_i2 ?_ + intro b hb + exact common_sub_599_i2 (mem_commonEnvelope childrenD_599_i2 b hb) +def required_599_i1 : Finset Cell := ⟨(([(0, 1), (1, 1), (3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_599_i1 : Finset Cell := ⟨(([(0, 1), (1, 1), (2, 0), (2, 1), (2, 2), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_599_i1 : Fin 5 → Finset Cell := ![(placed21 2 (4, 2) required_10), (placed21 0 (3, 2) required_27), (placed21 2 (4, 2) required_48), (placed21 2 (4, 2) required_63), required_599_i2] +def childrenD_599_i1 : Fin 5 → Finset Cell := ![(placed21 2 (4, 2) envelope_10), (placed21 0 (3, 2) envelope_27), (placed21 2 (4, 2) envelope_48), (placed21 2 (4, 2) envelope_63), envelope_599_i2] +theorem common_sub_599_i1 : commonEnvelope childrenD_599_i1 ⊆ insert (3, 5) required_599_i1 := by decide +kernel +theorem child_required_sub_599_i1 : ∀ j, childrenC_599_i1 j ⊆ insert (3, 5) required_599_i1 := by decide +kernel +theorem child_envelope_sub_599_i1 : ∀ j, childrenD_599_i1 j ⊆ envelope_599_i1 := by decide +kernel +theorem pivot_mem_599_i1 : (3, 5) ∈ envelope_599_i1 := by decide +kernel +theorem children_work_599_i1 : ∀ j, Template HasSnaky 9 (childrenC_599_i1 j) (childrenD_599_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_27 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_48 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_63 2 (4, 2)).mono (by decide +kernel) + · exact row_works_599_i2.mono (by decide +kernel) +theorem row_works_599_i1 : Template HasSnaky 10 required_599_i1 envelope_599_i1 := by + refine compose HasSnaky 9 childrenC_599_i1 childrenD_599_i1 children_work_599_i1 (3, 5) + required_599_i1 envelope_599_i1 pivot_mem_599_i1 child_required_sub_599_i1 child_envelope_sub_599_i1 ?_ + intro b hb + exact common_sub_599_i1 (mem_commonEnvelope childrenD_599_i1 b hb) +def required_599_i0 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 4), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_599_i0 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 4), (2, 0), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_599_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 4) required_2), required_599_i1] +def childrenD_599_i0 : Fin 2 → Finset Cell := ![(placed21 4 (0, 4) envelope_2), envelope_599_i1] +theorem common_sub_599_i0 : commonEnvelope childrenD_599_i0 ⊆ insert (3, 4) required_599_i0 := by decide +kernel +theorem child_required_sub_599_i0 : ∀ j, childrenC_599_i0 j ⊆ insert (3, 4) required_599_i0 := by decide +kernel +theorem child_envelope_sub_599_i0 : ∀ j, childrenD_599_i0 j ⊆ envelope_599_i0 := by decide +kernel +theorem pivot_mem_599_i0 : (3, 4) ∈ envelope_599_i0 := by decide +kernel +theorem children_work_599_i0 : ∀ j, Template HasSnaky 10 (childrenC_599_i0 j) (childrenD_599_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (0, 4)).mono (by decide +kernel) + · exact row_works_599_i1.mono (by decide +kernel) +theorem row_works_599_i0 : Template HasSnaky 11 required_599_i0 envelope_599_i0 := by + refine compose HasSnaky 10 childrenC_599_i0 childrenD_599_i0 children_work_599_i0 (3, 4) + required_599_i0 envelope_599_i0 pivot_mem_599_i0 child_required_sub_599_i0 child_envelope_sub_599_i0 ?_ + intro b hb + exact common_sub_599_i0 (mem_commonEnvelope childrenD_599_i0 b hb) +def required_599 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 4), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_599 : Finset Cell := ⟨(([(0, 1), (0, 4), (1, 1), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 4), (8, 5), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_599 : Fin 4 → Finset Cell := ![(placed21 3 (0, 4) required_107), (placed21 3 (0, 4) required_163), (placed21 4 (0, 7) required_401), required_599_i0] +def childrenD_599 : Fin 4 → Finset Cell := ![(placed21 3 (0, 4) envelope_107), (placed21 3 (0, 4) envelope_163), (placed21 4 (0, 7) envelope_401), envelope_599_i0] +theorem common_sub_599 : commonEnvelope childrenD_599 ⊆ insert (4, 3) required_599 := by decide +kernel +theorem child_required_sub_599 : ∀ j, childrenC_599 j ⊆ insert (4, 3) required_599 := by decide +kernel +theorem child_envelope_sub_599 : ∀ j, childrenD_599 j ⊆ envelope_599 := by decide +kernel +theorem pivot_mem_599 : (4, 3) ∈ envelope_599 := by decide +kernel +theorem children_work_599 : ∀ j, Template HasSnaky 11 (childrenC_599 j) (childrenD_599 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_107 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_163 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_401 4 (0, 7)).mono (by decide +kernel) + · exact row_works_599_i0.mono (by decide +kernel) +theorem row_works_599 : Template HasSnaky 12 required_599 envelope_599 := by + refine compose HasSnaky 11 childrenC_599 childrenD_599 children_work_599 (4, 3) + required_599 envelope_599 pivot_mem_599 child_required_sub_599 child_envelope_sub_599 ?_ + intro b hb + exact common_sub_599 (mem_commonEnvelope childrenD_599 b hb) +def required_605_i0 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_605_i0 : Finset Cell := ⟨(([(0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_605_i0 : Fin 3 → Finset Cell := ![(placed21 2 (4, 0) required_115), (placed21 0 (0, 1) required_585), (placed21 0 (1, 0) required_604)] +def childrenD_605_i0 : Fin 3 → Finset Cell := ![(placed21 2 (4, 0) envelope_115), (placed21 0 (0, 1) envelope_585), (placed21 0 (1, 0) envelope_604)] +theorem common_sub_605_i0 : commonEnvelope childrenD_605_i0 ⊆ insert (1, 3) required_605_i0 := by decide +kernel +theorem child_required_sub_605_i0 : ∀ j, childrenC_605_i0 j ⊆ insert (1, 3) required_605_i0 := by decide +kernel +theorem child_envelope_sub_605_i0 : ∀ j, childrenD_605_i0 j ⊆ envelope_605_i0 := by decide +kernel +theorem pivot_mem_605_i0 : (1, 3) ∈ envelope_605_i0 := by decide +kernel +theorem children_work_605_i0 : ∀ j, Template HasSnaky 10 (childrenC_605_i0 j) (childrenD_605_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_115 2 (4, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_585 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_604 0 (1, 0)).mono (by decide +kernel) +theorem row_works_605_i0 : Template HasSnaky 11 required_605_i0 envelope_605_i0 := by + refine compose HasSnaky 10 childrenC_605_i0 childrenD_605_i0 children_work_605_i0 (1, 3) + required_605_i0 envelope_605_i0 pivot_mem_605_i0 child_required_sub_605_i0 child_envelope_sub_605_i0 ?_ + intro b hb + exact common_sub_605_i0 (mem_commonEnvelope childrenD_605_i0 b hb) +def required_605 : Finset Cell := ⟨(([(2, 3), (3, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_605 : Finset Cell := ⟨(([(0, 2), (0, 4), (0, 5), (0, 6), (0, 7), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 4), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_605 : Fin 5 → Finset Cell := ![(placed21 1 (0, 2) required_12), (placed21 1 (0, 1) required_135), (placed21 3 (0, 5) required_182), (placed21 0 (1, 1) required_474), required_605_i0] +def childrenD_605 : Fin 5 → Finset Cell := ![(placed21 1 (0, 2) envelope_12), (placed21 1 (0, 1) envelope_135), (placed21 3 (0, 5) envelope_182), (placed21 0 (1, 1) envelope_474), envelope_605_i0] +theorem common_sub_605 : commonEnvelope childrenD_605 ⊆ insert (4, 3) required_605 := by decide +kernel +theorem child_required_sub_605 : ∀ j, childrenC_605 j ⊆ insert (4, 3) required_605 := by decide +kernel +theorem child_envelope_sub_605 : ∀ j, childrenD_605 j ⊆ envelope_605 := by decide +kernel +theorem pivot_mem_605 : (4, 3) ∈ envelope_605 := by decide +kernel +theorem children_work_605 : ∀ j, Template HasSnaky 11 (childrenC_605 j) (childrenD_605 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_135 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_182 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_474 0 (1, 1)).mono (by decide +kernel) + · exact row_works_605_i0.mono (by decide +kernel) +theorem row_works_605 : Template HasSnaky 12 required_605 envelope_605 := by + refine compose HasSnaky 11 childrenC_605 childrenD_605 children_work_605 (4, 3) + required_605 envelope_605 pivot_mem_605 child_required_sub_605 child_envelope_sub_605 ?_ + intro b hb + exact common_sub_605 (mem_commonEnvelope childrenD_605 b hb) +def required_618_i2 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 4), (5, 3), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_618_i2 : Finset Cell := ⟨(([(2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_618_i2 : Fin 2 → Finset Cell := ![(placed21 6 (3, 7) required_53), (placed21 1 (3, 3) required_378)] +def childrenD_618_i2 : Fin 2 → Finset Cell := ![(placed21 6 (3, 7) envelope_53), (placed21 1 (3, 3) envelope_378)] +theorem common_sub_618_i2 : commonEnvelope childrenD_618_i2 ⊆ insert (3, 5) required_618_i2 := by decide +kernel +theorem child_required_sub_618_i2 : ∀ j, childrenC_618_i2 j ⊆ insert (3, 5) required_618_i2 := by decide +kernel +theorem child_envelope_sub_618_i2 : ∀ j, childrenD_618_i2 j ⊆ envelope_618_i2 := by decide +kernel +theorem pivot_mem_618_i2 : (3, 5) ∈ envelope_618_i2 := by decide +kernel +theorem children_work_618_i2 : ∀ j, Template HasSnaky 6 (childrenC_618_i2 j) (childrenD_618_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 6 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_378 1 (3, 3)).mono (by decide +kernel) +theorem row_works_618_i2 : Template HasSnaky 7 required_618_i2 envelope_618_i2 := by + refine compose HasSnaky 6 childrenC_618_i2 childrenD_618_i2 children_work_618_i2 (3, 5) + required_618_i2 envelope_618_i2 pivot_mem_618_i2 child_required_sub_618_i2 child_envelope_sub_618_i2 ?_ + intro b hb + exact common_sub_618_i2 (mem_commonEnvelope childrenD_618_i2 b hb) +def required_618_i1 : Finset Cell := ⟨(([(2, 3), (2, 4), (5, 3), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_618_i1 : Finset Cell := ⟨(([(2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_618_i1 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) required_25), required_618_i2] +def childrenD_618_i1 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) envelope_25), envelope_618_i2] +theorem common_sub_618_i1 : commonEnvelope childrenD_618_i1 ⊆ insert (3, 4) required_618_i1 := by decide +kernel +theorem child_required_sub_618_i1 : ∀ j, childrenC_618_i1 j ⊆ insert (3, 4) required_618_i1 := by decide +kernel +theorem child_envelope_sub_618_i1 : ∀ j, childrenD_618_i1 j ⊆ envelope_618_i1 := by decide +kernel +theorem pivot_mem_618_i1 : (3, 4) ∈ envelope_618_i1 := by decide +kernel +theorem children_work_618_i1 : ∀ j, Template HasSnaky 7 (childrenC_618_i1 j) (childrenD_618_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_25 7 (6, 6)).mono (by decide +kernel) + · exact row_works_618_i2.mono (by decide +kernel) +theorem row_works_618_i1 : Template HasSnaky 8 required_618_i1 envelope_618_i1 := by + refine compose HasSnaky 7 childrenC_618_i1 childrenD_618_i1 children_work_618_i1 (3, 4) + required_618_i1 envelope_618_i1 pivot_mem_618_i1 child_required_sub_618_i1 child_envelope_sub_618_i1 ?_ + intro b hb + exact common_sub_618_i1 (mem_commonEnvelope childrenD_618_i1 b hb) +def required_618_i0 : Finset Cell := ⟨(([(2, 3), (2, 4), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_618_i0 : Finset Cell := ⟨(([(2, 1), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_618_i0 : Fin 4 → Finset Cell := ![(placed21 0 (5, 2) required_7), (placed21 1 (4, 3) required_8), (placed21 2 (6, 2) required_9), required_618_i1] +def childrenD_618_i0 : Fin 4 → Finset Cell := ![(placed21 0 (5, 2) envelope_7), (placed21 1 (4, 3) envelope_8), (placed21 2 (6, 2) envelope_9), envelope_618_i1] +theorem common_sub_618_i0 : commonEnvelope childrenD_618_i0 ⊆ insert (5, 6) required_618_i0 := by decide +kernel +theorem child_required_sub_618_i0 : ∀ j, childrenC_618_i0 j ⊆ insert (5, 6) required_618_i0 := by decide +kernel +theorem child_envelope_sub_618_i0 : ∀ j, childrenD_618_i0 j ⊆ envelope_618_i0 := by decide +kernel +theorem pivot_mem_618_i0 : (5, 6) ∈ envelope_618_i0 := by decide +kernel +theorem children_work_618_i0 : ∀ j, Template HasSnaky 8 (childrenC_618_i0 j) (childrenD_618_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (6, 2)).mono (by decide +kernel) + · exact row_works_618_i1.mono (by decide +kernel) +theorem row_works_618_i0 : Template HasSnaky 9 required_618_i0 envelope_618_i0 := by + refine compose HasSnaky 8 childrenC_618_i0 childrenD_618_i0 children_work_618_i0 (5, 6) + required_618_i0 envelope_618_i0 pivot_mem_618_i0 child_required_sub_618_i0 child_envelope_sub_618_i0 ?_ + intro b hb + exact common_sub_618_i0 (mem_commonEnvelope childrenD_618_i0 b hb) +def required_618_i3 : Finset Cell := ⟨(([(5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_618_i3 : Finset Cell := ⟨(([(2, 6), (3, 6), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 5), (8, 6), (8, 7), (9, 5), (9, 6), (9, 7), (10, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_618_i3 : Fin 4 → Finset Cell := ![(placed21 0 (5, 2) required_7), (placed21 1 (4, 3) required_8), (placed21 2 (6, 2) required_9), (placed21 1 (2, 3) required_604)] +def childrenD_618_i3 : Fin 4 → Finset Cell := ![(placed21 0 (5, 2) envelope_7), (placed21 1 (4, 3) envelope_8), (placed21 2 (6, 2) envelope_9), (placed21 1 (2, 3) envelope_604)] +theorem common_sub_618_i3 : commonEnvelope childrenD_618_i3 ⊆ insert (5, 6) required_618_i3 := by decide +kernel +theorem child_required_sub_618_i3 : ∀ j, childrenC_618_i3 j ⊆ insert (5, 6) required_618_i3 := by decide +kernel +theorem child_envelope_sub_618_i3 : ∀ j, childrenD_618_i3 j ⊆ envelope_618_i3 := by decide +kernel +theorem pivot_mem_618_i3 : (5, 6) ∈ envelope_618_i3 := by decide +kernel +theorem children_work_618_i3 : ∀ j, Template HasSnaky 8 (childrenC_618_i3 j) (childrenD_618_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_604 1 (2, 3)).mono (by decide +kernel) +theorem row_works_618_i3 : Template HasSnaky 9 required_618_i3 envelope_618_i3 := by + refine compose HasSnaky 8 childrenC_618_i3 childrenD_618_i3 children_work_618_i3 (5, 6) + required_618_i3 envelope_618_i3 pivot_mem_618_i3 child_required_sub_618_i3 child_envelope_sub_618_i3 ?_ + intro b hb + exact common_sub_618_i3 (mem_commonEnvelope childrenD_618_i3 b hb) +def required_618_i4 : Finset Cell := ⟨(([(2, 3), (2, 4), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_618_i4 : Finset Cell := ⟨(([(0, 7), (1, 6), (1, 7), (2, 1), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 3), (8, 4), (8, 5), (8, 6), (9, 4), (9, 5), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_618_i4 : Fin 4 → Finset Cell := ![(placed21 2 (6, 2) required_9), (placed21 1 (2, 3) required_171), (placed21 3 (3, 7) required_577), (placed21 6 (6, 7) required_609)] +def childrenD_618_i4 : Fin 4 → Finset Cell := ![(placed21 2 (6, 2) envelope_9), (placed21 1 (2, 3) envelope_171), (placed21 3 (3, 7) envelope_577), (placed21 6 (6, 7) envelope_609)] +theorem common_sub_618_i4 : commonEnvelope childrenD_618_i4 ⊆ insert (5, 6) required_618_i4 := by decide +kernel +theorem child_required_sub_618_i4 : ∀ j, childrenC_618_i4 j ⊆ insert (5, 6) required_618_i4 := by decide +kernel +theorem child_envelope_sub_618_i4 : ∀ j, childrenD_618_i4 j ⊆ envelope_618_i4 := by decide +kernel +theorem pivot_mem_618_i4 : (5, 6) ∈ envelope_618_i4 := by decide +kernel +theorem children_work_618_i4 : ∀ j, Template HasSnaky 9 (childrenC_618_i4 j) (childrenD_618_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_171 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_577 3 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_609 6 (6, 7)).mono (by decide +kernel) +theorem row_works_618_i4 : Template HasSnaky 10 required_618_i4 envelope_618_i4 := by + refine compose HasSnaky 9 childrenC_618_i4 childrenD_618_i4 children_work_618_i4 (5, 6) + required_618_i4 envelope_618_i4 pivot_mem_618_i4 child_required_sub_618_i4 child_envelope_sub_618_i4 ?_ + intro b hb + exact common_sub_618_i4 (mem_commonEnvelope childrenD_618_i4 b hb) +def required_618_i5 : Finset Cell := ⟨(([(5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_618_i5 : Finset Cell := ⟨(([(1, 6), (1, 7), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 3), (8, 4), (8, 5), (8, 6), (9, 4), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_618_i5 : Fin 3 → Finset Cell := ![(placed21 2 (6, 2) required_9), (placed21 5 (8, 3) required_256), (placed21 3 (3, 7) required_577)] +def childrenD_618_i5 : Fin 3 → Finset Cell := ![(placed21 2 (6, 2) envelope_9), (placed21 5 (8, 3) envelope_256), (placed21 3 (3, 7) envelope_577)] +theorem common_sub_618_i5 : commonEnvelope childrenD_618_i5 ⊆ insert (5, 6) required_618_i5 := by decide +kernel +theorem child_required_sub_618_i5 : ∀ j, childrenC_618_i5 j ⊆ insert (5, 6) required_618_i5 := by decide +kernel +theorem child_envelope_sub_618_i5 : ∀ j, childrenD_618_i5 j ⊆ envelope_618_i5 := by decide +kernel +theorem pivot_mem_618_i5 : (5, 6) ∈ envelope_618_i5 := by decide +kernel +theorem children_work_618_i5 : ∀ j, Template HasSnaky 9 (childrenC_618_i5 j) (childrenD_618_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_256 5 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_577 3 (3, 7)).mono (by decide +kernel) +theorem row_works_618_i5 : Template HasSnaky 10 required_618_i5 envelope_618_i5 := by + refine compose HasSnaky 9 childrenC_618_i5 childrenD_618_i5 children_work_618_i5 (5, 6) + required_618_i5 envelope_618_i5 pivot_mem_618_i5 child_required_sub_618_i5 child_envelope_sub_618_i5 ?_ + intro b hb + exact common_sub_618_i5 (mem_commonEnvelope childrenD_618_i5 b hb) +def required_618_i8 : Finset Cell := ⟨(([(2, 3), (2, 4), (3, 4), (4, 4), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_618_i8 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5), (5, 4), (5, 5), (6, 4), (7, 4), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_618_i8 : Fin 2 → Finset Cell := ![(placed21 6 (6, 4) required_4), (placed21 1 (1, 4) required_113)] +def childrenD_618_i8 : Fin 2 → Finset Cell := ![(placed21 6 (6, 4) envelope_4), (placed21 1 (1, 4) envelope_113)] +theorem common_sub_618_i8 : commonEnvelope childrenD_618_i8 ⊆ insert (6, 4) required_618_i8 := by decide +kernel +theorem child_required_sub_618_i8 : ∀ j, childrenC_618_i8 j ⊆ insert (6, 4) required_618_i8 := by decide +kernel +theorem child_envelope_sub_618_i8 : ∀ j, childrenD_618_i8 j ⊆ envelope_618_i8 := by decide +kernel +theorem pivot_mem_618_i8 : (6, 4) ∈ envelope_618_i8 := by decide +kernel +theorem children_work_618_i8 : ∀ j, Template HasSnaky 3 (childrenC_618_i8 j) (childrenD_618_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 6 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_113 1 (1, 4)).mono (by decide +kernel) +theorem row_works_618_i8 : Template HasSnaky 4 required_618_i8 envelope_618_i8 := by + refine compose HasSnaky 3 childrenC_618_i8 childrenD_618_i8 children_work_618_i8 (6, 4) + required_618_i8 envelope_618_i8 pivot_mem_618_i8 child_required_sub_618_i8 child_envelope_sub_618_i8 ?_ + intro b hb + exact common_sub_618_i8 (mem_commonEnvelope childrenD_618_i8 b hb) +def required_618_i7 : Finset Cell := ⟨(([(2, 3), (2, 4), (4, 4), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_618_i7 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5), (5, 4), (5, 5), (6, 4), (6, 5), (7, 4), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_618_i7 : Fin 2 → Finset Cell := ![(placed21 0 (2, 4) required_5), required_618_i8] +def childrenD_618_i7 : Fin 2 → Finset Cell := ![(placed21 0 (2, 4) envelope_5), envelope_618_i8] +theorem common_sub_618_i7 : commonEnvelope childrenD_618_i7 ⊆ insert (3, 4) required_618_i7 := by decide +kernel +theorem child_required_sub_618_i7 : ∀ j, childrenC_618_i7 j ⊆ insert (3, 4) required_618_i7 := by decide +kernel +theorem child_envelope_sub_618_i7 : ∀ j, childrenD_618_i7 j ⊆ envelope_618_i7 := by decide +kernel +theorem pivot_mem_618_i7 : (3, 4) ∈ envelope_618_i7 := by decide +kernel +theorem children_work_618_i7 : ∀ j, Template HasSnaky 4 (childrenC_618_i7 j) (childrenD_618_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (2, 4)).mono (by decide +kernel) + · exact row_works_618_i8.mono (by decide +kernel) +theorem row_works_618_i7 : Template HasSnaky 5 required_618_i7 envelope_618_i7 := by + refine compose HasSnaky 4 childrenC_618_i7 childrenD_618_i7 children_work_618_i7 (3, 4) + required_618_i7 envelope_618_i7 pivot_mem_618_i7 child_required_sub_618_i7 child_envelope_sub_618_i7 ?_ + intro b hb + exact common_sub_618_i7 (mem_commonEnvelope childrenD_618_i7 b hb) +def required_618_i6 : Finset Cell := ⟨(([(2, 3), (2, 4), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_618_i6 : Finset Cell := ⟨(([(1, 4), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3), (9, 4), (9, 5), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_618_i6 : Fin 4 → Finset Cell := ![(placed21 5 (6, 3) required_80), (placed21 1 (2, 2) required_111), (placed21 0 (3, 1) required_616), required_618_i7] +def childrenD_618_i6 : Fin 4 → Finset Cell := ![(placed21 5 (6, 3) envelope_80), (placed21 1 (2, 2) envelope_111), (placed21 0 (3, 1) envelope_616), envelope_618_i7] +theorem common_sub_618_i6 : commonEnvelope childrenD_618_i6 ⊆ insert (4, 4) required_618_i6 := by decide +kernel +theorem child_required_sub_618_i6 : ∀ j, childrenC_618_i6 j ⊆ insert (4, 4) required_618_i6 := by decide +kernel +theorem child_envelope_sub_618_i6 : ∀ j, childrenD_618_i6 j ⊆ envelope_618_i6 := by decide +kernel +theorem pivot_mem_618_i6 : (4, 4) ∈ envelope_618_i6 := by decide +kernel +theorem children_work_618_i6 : ∀ j, Template HasSnaky 10 (childrenC_618_i6 j) (childrenD_618_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_80 5 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_111 1 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_616 0 (3, 1)).mono (by decide +kernel) + · exact row_works_618_i7.mono (by decide +kernel) +theorem row_works_618_i6 : Template HasSnaky 11 required_618_i6 envelope_618_i6 := by + refine compose HasSnaky 10 childrenC_618_i6 childrenD_618_i6 children_work_618_i6 (4, 4) + required_618_i6 envelope_618_i6 pivot_mem_618_i6 child_required_sub_618_i6 child_envelope_sub_618_i6 ?_ + intro b hb + exact common_sub_618_i6 (mem_commonEnvelope childrenD_618_i6 b hb) +def required_618 : Finset Cell := ⟨(([(2, 3), (2, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_618 : Finset Cell := ⟨(([(0, 7), (1, 4), (1, 6), (1, 7), (2, 1), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (10, 2), (10, 4), (10, 5), (10, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_618 : Fin 9 → Finset Cell := ![(placed21 1 (2, 3) required_398), (placed21 0 (1, 2) required_434), (placed21 2 (6, 1) required_610), required_618_i0, required_618_i3, required_618_i4, required_618_i5, (placed21 0 (2, 0) required_615), required_618_i6] +def childrenD_618 : Fin 9 → Finset Cell := ![(placed21 1 (2, 3) envelope_398), (placed21 0 (1, 2) envelope_434), (placed21 2 (6, 1) envelope_610), envelope_618_i0, envelope_618_i3, envelope_618_i4, envelope_618_i5, (placed21 0 (2, 0) envelope_615), envelope_618_i6] +theorem common_sub_618 : commonEnvelope childrenD_618 ⊆ insert (5, 5) required_618 := by decide +kernel +theorem child_required_sub_618 : ∀ j, childrenC_618 j ⊆ insert (5, 5) required_618 := by decide +kernel +theorem child_envelope_sub_618 : ∀ j, childrenD_618 j ⊆ envelope_618 := by decide +kernel +theorem pivot_mem_618 : (5, 5) ∈ envelope_618 := by decide +kernel +theorem children_work_618 : ∀ j, Template HasSnaky 11 (childrenC_618 j) (childrenD_618 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_398 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_434 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_610 2 (6, 1)).mono (by decide +kernel) + · exact row_works_618_i0.mono (by decide +kernel) + · exact row_works_618_i3.mono (by decide +kernel) + · exact row_works_618_i4.mono (by decide +kernel) + · exact row_works_618_i5.mono (by decide +kernel) + · exact (placed21_template row_works_615 0 (2, 0)).mono (by decide +kernel) + · exact row_works_618_i6.mono (by decide +kernel) +theorem row_works_618 : Template HasSnaky 12 required_618 envelope_618 := by + refine compose HasSnaky 11 childrenC_618 childrenD_618 children_work_618 (5, 5) + required_618 envelope_618 pivot_mem_618 child_required_sub_618 child_envelope_sub_618 ?_ + intro b hb + exact common_sub_618 (mem_commonEnvelope childrenD_618 b hb) +def height_599_i6 : ℕ := 4 +def childrenH_599_i6 : Fin 2 → ℕ := ![height_5, height_64] +theorem height_exact_599_i6 : height_599_i6 = 1 + Finset.univ.sup childrenH_599_i6 := by decide +kernel +theorem required_origin_599_i6 : ∀ x ∈ required_599_i6, + (∃ j, x ∈ childrenC_599_i6 j) ∨ ∀ j, x ∈ childrenD_599_i6 j := by decide +kernel +theorem required_exact_599_i6 : required_599_i6 = + ((Finset.univ.biUnion childrenC_599_i6) ∪ commonEnvelope childrenD_599_i6).erase (5, 6) := by + exact required_eq_combination childrenC_599_i6 childrenD_599_i6 (5, 6) required_599_i6 + (by decide +kernel) child_required_sub_599_i6 common_sub_599_i6 required_origin_599_i6 +theorem envelope_origin_599_i6 : ∀ x ∈ envelope_599_i6, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_599_i6 j := by decide +kernel +theorem envelope_exact_599_i6 : envelope_599_i6 = + insert (5, 6) (Finset.univ.biUnion childrenD_599_i6) := by + exact envelope_eq_combination childrenD_599_i6 (5, 6) envelope_599_i6 + pivot_mem_599_i6 child_envelope_sub_599_i6 envelope_origin_599_i6 +def checked_599_i6 : CheckedCard where + required := required_599_i6 + envelope := envelope_599_i6 + height := height_599_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_599_i6 +def height_599_i8 : ℕ := 4 +def childrenH_599_i8 : Fin 2 → ℕ := ![height_0, height_44] +theorem height_exact_599_i8 : height_599_i8 = 1 + Finset.univ.sup childrenH_599_i8 := by decide +kernel +theorem required_origin_599_i8 : ∀ x ∈ required_599_i8, + (∃ j, x ∈ childrenC_599_i8 j) ∨ ∀ j, x ∈ childrenD_599_i8 j := by decide +kernel +theorem required_exact_599_i8 : required_599_i8 = + ((Finset.univ.biUnion childrenC_599_i8) ∪ commonEnvelope childrenD_599_i8).erase (4, 4) := by + exact required_eq_combination childrenC_599_i8 childrenD_599_i8 (4, 4) required_599_i8 + (by decide +kernel) child_required_sub_599_i8 common_sub_599_i8 required_origin_599_i8 +theorem envelope_origin_599_i8 : ∀ x ∈ envelope_599_i8, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_599_i8 j := by decide +kernel +theorem envelope_exact_599_i8 : envelope_599_i8 = + insert (4, 4) (Finset.univ.biUnion childrenD_599_i8) := by + exact envelope_eq_combination childrenD_599_i8 (4, 4) envelope_599_i8 + pivot_mem_599_i8 child_envelope_sub_599_i8 envelope_origin_599_i8 +def checked_599_i8 : CheckedCard where + required := required_599_i8 + envelope := envelope_599_i8 + height := height_599_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_599_i8 +def height_599_i7 : ℕ := 5 +def childrenH_599_i7 : Fin 3 → ℕ := ![height_6, height_16, height_599_i8] +theorem height_exact_599_i7 : height_599_i7 = 1 + Finset.univ.sup childrenH_599_i7 := by decide +kernel +theorem required_origin_599_i7 : ∀ x ∈ required_599_i7, + (∃ j, x ∈ childrenC_599_i7 j) ∨ ∀ j, x ∈ childrenD_599_i7 j := by decide +kernel +theorem required_exact_599_i7 : required_599_i7 = + ((Finset.univ.biUnion childrenC_599_i7) ∪ commonEnvelope childrenD_599_i7).erase (6, 5) := by + exact required_eq_combination childrenC_599_i7 childrenD_599_i7 (6, 5) required_599_i7 + (by decide +kernel) child_required_sub_599_i7 common_sub_599_i7 required_origin_599_i7 +theorem envelope_origin_599_i7 : ∀ x ∈ envelope_599_i7, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_599_i7 j := by decide +kernel +theorem envelope_exact_599_i7 : envelope_599_i7 = + insert (6, 5) (Finset.univ.biUnion childrenD_599_i7) := by + exact envelope_eq_combination childrenD_599_i7 (6, 5) envelope_599_i7 + pivot_mem_599_i7 child_envelope_sub_599_i7 envelope_origin_599_i7 +def checked_599_i7 : CheckedCard where + required := required_599_i7 + envelope := envelope_599_i7 + height := height_599_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_599_i7 +def height_599_i5 : ℕ := 6 +def childrenH_599_i5 : Fin 5 → ℕ := ![height_8, height_17, height_41, height_599_i6, height_599_i7] +theorem height_exact_599_i5 : height_599_i5 = 1 + Finset.univ.sup childrenH_599_i5 := by decide +kernel +theorem required_origin_599_i5 : ∀ x ∈ required_599_i5, + (∃ j, x ∈ childrenC_599_i5 j) ∨ ∀ j, x ∈ childrenD_599_i5 j := by decide +kernel +theorem required_exact_599_i5 : required_599_i5 = + ((Finset.univ.biUnion childrenC_599_i5) ∪ commonEnvelope childrenD_599_i5).erase (5, 5) := by + exact required_eq_combination childrenC_599_i5 childrenD_599_i5 (5, 5) required_599_i5 + (by decide +kernel) child_required_sub_599_i5 common_sub_599_i5 required_origin_599_i5 +theorem envelope_origin_599_i5 : ∀ x ∈ envelope_599_i5, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_599_i5 j := by decide +kernel +theorem envelope_exact_599_i5 : envelope_599_i5 = + insert (5, 5) (Finset.univ.biUnion childrenD_599_i5) := by + exact envelope_eq_combination childrenD_599_i5 (5, 5) envelope_599_i5 + pivot_mem_599_i5 child_envelope_sub_599_i5 envelope_origin_599_i5 +def checked_599_i5 : CheckedCard where + required := required_599_i5 + envelope := envelope_599_i5 + height := height_599_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_599_i5 +def height_599_i4 : ℕ := 7 +def childrenH_599_i4 : Fin 2 → ℕ := ![height_5, height_599_i5] +theorem height_exact_599_i4 : height_599_i4 = 1 + Finset.univ.sup childrenH_599_i4 := by decide +kernel +theorem required_origin_599_i4 : ∀ x ∈ required_599_i4, + (∃ j, x ∈ childrenC_599_i4 j) ∨ ∀ j, x ∈ childrenD_599_i4 j := by decide +kernel +theorem required_exact_599_i4 : required_599_i4 = + ((Finset.univ.biUnion childrenC_599_i4) ∪ commonEnvelope childrenD_599_i4).erase (2, 5) := by + exact required_eq_combination childrenC_599_i4 childrenD_599_i4 (2, 5) required_599_i4 + (by decide +kernel) child_required_sub_599_i4 common_sub_599_i4 required_origin_599_i4 +theorem envelope_origin_599_i4 : ∀ x ∈ envelope_599_i4, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_599_i4 j := by decide +kernel +theorem envelope_exact_599_i4 : envelope_599_i4 = + insert (2, 5) (Finset.univ.biUnion childrenD_599_i4) := by + exact envelope_eq_combination childrenD_599_i4 (2, 5) envelope_599_i4 + pivot_mem_599_i4 child_envelope_sub_599_i4 envelope_origin_599_i4 +def checked_599_i4 : CheckedCard where + required := required_599_i4 + envelope := envelope_599_i4 + height := height_599_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_599_i4 +def height_599_i3 : ℕ := 8 +def childrenH_599_i3 : Fin 2 → ℕ := ![height_5, height_599_i4] +theorem height_exact_599_i3 : height_599_i3 = 1 + Finset.univ.sup childrenH_599_i3 := by decide +kernel +theorem required_origin_599_i3 : ∀ x ∈ required_599_i3, + (∃ j, x ∈ childrenC_599_i3 j) ∨ ∀ j, x ∈ childrenD_599_i3 j := by decide +kernel +theorem required_exact_599_i3 : required_599_i3 = + ((Finset.univ.biUnion childrenC_599_i3) ∪ commonEnvelope childrenD_599_i3).erase (4, 5) := by + exact required_eq_combination childrenC_599_i3 childrenD_599_i3 (4, 5) required_599_i3 + (by decide +kernel) child_required_sub_599_i3 common_sub_599_i3 required_origin_599_i3 +theorem envelope_origin_599_i3 : ∀ x ∈ envelope_599_i3, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_599_i3 j := by decide +kernel +theorem envelope_exact_599_i3 : envelope_599_i3 = + insert (4, 5) (Finset.univ.biUnion childrenD_599_i3) := by + exact envelope_eq_combination childrenD_599_i3 (4, 5) envelope_599_i3 + pivot_mem_599_i3 child_envelope_sub_599_i3 envelope_origin_599_i3 +def checked_599_i3 : CheckedCard where + required := required_599_i3 + envelope := envelope_599_i3 + height := height_599_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_599_i3 +def height_599_i2 : ℕ := 9 +def childrenH_599_i2 : Fin 3 → ℕ := ![height_9, height_251, height_599_i3] +theorem height_exact_599_i2 : height_599_i2 = 1 + Finset.univ.sup childrenH_599_i2 := by decide +kernel +theorem required_origin_599_i2 : ∀ x ∈ required_599_i2, + (∃ j, x ∈ childrenC_599_i2 j) ∨ ∀ j, x ∈ childrenD_599_i2 j := by decide +kernel +theorem required_exact_599_i2 : required_599_i2 = + ((Finset.univ.biUnion childrenC_599_i2) ∪ commonEnvelope childrenD_599_i2).erase (3, 2) := by + exact required_eq_combination childrenC_599_i2 childrenD_599_i2 (3, 2) required_599_i2 + (by decide +kernel) child_required_sub_599_i2 common_sub_599_i2 required_origin_599_i2 +theorem envelope_origin_599_i2 : ∀ x ∈ envelope_599_i2, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_599_i2 j := by decide +kernel +theorem envelope_exact_599_i2 : envelope_599_i2 = + insert (3, 2) (Finset.univ.biUnion childrenD_599_i2) := by + exact envelope_eq_combination childrenD_599_i2 (3, 2) envelope_599_i2 + pivot_mem_599_i2 child_envelope_sub_599_i2 envelope_origin_599_i2 +def checked_599_i2 : CheckedCard where + required := required_599_i2 + envelope := envelope_599_i2 + height := height_599_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_599_i2 +def height_599_i1 : ℕ := 10 +def childrenH_599_i1 : Fin 5 → ℕ := ![height_10, height_27, height_48, height_63, height_599_i2] +theorem height_exact_599_i1 : height_599_i1 = 1 + Finset.univ.sup childrenH_599_i1 := by decide +kernel +theorem required_origin_599_i1 : ∀ x ∈ required_599_i1, + (∃ j, x ∈ childrenC_599_i1 j) ∨ ∀ j, x ∈ childrenD_599_i1 j := by decide +kernel +theorem required_exact_599_i1 : required_599_i1 = + ((Finset.univ.biUnion childrenC_599_i1) ∪ commonEnvelope childrenD_599_i1).erase (3, 5) := by + exact required_eq_combination childrenC_599_i1 childrenD_599_i1 (3, 5) required_599_i1 + (by decide +kernel) child_required_sub_599_i1 common_sub_599_i1 required_origin_599_i1 +theorem envelope_origin_599_i1 : ∀ x ∈ envelope_599_i1, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_599_i1 j := by decide +kernel +theorem envelope_exact_599_i1 : envelope_599_i1 = + insert (3, 5) (Finset.univ.biUnion childrenD_599_i1) := by + exact envelope_eq_combination childrenD_599_i1 (3, 5) envelope_599_i1 + pivot_mem_599_i1 child_envelope_sub_599_i1 envelope_origin_599_i1 +def checked_599_i1 : CheckedCard where + required := required_599_i1 + envelope := envelope_599_i1 + height := height_599_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_599_i1 +def height_599_i0 : ℕ := 11 +def childrenH_599_i0 : Fin 2 → ℕ := ![height_2, height_599_i1] +theorem height_exact_599_i0 : height_599_i0 = 1 + Finset.univ.sup childrenH_599_i0 := by decide +kernel +theorem required_origin_599_i0 : ∀ x ∈ required_599_i0, + (∃ j, x ∈ childrenC_599_i0 j) ∨ ∀ j, x ∈ childrenD_599_i0 j := by decide +kernel +theorem required_exact_599_i0 : required_599_i0 = + ((Finset.univ.biUnion childrenC_599_i0) ∪ commonEnvelope childrenD_599_i0).erase (3, 4) := by + exact required_eq_combination childrenC_599_i0 childrenD_599_i0 (3, 4) required_599_i0 + (by decide +kernel) child_required_sub_599_i0 common_sub_599_i0 required_origin_599_i0 +theorem envelope_origin_599_i0 : ∀ x ∈ envelope_599_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_599_i0 j := by decide +kernel +theorem envelope_exact_599_i0 : envelope_599_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_599_i0) := by + exact envelope_eq_combination childrenD_599_i0 (3, 4) envelope_599_i0 + pivot_mem_599_i0 child_envelope_sub_599_i0 envelope_origin_599_i0 +def checked_599_i0 : CheckedCard where + required := required_599_i0 + envelope := envelope_599_i0 + height := height_599_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_599_i0 +def height_599 : ℕ := 12 +def childrenH_599 : Fin 4 → ℕ := ![height_107, height_163, height_401, height_599_i0] +theorem height_exact_599 : height_599 = 1 + Finset.univ.sup childrenH_599 := by decide +kernel +theorem required_origin_599 : ∀ x ∈ required_599, + (∃ j, x ∈ childrenC_599 j) ∨ ∀ j, x ∈ childrenD_599 j := by decide +kernel +theorem required_exact_599 : required_599 = + ((Finset.univ.biUnion childrenC_599) ∪ commonEnvelope childrenD_599).erase (4, 3) := by + exact required_eq_combination childrenC_599 childrenD_599 (4, 3) required_599 + (by decide +kernel) child_required_sub_599 common_sub_599 required_origin_599 +theorem envelope_origin_599 : ∀ x ∈ envelope_599, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_599 j := by decide +kernel +theorem envelope_exact_599 : envelope_599 = + insert (4, 3) (Finset.univ.biUnion childrenD_599) := by + exact envelope_eq_combination childrenD_599 (4, 3) envelope_599 + pivot_mem_599 child_envelope_sub_599 envelope_origin_599 +def checked_599 : CheckedCard where + required := required_599 + envelope := envelope_599 + height := height_599 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_599 +def height_605_i0 : ℕ := 11 +def childrenH_605_i0 : Fin 3 → ℕ := ![height_115, height_585, height_604] +theorem height_exact_605_i0 : height_605_i0 = 1 + Finset.univ.sup childrenH_605_i0 := by decide +kernel +theorem required_origin_605_i0 : ∀ x ∈ required_605_i0, + (∃ j, x ∈ childrenC_605_i0 j) ∨ ∀ j, x ∈ childrenD_605_i0 j := by decide +kernel +theorem required_exact_605_i0 : required_605_i0 = + ((Finset.univ.biUnion childrenC_605_i0) ∪ commonEnvelope childrenD_605_i0).erase (1, 3) := by + exact required_eq_combination childrenC_605_i0 childrenD_605_i0 (1, 3) required_605_i0 + (by decide +kernel) child_required_sub_605_i0 common_sub_605_i0 required_origin_605_i0 +theorem envelope_origin_605_i0 : ∀ x ∈ envelope_605_i0, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_605_i0 j := by decide +kernel +theorem envelope_exact_605_i0 : envelope_605_i0 = + insert (1, 3) (Finset.univ.biUnion childrenD_605_i0) := by + exact envelope_eq_combination childrenD_605_i0 (1, 3) envelope_605_i0 + pivot_mem_605_i0 child_envelope_sub_605_i0 envelope_origin_605_i0 +def checked_605_i0 : CheckedCard where + required := required_605_i0 + envelope := envelope_605_i0 + height := height_605_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_605_i0 +def height_605 : ℕ := 12 +def childrenH_605 : Fin 5 → ℕ := ![height_12, height_135, height_182, height_474, height_605_i0] +theorem height_exact_605 : height_605 = 1 + Finset.univ.sup childrenH_605 := by decide +kernel +theorem required_origin_605 : ∀ x ∈ required_605, + (∃ j, x ∈ childrenC_605 j) ∨ ∀ j, x ∈ childrenD_605 j := by decide +kernel +theorem required_exact_605 : required_605 = + ((Finset.univ.biUnion childrenC_605) ∪ commonEnvelope childrenD_605).erase (4, 3) := by + exact required_eq_combination childrenC_605 childrenD_605 (4, 3) required_605 + (by decide +kernel) child_required_sub_605 common_sub_605 required_origin_605 +theorem envelope_origin_605 : ∀ x ∈ envelope_605, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_605 j := by decide +kernel +theorem envelope_exact_605 : envelope_605 = + insert (4, 3) (Finset.univ.biUnion childrenD_605) := by + exact envelope_eq_combination childrenD_605 (4, 3) envelope_605 + pivot_mem_605 child_envelope_sub_605 envelope_origin_605 +def checked_605 : CheckedCard where + required := required_605 + envelope := envelope_605 + height := height_605 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_605 +def height_618_i2 : ℕ := 7 +def childrenH_618_i2 : Fin 2 → ℕ := ![height_53, height_378] +theorem height_exact_618_i2 : height_618_i2 = 1 + Finset.univ.sup childrenH_618_i2 := by decide +kernel +theorem required_origin_618_i2 : ∀ x ∈ required_618_i2, + (∃ j, x ∈ childrenC_618_i2 j) ∨ ∀ j, x ∈ childrenD_618_i2 j := by decide +kernel +theorem required_exact_618_i2 : required_618_i2 = + ((Finset.univ.biUnion childrenC_618_i2) ∪ commonEnvelope childrenD_618_i2).erase (3, 5) := by + exact required_eq_combination childrenC_618_i2 childrenD_618_i2 (3, 5) required_618_i2 + (by decide +kernel) child_required_sub_618_i2 common_sub_618_i2 required_origin_618_i2 +theorem envelope_origin_618_i2 : ∀ x ∈ envelope_618_i2, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_618_i2 j := by decide +kernel +theorem envelope_exact_618_i2 : envelope_618_i2 = + insert (3, 5) (Finset.univ.biUnion childrenD_618_i2) := by + exact envelope_eq_combination childrenD_618_i2 (3, 5) envelope_618_i2 + pivot_mem_618_i2 child_envelope_sub_618_i2 envelope_origin_618_i2 +def checked_618_i2 : CheckedCard where + required := required_618_i2 + envelope := envelope_618_i2 + height := height_618_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_618_i2 +def height_618_i1 : ℕ := 8 +def childrenH_618_i1 : Fin 2 → ℕ := ![height_25, height_618_i2] +theorem height_exact_618_i1 : height_618_i1 = 1 + Finset.univ.sup childrenH_618_i1 := by decide +kernel +theorem required_origin_618_i1 : ∀ x ∈ required_618_i1, + (∃ j, x ∈ childrenC_618_i1 j) ∨ ∀ j, x ∈ childrenD_618_i1 j := by decide +kernel +theorem required_exact_618_i1 : required_618_i1 = + ((Finset.univ.biUnion childrenC_618_i1) ∪ commonEnvelope childrenD_618_i1).erase (3, 4) := by + exact required_eq_combination childrenC_618_i1 childrenD_618_i1 (3, 4) required_618_i1 + (by decide +kernel) child_required_sub_618_i1 common_sub_618_i1 required_origin_618_i1 +theorem envelope_origin_618_i1 : ∀ x ∈ envelope_618_i1, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_618_i1 j := by decide +kernel +theorem envelope_exact_618_i1 : envelope_618_i1 = + insert (3, 4) (Finset.univ.biUnion childrenD_618_i1) := by + exact envelope_eq_combination childrenD_618_i1 (3, 4) envelope_618_i1 + pivot_mem_618_i1 child_envelope_sub_618_i1 envelope_origin_618_i1 +def checked_618_i1 : CheckedCard where + required := required_618_i1 + envelope := envelope_618_i1 + height := height_618_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_618_i1 +def height_618_i0 : ℕ := 9 +def childrenH_618_i0 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_618_i1] +theorem height_exact_618_i0 : height_618_i0 = 1 + Finset.univ.sup childrenH_618_i0 := by decide +kernel +theorem required_origin_618_i0 : ∀ x ∈ required_618_i0, + (∃ j, x ∈ childrenC_618_i0 j) ∨ ∀ j, x ∈ childrenD_618_i0 j := by decide +kernel +theorem required_exact_618_i0 : required_618_i0 = + ((Finset.univ.biUnion childrenC_618_i0) ∪ commonEnvelope childrenD_618_i0).erase (5, 6) := by + exact required_eq_combination childrenC_618_i0 childrenD_618_i0 (5, 6) required_618_i0 + (by decide +kernel) child_required_sub_618_i0 common_sub_618_i0 required_origin_618_i0 +theorem envelope_origin_618_i0 : ∀ x ∈ envelope_618_i0, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_618_i0 j := by decide +kernel +theorem envelope_exact_618_i0 : envelope_618_i0 = + insert (5, 6) (Finset.univ.biUnion childrenD_618_i0) := by + exact envelope_eq_combination childrenD_618_i0 (5, 6) envelope_618_i0 + pivot_mem_618_i0 child_envelope_sub_618_i0 envelope_origin_618_i0 +def checked_618_i0 : CheckedCard where + required := required_618_i0 + envelope := envelope_618_i0 + height := height_618_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_618_i0 +def height_618_i3 : ℕ := 9 +def childrenH_618_i3 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_604] +theorem height_exact_618_i3 : height_618_i3 = 1 + Finset.univ.sup childrenH_618_i3 := by decide +kernel +theorem required_origin_618_i3 : ∀ x ∈ required_618_i3, + (∃ j, x ∈ childrenC_618_i3 j) ∨ ∀ j, x ∈ childrenD_618_i3 j := by decide +kernel +theorem required_exact_618_i3 : required_618_i3 = + ((Finset.univ.biUnion childrenC_618_i3) ∪ commonEnvelope childrenD_618_i3).erase (5, 6) := by + exact required_eq_combination childrenC_618_i3 childrenD_618_i3 (5, 6) required_618_i3 + (by decide +kernel) child_required_sub_618_i3 common_sub_618_i3 required_origin_618_i3 +theorem envelope_origin_618_i3 : ∀ x ∈ envelope_618_i3, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_618_i3 j := by decide +kernel +theorem envelope_exact_618_i3 : envelope_618_i3 = + insert (5, 6) (Finset.univ.biUnion childrenD_618_i3) := by + exact envelope_eq_combination childrenD_618_i3 (5, 6) envelope_618_i3 + pivot_mem_618_i3 child_envelope_sub_618_i3 envelope_origin_618_i3 +def checked_618_i3 : CheckedCard where + required := required_618_i3 + envelope := envelope_618_i3 + height := height_618_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_618_i3 +def height_618_i4 : ℕ := 10 +def childrenH_618_i4 : Fin 4 → ℕ := ![height_9, height_171, height_577, height_609] +theorem height_exact_618_i4 : height_618_i4 = 1 + Finset.univ.sup childrenH_618_i4 := by decide +kernel +theorem required_origin_618_i4 : ∀ x ∈ required_618_i4, + (∃ j, x ∈ childrenC_618_i4 j) ∨ ∀ j, x ∈ childrenD_618_i4 j := by decide +kernel +theorem required_exact_618_i4 : required_618_i4 = + ((Finset.univ.biUnion childrenC_618_i4) ∪ commonEnvelope childrenD_618_i4).erase (5, 6) := by + exact required_eq_combination childrenC_618_i4 childrenD_618_i4 (5, 6) required_618_i4 + (by decide +kernel) child_required_sub_618_i4 common_sub_618_i4 required_origin_618_i4 +theorem envelope_origin_618_i4 : ∀ x ∈ envelope_618_i4, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_618_i4 j := by decide +kernel +theorem envelope_exact_618_i4 : envelope_618_i4 = + insert (5, 6) (Finset.univ.biUnion childrenD_618_i4) := by + exact envelope_eq_combination childrenD_618_i4 (5, 6) envelope_618_i4 + pivot_mem_618_i4 child_envelope_sub_618_i4 envelope_origin_618_i4 +def checked_618_i4 : CheckedCard where + required := required_618_i4 + envelope := envelope_618_i4 + height := height_618_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_618_i4 +def height_618_i5 : ℕ := 10 +def childrenH_618_i5 : Fin 3 → ℕ := ![height_9, height_256, height_577] +theorem height_exact_618_i5 : height_618_i5 = 1 + Finset.univ.sup childrenH_618_i5 := by decide +kernel +theorem required_origin_618_i5 : ∀ x ∈ required_618_i5, + (∃ j, x ∈ childrenC_618_i5 j) ∨ ∀ j, x ∈ childrenD_618_i5 j := by decide +kernel +theorem required_exact_618_i5 : required_618_i5 = + ((Finset.univ.biUnion childrenC_618_i5) ∪ commonEnvelope childrenD_618_i5).erase (5, 6) := by + exact required_eq_combination childrenC_618_i5 childrenD_618_i5 (5, 6) required_618_i5 + (by decide +kernel) child_required_sub_618_i5 common_sub_618_i5 required_origin_618_i5 +theorem envelope_origin_618_i5 : ∀ x ∈ envelope_618_i5, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_618_i5 j := by decide +kernel +theorem envelope_exact_618_i5 : envelope_618_i5 = + insert (5, 6) (Finset.univ.biUnion childrenD_618_i5) := by + exact envelope_eq_combination childrenD_618_i5 (5, 6) envelope_618_i5 + pivot_mem_618_i5 child_envelope_sub_618_i5 envelope_origin_618_i5 +def checked_618_i5 : CheckedCard where + required := required_618_i5 + envelope := envelope_618_i5 + height := height_618_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_618_i5 +def height_618_i8 : ℕ := 4 +def childrenH_618_i8 : Fin 2 → ℕ := ![height_4, height_113] +theorem height_exact_618_i8 : height_618_i8 = 1 + Finset.univ.sup childrenH_618_i8 := by decide +kernel +theorem required_origin_618_i8 : ∀ x ∈ required_618_i8, + (∃ j, x ∈ childrenC_618_i8 j) ∨ ∀ j, x ∈ childrenD_618_i8 j := by decide +kernel +theorem required_exact_618_i8 : required_618_i8 = + ((Finset.univ.biUnion childrenC_618_i8) ∪ commonEnvelope childrenD_618_i8).erase (6, 4) := by + exact required_eq_combination childrenC_618_i8 childrenD_618_i8 (6, 4) required_618_i8 + (by decide +kernel) child_required_sub_618_i8 common_sub_618_i8 required_origin_618_i8 +theorem envelope_origin_618_i8 : ∀ x ∈ envelope_618_i8, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_618_i8 j := by decide +kernel +theorem envelope_exact_618_i8 : envelope_618_i8 = + insert (6, 4) (Finset.univ.biUnion childrenD_618_i8) := by + exact envelope_eq_combination childrenD_618_i8 (6, 4) envelope_618_i8 + pivot_mem_618_i8 child_envelope_sub_618_i8 envelope_origin_618_i8 +def checked_618_i8 : CheckedCard where + required := required_618_i8 + envelope := envelope_618_i8 + height := height_618_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_618_i8 +def height_618_i7 : ℕ := 5 +def childrenH_618_i7 : Fin 2 → ℕ := ![height_5, height_618_i8] +theorem height_exact_618_i7 : height_618_i7 = 1 + Finset.univ.sup childrenH_618_i7 := by decide +kernel +theorem required_origin_618_i7 : ∀ x ∈ required_618_i7, + (∃ j, x ∈ childrenC_618_i7 j) ∨ ∀ j, x ∈ childrenD_618_i7 j := by decide +kernel +theorem required_exact_618_i7 : required_618_i7 = + ((Finset.univ.biUnion childrenC_618_i7) ∪ commonEnvelope childrenD_618_i7).erase (3, 4) := by + exact required_eq_combination childrenC_618_i7 childrenD_618_i7 (3, 4) required_618_i7 + (by decide +kernel) child_required_sub_618_i7 common_sub_618_i7 required_origin_618_i7 +theorem envelope_origin_618_i7 : ∀ x ∈ envelope_618_i7, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_618_i7 j := by decide +kernel +theorem envelope_exact_618_i7 : envelope_618_i7 = + insert (3, 4) (Finset.univ.biUnion childrenD_618_i7) := by + exact envelope_eq_combination childrenD_618_i7 (3, 4) envelope_618_i7 + pivot_mem_618_i7 child_envelope_sub_618_i7 envelope_origin_618_i7 +def checked_618_i7 : CheckedCard where + required := required_618_i7 + envelope := envelope_618_i7 + height := height_618_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_618_i7 +def height_618_i6 : ℕ := 11 +def childrenH_618_i6 : Fin 4 → ℕ := ![height_80, height_111, height_616, height_618_i7] +theorem height_exact_618_i6 : height_618_i6 = 1 + Finset.univ.sup childrenH_618_i6 := by decide +kernel +theorem required_origin_618_i6 : ∀ x ∈ required_618_i6, + (∃ j, x ∈ childrenC_618_i6 j) ∨ ∀ j, x ∈ childrenD_618_i6 j := by decide +kernel +theorem required_exact_618_i6 : required_618_i6 = + ((Finset.univ.biUnion childrenC_618_i6) ∪ commonEnvelope childrenD_618_i6).erase (4, 4) := by + exact required_eq_combination childrenC_618_i6 childrenD_618_i6 (4, 4) required_618_i6 + (by decide +kernel) child_required_sub_618_i6 common_sub_618_i6 required_origin_618_i6 +theorem envelope_origin_618_i6 : ∀ x ∈ envelope_618_i6, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_618_i6 j := by decide +kernel +theorem envelope_exact_618_i6 : envelope_618_i6 = + insert (4, 4) (Finset.univ.biUnion childrenD_618_i6) := by + exact envelope_eq_combination childrenD_618_i6 (4, 4) envelope_618_i6 + pivot_mem_618_i6 child_envelope_sub_618_i6 envelope_origin_618_i6 +def checked_618_i6 : CheckedCard where + required := required_618_i6 + envelope := envelope_618_i6 + height := height_618_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_618_i6 +def height_618 : ℕ := 12 +def childrenH_618 : Fin 9 → ℕ := ![height_398, height_434, height_610, height_618_i0, height_618_i3, height_618_i4, height_618_i5, height_615, height_618_i6] +theorem height_exact_618 : height_618 = 1 + Finset.univ.sup childrenH_618 := by decide +kernel +theorem required_origin_618 : ∀ x ∈ required_618, + (∃ j, x ∈ childrenC_618 j) ∨ ∀ j, x ∈ childrenD_618 j := by decide +kernel +theorem required_exact_618 : required_618 = + ((Finset.univ.biUnion childrenC_618) ∪ commonEnvelope childrenD_618).erase (5, 5) := by + exact required_eq_combination childrenC_618 childrenD_618 (5, 5) required_618 + (by decide +kernel) child_required_sub_618 common_sub_618 required_origin_618 +theorem envelope_origin_618 : ∀ x ∈ envelope_618, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_618 j := by decide +kernel +theorem envelope_exact_618 : envelope_618 = + insert (5, 5) (Finset.univ.biUnion childrenD_618) := by + exact envelope_eq_combination childrenD_618 (5, 5) envelope_618 + pivot_mem_618 child_envelope_sub_618 envelope_origin_618 +def checked_618 : CheckedCard where + required := required_618 + envelope := envelope_618 + height := height_618 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_618 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part04.lean new file mode 100644 index 0000000..95fcb04 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part04.lean @@ -0,0 +1,882 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part08 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_632_i2 : Finset Cell := ⟨(([(1, 4), (3, 3), (3, 4), (3, 5), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_632_i2 : Finset Cell := ⟨(([(1, 2), (1, 4), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_632_i2 : Fin 2 → Finset Cell := ![(placed21 3 (1, 5) required_92), (placed21 1 (1, 2) required_378)] +def childrenD_632_i2 : Fin 2 → Finset Cell := ![(placed21 3 (1, 5) envelope_92), (placed21 1 (1, 2) envelope_378)] +theorem common_sub_632_i2 : commonEnvelope childrenD_632_i2 ⊆ insert (3, 2) required_632_i2 := by decide +kernel +theorem child_required_sub_632_i2 : ∀ j, childrenC_632_i2 j ⊆ insert (3, 2) required_632_i2 := by decide +kernel +theorem child_envelope_sub_632_i2 : ∀ j, childrenD_632_i2 j ⊆ envelope_632_i2 := by decide +kernel +theorem pivot_mem_632_i2 : (3, 2) ∈ envelope_632_i2 := by decide +kernel +theorem children_work_632_i2 : ∀ j, Template HasSnaky 6 (childrenC_632_i2 j) (childrenD_632_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_92 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_378 1 (1, 2)).mono (by decide +kernel) +theorem row_works_632_i2 : Template HasSnaky 7 required_632_i2 envelope_632_i2 := by + refine compose HasSnaky 6 childrenC_632_i2 childrenD_632_i2 children_work_632_i2 (3, 2) + required_632_i2 envelope_632_i2 pivot_mem_632_i2 child_required_sub_632_i2 child_envelope_sub_632_i2 ?_ + intro b hb + exact common_sub_632_i2 (mem_commonEnvelope childrenD_632_i2 b hb) +def required_632_i1 : Finset Cell := ⟨(([(1, 4), (3, 3), (3, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_632_i1 : Finset Cell := ⟨(([(0, 4), (1, 2), (1, 4), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_632_i1 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) required_10), (placed21 4 (3, 6) required_52), (placed21 0 (0, 2) required_82), required_632_i2] +def childrenD_632_i1 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) envelope_10), (placed21 4 (3, 6) envelope_52), (placed21 0 (0, 2) envelope_82), envelope_632_i2] +theorem common_sub_632_i1 : commonEnvelope childrenD_632_i1 ⊆ insert (3, 5) required_632_i1 := by decide +kernel +theorem child_required_sub_632_i1 : ∀ j, childrenC_632_i1 j ⊆ insert (3, 5) required_632_i1 := by decide +kernel +theorem child_envelope_sub_632_i1 : ∀ j, childrenD_632_i1 j ⊆ envelope_632_i1 := by decide +kernel +theorem pivot_mem_632_i1 : (3, 5) ∈ envelope_632_i1 := by decide +kernel +theorem children_work_632_i1 : ∀ j, Template HasSnaky 7 (childrenC_632_i1 j) (childrenD_632_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_82 0 (0, 2)).mono (by decide +kernel) + · exact row_works_632_i2.mono (by decide +kernel) +theorem row_works_632_i1 : Template HasSnaky 8 required_632_i1 envelope_632_i1 := by + refine compose HasSnaky 7 childrenC_632_i1 childrenD_632_i1 children_work_632_i1 (3, 5) + required_632_i1 envelope_632_i1 pivot_mem_632_i1 child_required_sub_632_i1 child_envelope_sub_632_i1 ?_ + intro b hb + exact common_sub_632_i1 (mem_commonEnvelope childrenD_632_i1 b hb) +def required_632_i0 : Finset Cell := ⟨(([(1, 4), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_632_i0 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 4), (2, 1), (2, 2), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_632_i0 : Fin 4 → Finset Cell := ![(placed21 3 (0, 4) required_54), (placed21 5 (6, 2) required_294), required_632_i1, required_631] +def childrenD_632_i0 : Fin 4 → Finset Cell := ![(placed21 3 (0, 4) envelope_54), (placed21 5 (6, 2) envelope_294), envelope_632_i1, envelope_631] +theorem common_sub_632_i0 : commonEnvelope childrenD_632_i0 ⊆ insert (3, 4) required_632_i0 := by decide +kernel +theorem child_required_sub_632_i0 : ∀ j, childrenC_632_i0 j ⊆ insert (3, 4) required_632_i0 := by decide +kernel +theorem child_envelope_sub_632_i0 : ∀ j, childrenD_632_i0 j ⊆ envelope_632_i0 := by decide +kernel +theorem pivot_mem_632_i0 : (3, 4) ∈ envelope_632_i0 := by decide +kernel +theorem children_work_632_i0 : ∀ j, Template HasSnaky 10 (childrenC_632_i0 j) (childrenD_632_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_294 5 (6, 2)).mono (by decide +kernel) + · exact row_works_632_i1.mono (by decide +kernel) + · exact row_works_631.mono (by decide +kernel) +theorem row_works_632_i0 : Template HasSnaky 11 required_632_i0 envelope_632_i0 := by + refine compose HasSnaky 10 childrenC_632_i0 childrenD_632_i0 children_work_632_i0 (3, 4) + required_632_i0 envelope_632_i0 pivot_mem_632_i0 child_required_sub_632_i0 child_envelope_sub_632_i0 ?_ + intro b hb + exact common_sub_632_i0 (mem_commonEnvelope childrenD_632_i0 b hb) +def required_632 : Finset Cell := ⟨(([(1, 3), (1, 4), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_632 : Finset Cell := ⟨(([(0, 2), (0, 4), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_632 : Fin 5 → Finset Cell := ![(placed21 3 (0, 4) required_50), (placed21 3 (0, 4) required_125), (placed21 5 (5, 2) required_454), (placed21 0 (1, 2) required_455), required_632_i0] +def childrenD_632 : Fin 5 → Finset Cell := ![(placed21 3 (0, 4) envelope_50), (placed21 3 (0, 4) envelope_125), (placed21 5 (5, 2) envelope_454), (placed21 0 (1, 2) envelope_455), envelope_632_i0] +theorem common_sub_632 : commonEnvelope childrenD_632 ⊆ insert (3, 3) required_632 := by decide +kernel +theorem child_required_sub_632 : ∀ j, childrenC_632 j ⊆ insert (3, 3) required_632 := by decide +kernel +theorem child_envelope_sub_632 : ∀ j, childrenD_632 j ⊆ envelope_632 := by decide +kernel +theorem pivot_mem_632 : (3, 3) ∈ envelope_632 := by decide +kernel +theorem children_work_632 : ∀ j, Template HasSnaky 11 (childrenC_632 j) (childrenD_632 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_50 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_125 3 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_454 5 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_455 0 (1, 2)).mono (by decide +kernel) + · exact row_works_632_i0.mono (by decide +kernel) +theorem row_works_632 : Template HasSnaky 12 required_632 envelope_632 := by + refine compose HasSnaky 11 childrenC_632 childrenD_632 children_work_632 (3, 3) + required_632 envelope_632 pivot_mem_632 child_required_sub_632 child_envelope_sub_632 ?_ + intro b hb + exact common_sub_632 (mem_commonEnvelope childrenD_632 b hb) +def required_635_i0 : Finset Cell := ⟨(([(2, 3), (2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_635_i0 : Finset Cell := ⟨(([(0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 6), (5, 7), (6, 5), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_635_i0 : Fin 3 → Finset Cell := ![(placed21 2 (2, 2) required_7), (placed21 0 (1, 2) required_9), (placed21 1 (0, 3) required_395)] +def childrenD_635_i0 : Fin 3 → Finset Cell := ![(placed21 2 (2, 2) envelope_7), (placed21 0 (1, 2) envelope_9), (placed21 1 (0, 3) envelope_395)] +theorem common_sub_635_i0 : commonEnvelope childrenD_635_i0 ⊆ insert (2, 6) required_635_i0 := by decide +kernel +theorem child_required_sub_635_i0 : ∀ j, childrenC_635_i0 j ⊆ insert (2, 6) required_635_i0 := by decide +kernel +theorem child_envelope_sub_635_i0 : ∀ j, childrenD_635_i0 j ⊆ envelope_635_i0 := by decide +kernel +theorem pivot_mem_635_i0 : (2, 6) ∈ envelope_635_i0 := by decide +kernel +theorem children_work_635_i0 : ∀ j, Template HasSnaky 8 (childrenC_635_i0 j) (childrenD_635_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_9 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_395 1 (0, 3)).mono (by decide +kernel) +theorem row_works_635_i0 : Template HasSnaky 9 required_635_i0 envelope_635_i0 := by + refine compose HasSnaky 8 childrenC_635_i0 childrenD_635_i0 children_work_635_i0 (2, 6) + required_635_i0 envelope_635_i0 pivot_mem_635_i0 child_required_sub_635_i0 child_envelope_sub_635_i0 ?_ + intro b hb + exact common_sub_635_i0 (mem_commonEnvelope childrenD_635_i0 b hb) +def required_635 : Finset Cell := ⟨(([(2, 4), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_635 : Finset Cell := ⟨(([(0, 3), (0, 6), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_635 : Fin 5 → Finset Cell := ![(placed21 4 (1, 7) required_14), (placed21 6 (3, 7) required_33), (placed21 3 (0, 6) required_181), (placed21 3 (0, 6) required_589), required_635_i0] +def childrenD_635 : Fin 5 → Finset Cell := ![(placed21 4 (1, 7) envelope_14), (placed21 6 (3, 7) envelope_33), (placed21 3 (0, 6) envelope_181), (placed21 3 (0, 6) envelope_589), envelope_635_i0] +theorem common_sub_635 : commonEnvelope childrenD_635 ⊆ insert (2, 3) required_635 := by decide +kernel +theorem child_required_sub_635 : ∀ j, childrenC_635 j ⊆ insert (2, 3) required_635 := by decide +kernel +theorem child_envelope_sub_635 : ∀ j, childrenD_635 j ⊆ envelope_635 := by decide +kernel +theorem pivot_mem_635 : (2, 3) ∈ envelope_635 := by decide +kernel +theorem children_work_635 : ∀ j, Template HasSnaky 11 (childrenC_635 j) (childrenD_635 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_33 6 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_181 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_589 3 (0, 6)).mono (by decide +kernel) + · exact row_works_635_i0.mono (by decide +kernel) +theorem row_works_635 : Template HasSnaky 12 required_635 envelope_635 := by + refine compose HasSnaky 11 childrenC_635 childrenD_635 children_work_635 (2, 3) + required_635 envelope_635 pivot_mem_635 child_required_sub_635 child_envelope_sub_635 ?_ + intro b hb + exact common_sub_635 (mem_commonEnvelope childrenD_635 b hb) +def required_649_i7 : Finset Cell := ⟨(([(2, 3), (2, 5), (2, 6), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_649_i7 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 5), (2, 6), (3, 3), (3, 4), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_649_i7 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_0), (placed21 2 (4, 2) required_78)] +def childrenD_649_i7 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_0), (placed21 2 (4, 2) envelope_78)] +theorem common_sub_649_i7 : commonEnvelope childrenD_649_i7 ⊆ insert (1, 3) required_649_i7 := by decide +kernel +theorem child_required_sub_649_i7 : ∀ j, childrenC_649_i7 j ⊆ insert (1, 3) required_649_i7 := by decide +kernel +theorem child_envelope_sub_649_i7 : ∀ j, childrenD_649_i7 j ⊆ envelope_649_i7 := by decide +kernel +theorem pivot_mem_649_i7 : (1, 3) ∈ envelope_649_i7 := by decide +kernel +theorem children_work_649_i7 : ∀ j, Template HasSnaky 3 (childrenC_649_i7 j) (childrenD_649_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_78 2 (4, 2)).mono (by decide +kernel) +theorem row_works_649_i7 : Template HasSnaky 4 required_649_i7 envelope_649_i7 := by + refine compose HasSnaky 3 childrenC_649_i7 childrenD_649_i7 children_work_649_i7 (1, 3) + required_649_i7 envelope_649_i7 pivot_mem_649_i7 child_required_sub_649_i7 child_envelope_sub_649_i7 ?_ + intro b hb + exact common_sub_649_i7 (mem_commonEnvelope childrenD_649_i7 b hb) +def required_649_i6 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_649_i6 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_649_i6 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) required_5), required_649_i7] +def childrenD_649_i6 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) envelope_5), envelope_649_i7] +theorem common_sub_649_i6 : commonEnvelope childrenD_649_i6 ⊆ insert (2, 3) required_649_i6 := by decide +kernel +theorem child_required_sub_649_i6 : ∀ j, childrenC_649_i6 j ⊆ insert (2, 3) required_649_i6 := by decide +kernel +theorem child_envelope_sub_649_i6 : ∀ j, childrenD_649_i6 j ⊆ envelope_649_i6 := by decide +kernel +theorem pivot_mem_649_i6 : (2, 3) ∈ envelope_649_i6 := by decide +kernel +theorem children_work_649_i6 : ∀ j, Template HasSnaky 4 (childrenC_649_i6 j) (childrenD_649_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (3, 6)).mono (by decide +kernel) + · exact row_works_649_i7.mono (by decide +kernel) +theorem row_works_649_i6 : Template HasSnaky 5 required_649_i6 envelope_649_i6 := by + refine compose HasSnaky 4 childrenC_649_i6 childrenD_649_i6 children_work_649_i6 (2, 3) + required_649_i6 envelope_649_i6 pivot_mem_649_i6 child_required_sub_649_i6 child_envelope_sub_649_i6 ?_ + intro b hb + exact common_sub_649_i6 (mem_commonEnvelope childrenD_649_i6 b hb) +def required_649_i5 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 3), (3, 5), (3, 6), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_649_i5 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_649_i5 : Fin 2 → Finset Cell := ![(placed21 5 (3, 3) required_5), required_649_i6] +def childrenD_649_i5 : Fin 2 → Finset Cell := ![(placed21 5 (3, 3) envelope_5), envelope_649_i6] +theorem common_sub_649_i5 : commonEnvelope childrenD_649_i5 ⊆ insert (3, 4) required_649_i5 := by decide +kernel +theorem child_required_sub_649_i5 : ∀ j, childrenC_649_i5 j ⊆ insert (3, 4) required_649_i5 := by decide +kernel +theorem child_envelope_sub_649_i5 : ∀ j, childrenD_649_i5 j ⊆ envelope_649_i5 := by decide +kernel +theorem pivot_mem_649_i5 : (3, 4) ∈ envelope_649_i5 := by decide +kernel +theorem children_work_649_i5 : ∀ j, Template HasSnaky 5 (childrenC_649_i5 j) (childrenD_649_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (3, 3)).mono (by decide +kernel) + · exact row_works_649_i6.mono (by decide +kernel) +theorem row_works_649_i5 : Template HasSnaky 6 required_649_i5 envelope_649_i5 := by + refine compose HasSnaky 5 childrenC_649_i5 childrenD_649_i5 children_work_649_i5 (3, 4) + required_649_i5 envelope_649_i5 pivot_mem_649_i5 child_required_sub_649_i5 child_envelope_sub_649_i5 ?_ + intro b hb + exact common_sub_649_i5 (mem_commonEnvelope childrenD_649_i5 b hb) +def required_649_i4 : Finset Cell := ⟨(([(2, 5), (3, 3), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_649_i4 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_649_i4 : Fin 2 → Finset Cell := ![(placed21 5 (5, 5) required_15), required_649_i5] +def childrenD_649_i4 : Fin 2 → Finset Cell := ![(placed21 5 (5, 5) envelope_15), envelope_649_i5] +theorem common_sub_649_i4 : commonEnvelope childrenD_649_i4 ⊆ insert (2, 6) required_649_i4 := by decide +kernel +theorem child_required_sub_649_i4 : ∀ j, childrenC_649_i4 j ⊆ insert (2, 6) required_649_i4 := by decide +kernel +theorem child_envelope_sub_649_i4 : ∀ j, childrenD_649_i4 j ⊆ envelope_649_i4 := by decide +kernel +theorem pivot_mem_649_i4 : (2, 6) ∈ envelope_649_i4 := by decide +kernel +theorem children_work_649_i4 : ∀ j, Template HasSnaky 6 (childrenC_649_i4 j) (childrenD_649_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 5 (5, 5)).mono (by decide +kernel) + · exact row_works_649_i5.mono (by decide +kernel) +theorem row_works_649_i4 : Template HasSnaky 7 required_649_i4 envelope_649_i4 := by + refine compose HasSnaky 6 childrenC_649_i4 childrenD_649_i4 children_work_649_i4 (2, 6) + required_649_i4 envelope_649_i4 pivot_mem_649_i4 child_required_sub_649_i4 child_envelope_sub_649_i4 ?_ + intro b hb + exact common_sub_649_i4 (mem_commonEnvelope childrenD_649_i4 b hb) +def required_649_i3 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_649_i3 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_649_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 6) required_5), required_649_i4] +def childrenD_649_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 6) envelope_5), envelope_649_i4] +theorem common_sub_649_i3 : commonEnvelope childrenD_649_i3 ⊆ insert (3, 3) required_649_i3 := by decide +kernel +theorem child_required_sub_649_i3 : ∀ j, childrenC_649_i3 j ⊆ insert (3, 3) required_649_i3 := by decide +kernel +theorem child_envelope_sub_649_i3 : ∀ j, childrenD_649_i3 j ⊆ envelope_649_i3 := by decide +kernel +theorem pivot_mem_649_i3 : (3, 3) ∈ envelope_649_i3 := by decide +kernel +theorem children_work_649_i3 : ∀ j, Template HasSnaky 7 (childrenC_649_i3 j) (childrenD_649_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (4, 6)).mono (by decide +kernel) + · exact row_works_649_i4.mono (by decide +kernel) +theorem row_works_649_i3 : Template HasSnaky 8 required_649_i3 envelope_649_i3 := by + refine compose HasSnaky 7 childrenC_649_i3 childrenD_649_i3 children_work_649_i3 (3, 3) + required_649_i3 envelope_649_i3 pivot_mem_649_i3 child_required_sub_649_i3 child_envelope_sub_649_i3 ?_ + intro b hb + exact common_sub_649_i3 (mem_commonEnvelope childrenD_649_i3 b hb) +def required_649_i2 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_649_i2 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_649_i2 : Fin 2 → Finset Cell := ![(placed21 5 (4, 3) required_5), required_649_i3] +def childrenD_649_i2 : Fin 2 → Finset Cell := ![(placed21 5 (4, 3) envelope_5), envelope_649_i3] +theorem common_sub_649_i2 : commonEnvelope childrenD_649_i2 ⊆ insert (3, 6) required_649_i2 := by decide +kernel +theorem child_required_sub_649_i2 : ∀ j, childrenC_649_i2 j ⊆ insert (3, 6) required_649_i2 := by decide +kernel +theorem child_envelope_sub_649_i2 : ∀ j, childrenD_649_i2 j ⊆ envelope_649_i2 := by decide +kernel +theorem pivot_mem_649_i2 : (3, 6) ∈ envelope_649_i2 := by decide +kernel +theorem children_work_649_i2 : ∀ j, Template HasSnaky 8 (childrenC_649_i2 j) (childrenD_649_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (4, 3)).mono (by decide +kernel) + · exact row_works_649_i3.mono (by decide +kernel) +theorem row_works_649_i2 : Template HasSnaky 9 required_649_i2 envelope_649_i2 := by + refine compose HasSnaky 8 childrenC_649_i2 childrenD_649_i2 children_work_649_i2 (3, 6) + required_649_i2 envelope_649_i2 pivot_mem_649_i2 child_required_sub_649_i2 child_envelope_sub_649_i2 ?_ + intro b hb + exact common_sub_649_i2 (mem_commonEnvelope childrenD_649_i2 b hb) +def required_649_i1 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 3), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_649_i1 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_649_i1 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) required_19), (placed21 0 (3, 2) required_84), (placed21 1 (3, 3) required_314), required_649_i2] +def childrenD_649_i1 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) envelope_19), (placed21 0 (3, 2) envelope_84), (placed21 1 (3, 3) envelope_314), envelope_649_i2] +theorem common_sub_649_i1 : commonEnvelope childrenD_649_i1 ⊆ insert (4, 6) required_649_i1 := by decide +kernel +theorem child_required_sub_649_i1 : ∀ j, childrenC_649_i1 j ⊆ insert (4, 6) required_649_i1 := by decide +kernel +theorem child_envelope_sub_649_i1 : ∀ j, childrenD_649_i1 j ⊆ envelope_649_i1 := by decide +kernel +theorem pivot_mem_649_i1 : (4, 6) ∈ envelope_649_i1 := by decide +kernel +theorem children_work_649_i1 : ∀ j, Template HasSnaky 9 (childrenC_649_i1 j) (childrenD_649_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_84 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_314 1 (3, 3)).mono (by decide +kernel) + · exact row_works_649_i2.mono (by decide +kernel) +theorem row_works_649_i1 : Template HasSnaky 10 required_649_i1 envelope_649_i1 := by + refine compose HasSnaky 9 childrenC_649_i1 childrenD_649_i1 children_work_649_i1 (4, 6) + required_649_i1 envelope_649_i1 pivot_mem_649_i1 child_required_sub_649_i1 child_envelope_sub_649_i1 ?_ + intro b hb + exact common_sub_649_i1 (mem_commonEnvelope childrenD_649_i1 b hb) +def required_649_i0 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_649_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 5), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_649_i0 : Fin 4 → Finset Cell := ![(placed21 4 (3, 6) required_10), (placed21 2 (4, 2) required_44), (placed21 4 (3, 6) required_63), required_649_i1] +def childrenD_649_i0 : Fin 4 → Finset Cell := ![(placed21 4 (3, 6) envelope_10), (placed21 2 (4, 2) envelope_44), (placed21 4 (3, 6) envelope_63), envelope_649_i1] +theorem common_sub_649_i0 : commonEnvelope childrenD_649_i0 ⊆ insert (4, 3) required_649_i0 := by decide +kernel +theorem child_required_sub_649_i0 : ∀ j, childrenC_649_i0 j ⊆ insert (4, 3) required_649_i0 := by decide +kernel +theorem child_envelope_sub_649_i0 : ∀ j, childrenD_649_i0 j ⊆ envelope_649_i0 := by decide +kernel +theorem pivot_mem_649_i0 : (4, 3) ∈ envelope_649_i0 := by decide +kernel +theorem children_work_649_i0 : ∀ j, Template HasSnaky 10 (childrenC_649_i0 j) (childrenD_649_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_44 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_63 4 (3, 6)).mono (by decide +kernel) + · exact row_works_649_i1.mono (by decide +kernel) +theorem row_works_649_i0 : Template HasSnaky 11 required_649_i0 envelope_649_i0 := by + refine compose HasSnaky 10 childrenC_649_i0 childrenD_649_i0 children_work_649_i0 (4, 3) + required_649_i0 envelope_649_i0 pivot_mem_649_i0 child_required_sub_649_i0 child_envelope_sub_649_i0 ?_ + intro b hb + exact common_sub_649_i0 (mem_commonEnvelope childrenD_649_i0 b hb) +def required_649 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_649 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_649 : Fin 3 → Finset Cell := ![(placed21 3 (1, 5) required_52), (placed21 0 (1, 1) required_523), required_649_i0] +def childrenD_649 : Fin 3 → Finset Cell := ![(placed21 3 (1, 5) envelope_52), (placed21 0 (1, 1) envelope_523), envelope_649_i0] +theorem common_sub_649 : commonEnvelope childrenD_649 ⊆ insert (4, 4) required_649 := by decide +kernel +theorem child_required_sub_649 : ∀ j, childrenC_649 j ⊆ insert (4, 4) required_649 := by decide +kernel +theorem child_envelope_sub_649 : ∀ j, childrenD_649 j ⊆ envelope_649 := by decide +kernel +theorem pivot_mem_649 : (4, 4) ∈ envelope_649 := by decide +kernel +theorem children_work_649 : ∀ j, Template HasSnaky 11 (childrenC_649 j) (childrenD_649 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_523 0 (1, 1)).mono (by decide +kernel) + · exact row_works_649_i0.mono (by decide +kernel) +theorem row_works_649 : Template HasSnaky 12 required_649 envelope_649 := by + refine compose HasSnaky 11 childrenC_649 childrenD_649 children_work_649 (4, 4) + required_649 envelope_649 pivot_mem_649 child_required_sub_649 child_envelope_sub_649 ?_ + intro b hb + exact common_sub_649 (mem_commonEnvelope childrenD_649 b hb) +def required_654_i1 : Finset Cell := ⟨(([(3, 3), (3, 4), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_654_i1 : Finset Cell := ⟨(([(1, 4), (2, 4), (3, 3), (3, 4), (3, 5), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (6, 3), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_654_i1 : Fin 2 → Finset Cell := ![(placed21 7 (4, 7) required_0), (placed21 3 (1, 7) required_502)] +def childrenD_654_i1 : Fin 2 → Finset Cell := ![(placed21 7 (4, 7) envelope_0), (placed21 3 (1, 7) envelope_502)] +theorem common_sub_654_i1 : commonEnvelope childrenD_654_i1 ⊆ insert (4, 6) required_654_i1 := by decide +kernel +theorem child_required_sub_654_i1 : ∀ j, childrenC_654_i1 j ⊆ insert (4, 6) required_654_i1 := by decide +kernel +theorem child_envelope_sub_654_i1 : ∀ j, childrenD_654_i1 j ⊆ envelope_654_i1 := by decide +kernel +theorem pivot_mem_654_i1 : (4, 6) ∈ envelope_654_i1 := by decide +kernel +theorem children_work_654_i1 : ∀ j, Template HasSnaky 5 (childrenC_654_i1 j) (childrenD_654_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_502 3 (1, 7)).mono (by decide +kernel) +theorem row_works_654_i1 : Template HasSnaky 6 required_654_i1 envelope_654_i1 := by + refine compose HasSnaky 5 childrenC_654_i1 childrenD_654_i1 children_work_654_i1 (4, 6) + required_654_i1 envelope_654_i1 pivot_mem_654_i1 child_required_sub_654_i1 child_envelope_sub_654_i1 ?_ + intro b hb + exact common_sub_654_i1 (mem_commonEnvelope childrenD_654_i1 b hb) +def required_654_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_654_i0 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 5), (6, 6), (7, 2), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_654_i0 : Fin 4 → Finset Cell := ![(placed21 0 (3, 1) required_53), (placed21 6 (4, 7) required_53), (placed21 6 (7, 8) required_651), required_654_i1] +def childrenD_654_i0 : Fin 4 → Finset Cell := ![(placed21 0 (3, 1) envelope_53), (placed21 6 (4, 7) envelope_53), (placed21 6 (7, 8) envelope_651), envelope_654_i1] +theorem common_sub_654_i0 : commonEnvelope childrenD_654_i0 ⊆ insert (4, 5) required_654_i0 := by decide +kernel +theorem child_required_sub_654_i0 : ∀ j, childrenC_654_i0 j ⊆ insert (4, 5) required_654_i0 := by decide +kernel +theorem child_envelope_sub_654_i0 : ∀ j, childrenD_654_i0 j ⊆ envelope_654_i0 := by decide +kernel +theorem pivot_mem_654_i0 : (4, 5) ∈ envelope_654_i0 := by decide +kernel +theorem children_work_654_i0 : ∀ j, Template HasSnaky 8 (childrenC_654_i0 j) (childrenD_654_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_53 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_651 6 (7, 8)).mono (by decide +kernel) + · exact row_works_654_i1.mono (by decide +kernel) +theorem row_works_654_i0 : Template HasSnaky 9 required_654_i0 envelope_654_i0 := by + refine compose HasSnaky 8 childrenC_654_i0 childrenD_654_i0 children_work_654_i0 (4, 5) + required_654_i0 envelope_654_i0 pivot_mem_654_i0 child_required_sub_654_i0 child_envelope_sub_654_i0 ?_ + intro b hb + exact common_sub_654_i0 (mem_commonEnvelope childrenD_654_i0 b hb) +def required_654 : Finset Cell := ⟨(([(3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_654 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 3), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_654 : Fin 8 → Finset Cell := ![(placed21 1 (0, 2) required_248), (placed21 1 (0, 2) required_300), (placed21 1 (0, 1) required_436), (placed21 4 (1, 7) required_449), (placed21 0 (1, 1) required_509), (placed21 4 (1, 7) required_510), (placed21 3 (0, 7) required_653), required_654_i0] +def childrenD_654 : Fin 8 → Finset Cell := ![(placed21 1 (0, 2) envelope_248), (placed21 1 (0, 2) envelope_300), (placed21 1 (0, 1) envelope_436), (placed21 4 (1, 7) envelope_449), (placed21 0 (1, 1) envelope_509), (placed21 4 (1, 7) envelope_510), (placed21 3 (0, 7) envelope_653), envelope_654_i0] +theorem common_sub_654 : commonEnvelope childrenD_654 ⊆ insert (4, 4) required_654 := by decide +kernel +theorem child_required_sub_654 : ∀ j, childrenC_654 j ⊆ insert (4, 4) required_654 := by decide +kernel +theorem child_envelope_sub_654 : ∀ j, childrenD_654 j ⊆ envelope_654 := by decide +kernel +theorem pivot_mem_654 : (4, 4) ∈ envelope_654 := by decide +kernel +theorem children_work_654 : ∀ j, Template HasSnaky 11 (childrenC_654 j) (childrenD_654 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_248 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_300 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_436 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_449 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_509 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_510 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_653 3 (0, 7)).mono (by decide +kernel) + · exact row_works_654_i0.mono (by decide +kernel) +theorem row_works_654 : Template HasSnaky 12 required_654 envelope_654 := by + refine compose HasSnaky 11 childrenC_654 childrenD_654 children_work_654 (4, 4) + required_654 envelope_654 pivot_mem_654 child_required_sub_654 child_envelope_sub_654 ?_ + intro b hb + exact common_sub_654 (mem_commonEnvelope childrenD_654 b hb) +def required_677 : Finset Cell := ⟨(([(3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_677 : Finset Cell := ⟨(([(0, 3), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_677 : Fin 5 → Finset Cell := ![(placed21 6 (4, 7) required_13), (placed21 4 (2, 7) required_14), (placed21 6 (4, 7) required_33), (placed21 3 (1, 6) required_589), (placed21 1 (0, 2) required_676)] +def childrenD_677 : Fin 5 → Finset Cell := ![(placed21 6 (4, 7) envelope_13), (placed21 4 (2, 7) envelope_14), (placed21 6 (4, 7) envelope_33), (placed21 3 (1, 6) envelope_589), (placed21 1 (0, 2) envelope_676)] +theorem common_sub_677 : commonEnvelope childrenD_677 ⊆ insert (3, 3) required_677 := by decide +kernel +theorem child_required_sub_677 : ∀ j, childrenC_677 j ⊆ insert (3, 3) required_677 := by decide +kernel +theorem child_envelope_sub_677 : ∀ j, childrenD_677 j ⊆ envelope_677 := by decide +kernel +theorem pivot_mem_677 : (3, 3) ∈ envelope_677 := by decide +kernel +theorem children_work_677 : ∀ j, Template HasSnaky 11 (childrenC_677 j) (childrenD_677 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_14 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_33 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_589 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_676 1 (0, 2)).mono (by decide +kernel) +theorem row_works_677 : Template HasSnaky 12 required_677 envelope_677 := by + refine compose HasSnaky 11 childrenC_677 childrenD_677 children_work_677 (3, 3) + required_677 envelope_677 pivot_mem_677 child_required_sub_677 child_envelope_sub_677 ?_ + intro b hb + exact common_sub_677 (mem_commonEnvelope childrenD_677 b hb) +def required_687 : Finset Cell := ⟨(([(3, 4), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_687 : Finset Cell := ⟨(([(0, 3), (0, 5), (0, 6), (0, 7), (0, 8), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 5), (8, 6), (8, 7), (9, 5), (9, 6), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_687 : Fin 4 → Finset Cell := ![(placed21 1 (2, 4) required_44), (placed21 2 (6, 0) required_324), (placed21 1 (0, 1) required_685), (placed21 0 (1, 1) required_686)] +def childrenD_687 : Fin 4 → Finset Cell := ![(placed21 1 (2, 4) envelope_44), (placed21 2 (6, 0) envelope_324), (placed21 1 (0, 1) envelope_685), (placed21 0 (1, 1) envelope_686)] +theorem common_sub_687 : commonEnvelope childrenD_687 ⊆ insert (5, 5) required_687 := by decide +kernel +theorem child_required_sub_687 : ∀ j, childrenC_687 j ⊆ insert (5, 5) required_687 := by decide +kernel +theorem child_envelope_sub_687 : ∀ j, childrenD_687 j ⊆ envelope_687 := by decide +kernel +theorem pivot_mem_687 : (5, 5) ∈ envelope_687 := by decide +kernel +theorem children_work_687 : ∀ j, Template HasSnaky 11 (childrenC_687 j) (childrenD_687 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_324 2 (6, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_685 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_686 0 (1, 1)).mono (by decide +kernel) +theorem row_works_687 : Template HasSnaky 12 required_687 envelope_687 := by + refine compose HasSnaky 11 childrenC_687 childrenD_687 children_work_687 (5, 5) + required_687 envelope_687 pivot_mem_687 child_required_sub_687 child_envelope_sub_687 ?_ + intro b hb + exact common_sub_687 (mem_commonEnvelope childrenD_687 b hb) +def height_632_i2 : ℕ := 7 +def childrenH_632_i2 : Fin 2 → ℕ := ![height_92, height_378] +theorem height_exact_632_i2 : height_632_i2 = 1 + Finset.univ.sup childrenH_632_i2 := by decide +kernel +theorem required_origin_632_i2 : ∀ x ∈ required_632_i2, + (∃ j, x ∈ childrenC_632_i2 j) ∨ ∀ j, x ∈ childrenD_632_i2 j := by decide +kernel +theorem required_exact_632_i2 : required_632_i2 = + ((Finset.univ.biUnion childrenC_632_i2) ∪ commonEnvelope childrenD_632_i2).erase (3, 2) := by + exact required_eq_combination childrenC_632_i2 childrenD_632_i2 (3, 2) required_632_i2 + (by decide +kernel) child_required_sub_632_i2 common_sub_632_i2 required_origin_632_i2 +theorem envelope_origin_632_i2 : ∀ x ∈ envelope_632_i2, + x = (3, 2) ∨ ∃ j, x ∈ childrenD_632_i2 j := by decide +kernel +theorem envelope_exact_632_i2 : envelope_632_i2 = + insert (3, 2) (Finset.univ.biUnion childrenD_632_i2) := by + exact envelope_eq_combination childrenD_632_i2 (3, 2) envelope_632_i2 + pivot_mem_632_i2 child_envelope_sub_632_i2 envelope_origin_632_i2 +def checked_632_i2 : CheckedCard where + required := required_632_i2 + envelope := envelope_632_i2 + height := height_632_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_632_i2 +def height_632_i1 : ℕ := 8 +def childrenH_632_i1 : Fin 4 → ℕ := ![height_10, height_52, height_82, height_632_i2] +theorem height_exact_632_i1 : height_632_i1 = 1 + Finset.univ.sup childrenH_632_i1 := by decide +kernel +theorem required_origin_632_i1 : ∀ x ∈ required_632_i1, + (∃ j, x ∈ childrenC_632_i1 j) ∨ ∀ j, x ∈ childrenD_632_i1 j := by decide +kernel +theorem required_exact_632_i1 : required_632_i1 = + ((Finset.univ.biUnion childrenC_632_i1) ∪ commonEnvelope childrenD_632_i1).erase (3, 5) := by + exact required_eq_combination childrenC_632_i1 childrenD_632_i1 (3, 5) required_632_i1 + (by decide +kernel) child_required_sub_632_i1 common_sub_632_i1 required_origin_632_i1 +theorem envelope_origin_632_i1 : ∀ x ∈ envelope_632_i1, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_632_i1 j := by decide +kernel +theorem envelope_exact_632_i1 : envelope_632_i1 = + insert (3, 5) (Finset.univ.biUnion childrenD_632_i1) := by + exact envelope_eq_combination childrenD_632_i1 (3, 5) envelope_632_i1 + pivot_mem_632_i1 child_envelope_sub_632_i1 envelope_origin_632_i1 +def checked_632_i1 : CheckedCard where + required := required_632_i1 + envelope := envelope_632_i1 + height := height_632_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_632_i1 +def height_632_i0 : ℕ := 11 +def childrenH_632_i0 : Fin 4 → ℕ := ![height_54, height_294, height_632_i1, height_631] +theorem height_exact_632_i0 : height_632_i0 = 1 + Finset.univ.sup childrenH_632_i0 := by decide +kernel +theorem required_origin_632_i0 : ∀ x ∈ required_632_i0, + (∃ j, x ∈ childrenC_632_i0 j) ∨ ∀ j, x ∈ childrenD_632_i0 j := by decide +kernel +theorem required_exact_632_i0 : required_632_i0 = + ((Finset.univ.biUnion childrenC_632_i0) ∪ commonEnvelope childrenD_632_i0).erase (3, 4) := by + exact required_eq_combination childrenC_632_i0 childrenD_632_i0 (3, 4) required_632_i0 + (by decide +kernel) child_required_sub_632_i0 common_sub_632_i0 required_origin_632_i0 +theorem envelope_origin_632_i0 : ∀ x ∈ envelope_632_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_632_i0 j := by decide +kernel +theorem envelope_exact_632_i0 : envelope_632_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_632_i0) := by + exact envelope_eq_combination childrenD_632_i0 (3, 4) envelope_632_i0 + pivot_mem_632_i0 child_envelope_sub_632_i0 envelope_origin_632_i0 +def checked_632_i0 : CheckedCard where + required := required_632_i0 + envelope := envelope_632_i0 + height := height_632_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_632_i0 +def height_632 : ℕ := 12 +def childrenH_632 : Fin 5 → ℕ := ![height_50, height_125, height_454, height_455, height_632_i0] +theorem height_exact_632 : height_632 = 1 + Finset.univ.sup childrenH_632 := by decide +kernel +theorem required_origin_632 : ∀ x ∈ required_632, + (∃ j, x ∈ childrenC_632 j) ∨ ∀ j, x ∈ childrenD_632 j := by decide +kernel +theorem required_exact_632 : required_632 = + ((Finset.univ.biUnion childrenC_632) ∪ commonEnvelope childrenD_632).erase (3, 3) := by + exact required_eq_combination childrenC_632 childrenD_632 (3, 3) required_632 + (by decide +kernel) child_required_sub_632 common_sub_632 required_origin_632 +theorem envelope_origin_632 : ∀ x ∈ envelope_632, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_632 j := by decide +kernel +theorem envelope_exact_632 : envelope_632 = + insert (3, 3) (Finset.univ.biUnion childrenD_632) := by + exact envelope_eq_combination childrenD_632 (3, 3) envelope_632 + pivot_mem_632 child_envelope_sub_632 envelope_origin_632 +def checked_632 : CheckedCard where + required := required_632 + envelope := envelope_632 + height := height_632 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_632 +def height_635_i0 : ℕ := 9 +def childrenH_635_i0 : Fin 3 → ℕ := ![height_7, height_9, height_395] +theorem height_exact_635_i0 : height_635_i0 = 1 + Finset.univ.sup childrenH_635_i0 := by decide +kernel +theorem required_origin_635_i0 : ∀ x ∈ required_635_i0, + (∃ j, x ∈ childrenC_635_i0 j) ∨ ∀ j, x ∈ childrenD_635_i0 j := by decide +kernel +theorem required_exact_635_i0 : required_635_i0 = + ((Finset.univ.biUnion childrenC_635_i0) ∪ commonEnvelope childrenD_635_i0).erase (2, 6) := by + exact required_eq_combination childrenC_635_i0 childrenD_635_i0 (2, 6) required_635_i0 + (by decide +kernel) child_required_sub_635_i0 common_sub_635_i0 required_origin_635_i0 +theorem envelope_origin_635_i0 : ∀ x ∈ envelope_635_i0, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_635_i0 j := by decide +kernel +theorem envelope_exact_635_i0 : envelope_635_i0 = + insert (2, 6) (Finset.univ.biUnion childrenD_635_i0) := by + exact envelope_eq_combination childrenD_635_i0 (2, 6) envelope_635_i0 + pivot_mem_635_i0 child_envelope_sub_635_i0 envelope_origin_635_i0 +def checked_635_i0 : CheckedCard where + required := required_635_i0 + envelope := envelope_635_i0 + height := height_635_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_635_i0 +def height_635 : ℕ := 12 +def childrenH_635 : Fin 5 → ℕ := ![height_14, height_33, height_181, height_589, height_635_i0] +theorem height_exact_635 : height_635 = 1 + Finset.univ.sup childrenH_635 := by decide +kernel +theorem required_origin_635 : ∀ x ∈ required_635, + (∃ j, x ∈ childrenC_635 j) ∨ ∀ j, x ∈ childrenD_635 j := by decide +kernel +theorem required_exact_635 : required_635 = + ((Finset.univ.biUnion childrenC_635) ∪ commonEnvelope childrenD_635).erase (2, 3) := by + exact required_eq_combination childrenC_635 childrenD_635 (2, 3) required_635 + (by decide +kernel) child_required_sub_635 common_sub_635 required_origin_635 +theorem envelope_origin_635 : ∀ x ∈ envelope_635, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_635 j := by decide +kernel +theorem envelope_exact_635 : envelope_635 = + insert (2, 3) (Finset.univ.biUnion childrenD_635) := by + exact envelope_eq_combination childrenD_635 (2, 3) envelope_635 + pivot_mem_635 child_envelope_sub_635 envelope_origin_635 +def checked_635 : CheckedCard where + required := required_635 + envelope := envelope_635 + height := height_635 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_635 +def height_649_i7 : ℕ := 4 +def childrenH_649_i7 : Fin 2 → ℕ := ![height_0, height_78] +theorem height_exact_649_i7 : height_649_i7 = 1 + Finset.univ.sup childrenH_649_i7 := by decide +kernel +theorem required_origin_649_i7 : ∀ x ∈ required_649_i7, + (∃ j, x ∈ childrenC_649_i7 j) ∨ ∀ j, x ∈ childrenD_649_i7 j := by decide +kernel +theorem required_exact_649_i7 : required_649_i7 = + ((Finset.univ.biUnion childrenC_649_i7) ∪ commonEnvelope childrenD_649_i7).erase (1, 3) := by + exact required_eq_combination childrenC_649_i7 childrenD_649_i7 (1, 3) required_649_i7 + (by decide +kernel) child_required_sub_649_i7 common_sub_649_i7 required_origin_649_i7 +theorem envelope_origin_649_i7 : ∀ x ∈ envelope_649_i7, + x = (1, 3) ∨ ∃ j, x ∈ childrenD_649_i7 j := by decide +kernel +theorem envelope_exact_649_i7 : envelope_649_i7 = + insert (1, 3) (Finset.univ.biUnion childrenD_649_i7) := by + exact envelope_eq_combination childrenD_649_i7 (1, 3) envelope_649_i7 + pivot_mem_649_i7 child_envelope_sub_649_i7 envelope_origin_649_i7 +def checked_649_i7 : CheckedCard where + required := required_649_i7 + envelope := envelope_649_i7 + height := height_649_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_649_i7 +def height_649_i6 : ℕ := 5 +def childrenH_649_i6 : Fin 2 → ℕ := ![height_5, height_649_i7] +theorem height_exact_649_i6 : height_649_i6 = 1 + Finset.univ.sup childrenH_649_i6 := by decide +kernel +theorem required_origin_649_i6 : ∀ x ∈ required_649_i6, + (∃ j, x ∈ childrenC_649_i6 j) ∨ ∀ j, x ∈ childrenD_649_i6 j := by decide +kernel +theorem required_exact_649_i6 : required_649_i6 = + ((Finset.univ.biUnion childrenC_649_i6) ∪ commonEnvelope childrenD_649_i6).erase (2, 3) := by + exact required_eq_combination childrenC_649_i6 childrenD_649_i6 (2, 3) required_649_i6 + (by decide +kernel) child_required_sub_649_i6 common_sub_649_i6 required_origin_649_i6 +theorem envelope_origin_649_i6 : ∀ x ∈ envelope_649_i6, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_649_i6 j := by decide +kernel +theorem envelope_exact_649_i6 : envelope_649_i6 = + insert (2, 3) (Finset.univ.biUnion childrenD_649_i6) := by + exact envelope_eq_combination childrenD_649_i6 (2, 3) envelope_649_i6 + pivot_mem_649_i6 child_envelope_sub_649_i6 envelope_origin_649_i6 +def checked_649_i6 : CheckedCard where + required := required_649_i6 + envelope := envelope_649_i6 + height := height_649_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_649_i6 +def height_649_i5 : ℕ := 6 +def childrenH_649_i5 : Fin 2 → ℕ := ![height_5, height_649_i6] +theorem height_exact_649_i5 : height_649_i5 = 1 + Finset.univ.sup childrenH_649_i5 := by decide +kernel +theorem required_origin_649_i5 : ∀ x ∈ required_649_i5, + (∃ j, x ∈ childrenC_649_i5 j) ∨ ∀ j, x ∈ childrenD_649_i5 j := by decide +kernel +theorem required_exact_649_i5 : required_649_i5 = + ((Finset.univ.biUnion childrenC_649_i5) ∪ commonEnvelope childrenD_649_i5).erase (3, 4) := by + exact required_eq_combination childrenC_649_i5 childrenD_649_i5 (3, 4) required_649_i5 + (by decide +kernel) child_required_sub_649_i5 common_sub_649_i5 required_origin_649_i5 +theorem envelope_origin_649_i5 : ∀ x ∈ envelope_649_i5, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_649_i5 j := by decide +kernel +theorem envelope_exact_649_i5 : envelope_649_i5 = + insert (3, 4) (Finset.univ.biUnion childrenD_649_i5) := by + exact envelope_eq_combination childrenD_649_i5 (3, 4) envelope_649_i5 + pivot_mem_649_i5 child_envelope_sub_649_i5 envelope_origin_649_i5 +def checked_649_i5 : CheckedCard where + required := required_649_i5 + envelope := envelope_649_i5 + height := height_649_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_649_i5 +def height_649_i4 : ℕ := 7 +def childrenH_649_i4 : Fin 2 → ℕ := ![height_15, height_649_i5] +theorem height_exact_649_i4 : height_649_i4 = 1 + Finset.univ.sup childrenH_649_i4 := by decide +kernel +theorem required_origin_649_i4 : ∀ x ∈ required_649_i4, + (∃ j, x ∈ childrenC_649_i4 j) ∨ ∀ j, x ∈ childrenD_649_i4 j := by decide +kernel +theorem required_exact_649_i4 : required_649_i4 = + ((Finset.univ.biUnion childrenC_649_i4) ∪ commonEnvelope childrenD_649_i4).erase (2, 6) := by + exact required_eq_combination childrenC_649_i4 childrenD_649_i4 (2, 6) required_649_i4 + (by decide +kernel) child_required_sub_649_i4 common_sub_649_i4 required_origin_649_i4 +theorem envelope_origin_649_i4 : ∀ x ∈ envelope_649_i4, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_649_i4 j := by decide +kernel +theorem envelope_exact_649_i4 : envelope_649_i4 = + insert (2, 6) (Finset.univ.biUnion childrenD_649_i4) := by + exact envelope_eq_combination childrenD_649_i4 (2, 6) envelope_649_i4 + pivot_mem_649_i4 child_envelope_sub_649_i4 envelope_origin_649_i4 +def checked_649_i4 : CheckedCard where + required := required_649_i4 + envelope := envelope_649_i4 + height := height_649_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_649_i4 +def height_649_i3 : ℕ := 8 +def childrenH_649_i3 : Fin 2 → ℕ := ![height_5, height_649_i4] +theorem height_exact_649_i3 : height_649_i3 = 1 + Finset.univ.sup childrenH_649_i3 := by decide +kernel +theorem required_origin_649_i3 : ∀ x ∈ required_649_i3, + (∃ j, x ∈ childrenC_649_i3 j) ∨ ∀ j, x ∈ childrenD_649_i3 j := by decide +kernel +theorem required_exact_649_i3 : required_649_i3 = + ((Finset.univ.biUnion childrenC_649_i3) ∪ commonEnvelope childrenD_649_i3).erase (3, 3) := by + exact required_eq_combination childrenC_649_i3 childrenD_649_i3 (3, 3) required_649_i3 + (by decide +kernel) child_required_sub_649_i3 common_sub_649_i3 required_origin_649_i3 +theorem envelope_origin_649_i3 : ∀ x ∈ envelope_649_i3, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_649_i3 j := by decide +kernel +theorem envelope_exact_649_i3 : envelope_649_i3 = + insert (3, 3) (Finset.univ.biUnion childrenD_649_i3) := by + exact envelope_eq_combination childrenD_649_i3 (3, 3) envelope_649_i3 + pivot_mem_649_i3 child_envelope_sub_649_i3 envelope_origin_649_i3 +def checked_649_i3 : CheckedCard where + required := required_649_i3 + envelope := envelope_649_i3 + height := height_649_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_649_i3 +def height_649_i2 : ℕ := 9 +def childrenH_649_i2 : Fin 2 → ℕ := ![height_5, height_649_i3] +theorem height_exact_649_i2 : height_649_i2 = 1 + Finset.univ.sup childrenH_649_i2 := by decide +kernel +theorem required_origin_649_i2 : ∀ x ∈ required_649_i2, + (∃ j, x ∈ childrenC_649_i2 j) ∨ ∀ j, x ∈ childrenD_649_i2 j := by decide +kernel +theorem required_exact_649_i2 : required_649_i2 = + ((Finset.univ.biUnion childrenC_649_i2) ∪ commonEnvelope childrenD_649_i2).erase (3, 6) := by + exact required_eq_combination childrenC_649_i2 childrenD_649_i2 (3, 6) required_649_i2 + (by decide +kernel) child_required_sub_649_i2 common_sub_649_i2 required_origin_649_i2 +theorem envelope_origin_649_i2 : ∀ x ∈ envelope_649_i2, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_649_i2 j := by decide +kernel +theorem envelope_exact_649_i2 : envelope_649_i2 = + insert (3, 6) (Finset.univ.biUnion childrenD_649_i2) := by + exact envelope_eq_combination childrenD_649_i2 (3, 6) envelope_649_i2 + pivot_mem_649_i2 child_envelope_sub_649_i2 envelope_origin_649_i2 +def checked_649_i2 : CheckedCard where + required := required_649_i2 + envelope := envelope_649_i2 + height := height_649_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_649_i2 +def height_649_i1 : ℕ := 10 +def childrenH_649_i1 : Fin 4 → ℕ := ![height_19, height_84, height_314, height_649_i2] +theorem height_exact_649_i1 : height_649_i1 = 1 + Finset.univ.sup childrenH_649_i1 := by decide +kernel +theorem required_origin_649_i1 : ∀ x ∈ required_649_i1, + (∃ j, x ∈ childrenC_649_i1 j) ∨ ∀ j, x ∈ childrenD_649_i1 j := by decide +kernel +theorem required_exact_649_i1 : required_649_i1 = + ((Finset.univ.biUnion childrenC_649_i1) ∪ commonEnvelope childrenD_649_i1).erase (4, 6) := by + exact required_eq_combination childrenC_649_i1 childrenD_649_i1 (4, 6) required_649_i1 + (by decide +kernel) child_required_sub_649_i1 common_sub_649_i1 required_origin_649_i1 +theorem envelope_origin_649_i1 : ∀ x ∈ envelope_649_i1, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_649_i1 j := by decide +kernel +theorem envelope_exact_649_i1 : envelope_649_i1 = + insert (4, 6) (Finset.univ.biUnion childrenD_649_i1) := by + exact envelope_eq_combination childrenD_649_i1 (4, 6) envelope_649_i1 + pivot_mem_649_i1 child_envelope_sub_649_i1 envelope_origin_649_i1 +def checked_649_i1 : CheckedCard where + required := required_649_i1 + envelope := envelope_649_i1 + height := height_649_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_649_i1 +def height_649_i0 : ℕ := 11 +def childrenH_649_i0 : Fin 4 → ℕ := ![height_10, height_44, height_63, height_649_i1] +theorem height_exact_649_i0 : height_649_i0 = 1 + Finset.univ.sup childrenH_649_i0 := by decide +kernel +theorem required_origin_649_i0 : ∀ x ∈ required_649_i0, + (∃ j, x ∈ childrenC_649_i0 j) ∨ ∀ j, x ∈ childrenD_649_i0 j := by decide +kernel +theorem required_exact_649_i0 : required_649_i0 = + ((Finset.univ.biUnion childrenC_649_i0) ∪ commonEnvelope childrenD_649_i0).erase (4, 3) := by + exact required_eq_combination childrenC_649_i0 childrenD_649_i0 (4, 3) required_649_i0 + (by decide +kernel) child_required_sub_649_i0 common_sub_649_i0 required_origin_649_i0 +theorem envelope_origin_649_i0 : ∀ x ∈ envelope_649_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_649_i0 j := by decide +kernel +theorem envelope_exact_649_i0 : envelope_649_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_649_i0) := by + exact envelope_eq_combination childrenD_649_i0 (4, 3) envelope_649_i0 + pivot_mem_649_i0 child_envelope_sub_649_i0 envelope_origin_649_i0 +def checked_649_i0 : CheckedCard where + required := required_649_i0 + envelope := envelope_649_i0 + height := height_649_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_649_i0 +def height_649 : ℕ := 12 +def childrenH_649 : Fin 3 → ℕ := ![height_52, height_523, height_649_i0] +theorem height_exact_649 : height_649 = 1 + Finset.univ.sup childrenH_649 := by decide +kernel +theorem required_origin_649 : ∀ x ∈ required_649, + (∃ j, x ∈ childrenC_649 j) ∨ ∀ j, x ∈ childrenD_649 j := by decide +kernel +theorem required_exact_649 : required_649 = + ((Finset.univ.biUnion childrenC_649) ∪ commonEnvelope childrenD_649).erase (4, 4) := by + exact required_eq_combination childrenC_649 childrenD_649 (4, 4) required_649 + (by decide +kernel) child_required_sub_649 common_sub_649 required_origin_649 +theorem envelope_origin_649 : ∀ x ∈ envelope_649, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_649 j := by decide +kernel +theorem envelope_exact_649 : envelope_649 = + insert (4, 4) (Finset.univ.biUnion childrenD_649) := by + exact envelope_eq_combination childrenD_649 (4, 4) envelope_649 + pivot_mem_649 child_envelope_sub_649 envelope_origin_649 +def checked_649 : CheckedCard where + required := required_649 + envelope := envelope_649 + height := height_649 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_649 +def height_654_i1 : ℕ := 6 +def childrenH_654_i1 : Fin 2 → ℕ := ![height_0, height_502] +theorem height_exact_654_i1 : height_654_i1 = 1 + Finset.univ.sup childrenH_654_i1 := by decide +kernel +theorem required_origin_654_i1 : ∀ x ∈ required_654_i1, + (∃ j, x ∈ childrenC_654_i1 j) ∨ ∀ j, x ∈ childrenD_654_i1 j := by decide +kernel +theorem required_exact_654_i1 : required_654_i1 = + ((Finset.univ.biUnion childrenC_654_i1) ∪ commonEnvelope childrenD_654_i1).erase (4, 6) := by + exact required_eq_combination childrenC_654_i1 childrenD_654_i1 (4, 6) required_654_i1 + (by decide +kernel) child_required_sub_654_i1 common_sub_654_i1 required_origin_654_i1 +theorem envelope_origin_654_i1 : ∀ x ∈ envelope_654_i1, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_654_i1 j := by decide +kernel +theorem envelope_exact_654_i1 : envelope_654_i1 = + insert (4, 6) (Finset.univ.biUnion childrenD_654_i1) := by + exact envelope_eq_combination childrenD_654_i1 (4, 6) envelope_654_i1 + pivot_mem_654_i1 child_envelope_sub_654_i1 envelope_origin_654_i1 +def checked_654_i1 : CheckedCard where + required := required_654_i1 + envelope := envelope_654_i1 + height := height_654_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_654_i1 +def height_654_i0 : ℕ := 9 +def childrenH_654_i0 : Fin 4 → ℕ := ![height_53, height_53, height_651, height_654_i1] +theorem height_exact_654_i0 : height_654_i0 = 1 + Finset.univ.sup childrenH_654_i0 := by decide +kernel +theorem required_origin_654_i0 : ∀ x ∈ required_654_i0, + (∃ j, x ∈ childrenC_654_i0 j) ∨ ∀ j, x ∈ childrenD_654_i0 j := by decide +kernel +theorem required_exact_654_i0 : required_654_i0 = + ((Finset.univ.biUnion childrenC_654_i0) ∪ commonEnvelope childrenD_654_i0).erase (4, 5) := by + exact required_eq_combination childrenC_654_i0 childrenD_654_i0 (4, 5) required_654_i0 + (by decide +kernel) child_required_sub_654_i0 common_sub_654_i0 required_origin_654_i0 +theorem envelope_origin_654_i0 : ∀ x ∈ envelope_654_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_654_i0 j := by decide +kernel +theorem envelope_exact_654_i0 : envelope_654_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_654_i0) := by + exact envelope_eq_combination childrenD_654_i0 (4, 5) envelope_654_i0 + pivot_mem_654_i0 child_envelope_sub_654_i0 envelope_origin_654_i0 +def checked_654_i0 : CheckedCard where + required := required_654_i0 + envelope := envelope_654_i0 + height := height_654_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_654_i0 +def height_654 : ℕ := 12 +def childrenH_654 : Fin 8 → ℕ := ![height_248, height_300, height_436, height_449, height_509, height_510, height_653, height_654_i0] +theorem height_exact_654 : height_654 = 1 + Finset.univ.sup childrenH_654 := by decide +kernel +theorem required_origin_654 : ∀ x ∈ required_654, + (∃ j, x ∈ childrenC_654 j) ∨ ∀ j, x ∈ childrenD_654 j := by decide +kernel +theorem required_exact_654 : required_654 = + ((Finset.univ.biUnion childrenC_654) ∪ commonEnvelope childrenD_654).erase (4, 4) := by + exact required_eq_combination childrenC_654 childrenD_654 (4, 4) required_654 + (by decide +kernel) child_required_sub_654 common_sub_654 required_origin_654 +theorem envelope_origin_654 : ∀ x ∈ envelope_654, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_654 j := by decide +kernel +theorem envelope_exact_654 : envelope_654 = + insert (4, 4) (Finset.univ.biUnion childrenD_654) := by + exact envelope_eq_combination childrenD_654 (4, 4) envelope_654 + pivot_mem_654 child_envelope_sub_654 envelope_origin_654 +def checked_654 : CheckedCard where + required := required_654 + envelope := envelope_654 + height := height_654 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_654 +def height_677 : ℕ := 12 +def childrenH_677 : Fin 5 → ℕ := ![height_13, height_14, height_33, height_589, height_676] +theorem height_exact_677 : height_677 = 1 + Finset.univ.sup childrenH_677 := by decide +kernel +theorem required_origin_677 : ∀ x ∈ required_677, + (∃ j, x ∈ childrenC_677 j) ∨ ∀ j, x ∈ childrenD_677 j := by decide +kernel +theorem required_exact_677 : required_677 = + ((Finset.univ.biUnion childrenC_677) ∪ commonEnvelope childrenD_677).erase (3, 3) := by + exact required_eq_combination childrenC_677 childrenD_677 (3, 3) required_677 + (by decide +kernel) child_required_sub_677 common_sub_677 required_origin_677 +theorem envelope_origin_677 : ∀ x ∈ envelope_677, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_677 j := by decide +kernel +theorem envelope_exact_677 : envelope_677 = + insert (3, 3) (Finset.univ.biUnion childrenD_677) := by + exact envelope_eq_combination childrenD_677 (3, 3) envelope_677 + pivot_mem_677 child_envelope_sub_677 envelope_origin_677 +def checked_677 : CheckedCard where + required := required_677 + envelope := envelope_677 + height := height_677 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_677 +def height_687 : ℕ := 12 +def childrenH_687 : Fin 4 → ℕ := ![height_44, height_324, height_685, height_686] +theorem height_exact_687 : height_687 = 1 + Finset.univ.sup childrenH_687 := by decide +kernel +theorem required_origin_687 : ∀ x ∈ required_687, + (∃ j, x ∈ childrenC_687 j) ∨ ∀ j, x ∈ childrenD_687 j := by decide +kernel +theorem required_exact_687 : required_687 = + ((Finset.univ.biUnion childrenC_687) ∪ commonEnvelope childrenD_687).erase (5, 5) := by + exact required_eq_combination childrenC_687 childrenD_687 (5, 5) required_687 + (by decide +kernel) child_required_sub_687 common_sub_687 required_origin_687 +theorem envelope_origin_687 : ∀ x ∈ envelope_687, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_687 j := by decide +kernel +theorem envelope_exact_687 : envelope_687 = + insert (5, 5) (Finset.univ.biUnion childrenD_687) := by + exact envelope_eq_combination childrenD_687 (5, 5) envelope_687 + pivot_mem_687 child_envelope_sub_687 envelope_origin_687 +def checked_687 : CheckedCard where + required := required_687 + envelope := envelope_687 + height := height_687 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_687 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part05.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part05.lean new file mode 100644 index 0000000..4bdf82f --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part05.lean @@ -0,0 +1,780 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part06 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_715_i1 : Finset Cell := ⟨(([(3, 5), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_715_i1 : Finset Cell := ⟨(([(2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 5), (8, 6), (9, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_715_i1 : Fin 4 → Finset Cell := ![(placed21 6 (5, 8) required_53), (placed21 0 (4, 2) required_53), (placed21 0 (2, 2) required_111), (placed21 1 (2, 4) required_394)] +def childrenD_715_i1 : Fin 4 → Finset Cell := ![(placed21 6 (5, 8) envelope_53), (placed21 0 (4, 2) envelope_53), (placed21 0 (2, 2) envelope_111), (placed21 1 (2, 4) envelope_394)] +theorem common_sub_715_i1 : commonEnvelope childrenD_715_i1 ⊆ insert (4, 4) required_715_i1 := by decide +kernel +theorem child_required_sub_715_i1 : ∀ j, childrenC_715_i1 j ⊆ insert (4, 4) required_715_i1 := by decide +kernel +theorem child_envelope_sub_715_i1 : ∀ j, childrenD_715_i1 j ⊆ envelope_715_i1 := by decide +kernel +theorem pivot_mem_715_i1 : (4, 4) ∈ envelope_715_i1 := by decide +kernel +theorem children_work_715_i1 : ∀ j, Template HasSnaky 7 (childrenC_715_i1 j) (childrenD_715_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 6 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_53 0 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_111 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_394 1 (2, 4)).mono (by decide +kernel) +theorem row_works_715_i1 : Template HasSnaky 8 required_715_i1 envelope_715_i1 := by + refine compose HasSnaky 7 childrenC_715_i1 childrenD_715_i1 children_work_715_i1 (4, 4) + required_715_i1 envelope_715_i1 pivot_mem_715_i1 child_required_sub_715_i1 child_envelope_sub_715_i1 ?_ + intro b hb + exact common_sub_715_i1 (mem_commonEnvelope childrenD_715_i1 b hb) +def required_715_i0 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_715_i0 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (8, 4), (8, 5), (8, 6), (9, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_715_i0 : Fin 4 → Finset Cell := ![(placed21 1 (2, 5) required_44), (placed21 1 (2, 5) required_52), (placed21 2 (6, 3) required_134), required_715_i1] +def childrenD_715_i0 : Fin 4 → Finset Cell := ![(placed21 1 (2, 5) envelope_44), (placed21 1 (2, 5) envelope_52), (placed21 2 (6, 3) envelope_134), envelope_715_i1] +theorem common_sub_715_i0 : commonEnvelope childrenD_715_i0 ⊆ insert (3, 5) required_715_i0 := by decide +kernel +theorem child_required_sub_715_i0 : ∀ j, childrenC_715_i0 j ⊆ insert (3, 5) required_715_i0 := by decide +kernel +theorem child_envelope_sub_715_i0 : ∀ j, childrenD_715_i0 j ⊆ envelope_715_i0 := by decide +kernel +theorem pivot_mem_715_i0 : (3, 5) ∈ envelope_715_i0 := by decide +kernel +theorem children_work_715_i0 : ∀ j, Template HasSnaky 8 (childrenC_715_i0 j) (childrenD_715_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 1 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_52 1 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_134 2 (6, 3)).mono (by decide +kernel) + · exact row_works_715_i1.mono (by decide +kernel) +theorem row_works_715_i0 : Template HasSnaky 9 required_715_i0 envelope_715_i0 := by + refine compose HasSnaky 8 childrenC_715_i0 childrenD_715_i0 children_work_715_i0 (3, 5) + required_715_i0 envelope_715_i0 pivot_mem_715_i0 child_required_sub_715_i0 child_envelope_sub_715_i0 ?_ + intro b hb + exact common_sub_715_i0 (mem_commonEnvelope childrenD_715_i0 b hb) +def required_715_i4 : Finset Cell := ⟨(([(4, 5), (4, 6), (5, 5), (5, 6), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_715_i4 : Finset Cell := ⟨(([(3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (5, 8), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_715_i4 : Fin 4 → Finset Cell := ![(placed21 3 (4, 6) required_30), (placed21 0 (4, 3) required_110), (placed21 1 (3, 4) required_296), (placed21 0 (4, 3) required_511)] +def childrenD_715_i4 : Fin 4 → Finset Cell := ![(placed21 3 (4, 6) envelope_30), (placed21 0 (4, 3) envelope_110), (placed21 1 (3, 4) envelope_296), (placed21 0 (4, 3) envelope_511)] +theorem common_sub_715_i4 : commonEnvelope childrenD_715_i4 ⊆ insert (7, 6) required_715_i4 := by decide +kernel +theorem child_required_sub_715_i4 : ∀ j, childrenC_715_i4 j ⊆ insert (7, 6) required_715_i4 := by decide +kernel +theorem child_envelope_sub_715_i4 : ∀ j, childrenD_715_i4 j ⊆ envelope_715_i4 := by decide +kernel +theorem pivot_mem_715_i4 : (7, 6) ∈ envelope_715_i4 := by decide +kernel +theorem children_work_715_i4 : ∀ j, Template HasSnaky 7 (childrenC_715_i4 j) (childrenD_715_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_30 3 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_110 0 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_296 1 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_511 0 (4, 3)).mono (by decide +kernel) +theorem row_works_715_i4 : Template HasSnaky 8 required_715_i4 envelope_715_i4 := by + refine compose HasSnaky 7 childrenC_715_i4 childrenD_715_i4 children_work_715_i4 (7, 6) + required_715_i4 envelope_715_i4 pivot_mem_715_i4 child_required_sub_715_i4 child_envelope_sub_715_i4 ?_ + intro b hb + exact common_sub_715_i4 (mem_commonEnvelope childrenD_715_i4 b hb) +def required_715_i3 : Finset Cell := ⟨(([(4, 5), (4, 6), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_715_i3 : Finset Cell := ⟨(([(3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_715_i3 : Fin 4 → Finset Cell := ![(placed21 1 (3, 5) required_22), (placed21 1 (4, 5) required_74), (placed21 0 (3, 1) required_325), required_715_i4] +def childrenD_715_i3 : Fin 4 → Finset Cell := ![(placed21 1 (3, 5) envelope_22), (placed21 1 (4, 5) envelope_74), (placed21 0 (3, 1) envelope_325), envelope_715_i4] +theorem common_sub_715_i3 : commonEnvelope childrenD_715_i3 ⊆ insert (7, 5) required_715_i3 := by decide +kernel +theorem child_required_sub_715_i3 : ∀ j, childrenC_715_i3 j ⊆ insert (7, 5) required_715_i3 := by decide +kernel +theorem child_envelope_sub_715_i3 : ∀ j, childrenD_715_i3 j ⊆ envelope_715_i3 := by decide +kernel +theorem pivot_mem_715_i3 : (7, 5) ∈ envelope_715_i3 := by decide +kernel +theorem children_work_715_i3 : ∀ j, Template HasSnaky 9 (childrenC_715_i3 j) (childrenD_715_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 1 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_74 1 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_325 0 (3, 1)).mono (by decide +kernel) + · exact row_works_715_i4.mono (by decide +kernel) +theorem row_works_715_i3 : Template HasSnaky 10 required_715_i3 envelope_715_i3 := by + refine compose HasSnaky 9 childrenC_715_i3 childrenD_715_i3 children_work_715_i3 (7, 5) + required_715_i3 envelope_715_i3 pivot_mem_715_i3 child_required_sub_715_i3 child_envelope_sub_715_i3 ?_ + intro b hb + exact common_sub_715_i3 (mem_commonEnvelope childrenD_715_i3 b hb) +def required_715_i2 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_715_i2 : Finset Cell := ⟨(([(0, 7), (1, 6), (1, 7), (2, 6), (2, 7), (2, 8), (3, 6), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 7), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_715_i2 : Fin 5 → Finset Cell := ![(placed21 2 (7, 3) required_361), (placed21 5 (8, 5) required_408), (placed21 7 (8, 9) required_621), (placed21 1 (0, 3) required_714), required_715_i3] +def childrenD_715_i2 : Fin 5 → Finset Cell := ![(placed21 2 (7, 3) envelope_361), (placed21 5 (8, 5) envelope_408), (placed21 7 (8, 9) envelope_621), (placed21 1 (0, 3) envelope_714), envelope_715_i3] +theorem common_sub_715_i2 : commonEnvelope childrenD_715_i2 ⊆ insert (4, 6) required_715_i2 := by decide +kernel +theorem child_required_sub_715_i2 : ∀ j, childrenC_715_i2 j ⊆ insert (4, 6) required_715_i2 := by decide +kernel +theorem child_envelope_sub_715_i2 : ∀ j, childrenD_715_i2 j ⊆ envelope_715_i2 := by decide +kernel +theorem pivot_mem_715_i2 : (4, 6) ∈ envelope_715_i2 := by decide +kernel +theorem children_work_715_i2 : ∀ j, Template HasSnaky 10 (childrenC_715_i2 j) (childrenD_715_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_361 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_408 5 (8, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_621 7 (8, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_714 1 (0, 3)).mono (by decide +kernel) + · exact row_works_715_i3.mono (by decide +kernel) +theorem row_works_715_i2 : Template HasSnaky 11 required_715_i2 envelope_715_i2 := by + refine compose HasSnaky 10 childrenC_715_i2 childrenD_715_i2 children_work_715_i2 (4, 6) + required_715_i2 envelope_715_i2 pivot_mem_715_i2 child_required_sub_715_i2 child_envelope_sub_715_i2 ?_ + intro b hb + exact common_sub_715_i2 (mem_commonEnvelope childrenD_715_i2 b hb) +def required_715 : Finset Cell := ⟨(([(4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_715 : Finset Cell := ⟨(([(0, 4), (0, 6), (0, 7), (0, 8), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_715 : Fin 8 → Finset Cell := ![(placed21 4 (2, 9) required_523), (placed21 1 (0, 3) required_532), (placed21 6 (8, 9) required_536), (placed21 6 (6, 10) required_545), (placed21 4 (2, 10) required_655), (placed21 1 (0, 1) required_664), required_715_i0, required_715_i2] +def childrenD_715 : Fin 8 → Finset Cell := ![(placed21 4 (2, 9) envelope_523), (placed21 1 (0, 3) envelope_532), (placed21 6 (8, 9) envelope_536), (placed21 6 (6, 10) envelope_545), (placed21 4 (2, 10) envelope_655), (placed21 1 (0, 1) envelope_664), envelope_715_i0, envelope_715_i2] +theorem common_sub_715 : commonEnvelope childrenD_715 ⊆ insert (5, 6) required_715 := by decide +kernel +theorem child_required_sub_715 : ∀ j, childrenC_715 j ⊆ insert (5, 6) required_715 := by decide +kernel +theorem child_envelope_sub_715 : ∀ j, childrenD_715 j ⊆ envelope_715 := by decide +kernel +theorem pivot_mem_715 : (5, 6) ∈ envelope_715 := by decide +kernel +theorem children_work_715 : ∀ j, Template HasSnaky 11 (childrenC_715 j) (childrenD_715 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_523 4 (2, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_532 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_536 6 (8, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_545 6 (6, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_655 4 (2, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_664 1 (0, 1)).mono (by decide +kernel) + · exact row_works_715_i0.mono (by decide +kernel) + · exact row_works_715_i2.mono (by decide +kernel) +theorem row_works_715 : Template HasSnaky 12 required_715 envelope_715 := by + refine compose HasSnaky 11 childrenC_715 childrenD_715 children_work_715 (5, 6) + required_715 envelope_715 pivot_mem_715 child_required_sub_715 child_envelope_sub_715 ?_ + intro b hb + exact common_sub_715 (mem_commonEnvelope childrenD_715 b hb) +def required_717 : Finset Cell := ⟨(([(4, 6), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_717 : Finset Cell := ⟨(([(0, 3), (0, 5), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 9), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 2), (7, 3), (7, 4), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 3), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 5), (10, 7), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_717 : Fin 10 → Finset Cell := ![(placed21 1 (2, 5) required_192), (placed21 7 (8, 7) required_192), (placed21 2 (10, 1) required_550), (placed21 4 (0, 11) required_550), (placed21 0 (3, 3) required_578), (placed21 6 (7, 9) required_578), (placed21 1 (1, 3) required_622), (placed21 7 (9, 9) required_622), (placed21 0 (0, 1) required_716), (placed21 6 (10, 11) required_716)] +def childrenD_717 : Fin 10 → Finset Cell := ![(placed21 1 (2, 5) envelope_192), (placed21 7 (8, 7) envelope_192), (placed21 2 (10, 1) envelope_550), (placed21 4 (0, 11) envelope_550), (placed21 0 (3, 3) envelope_578), (placed21 6 (7, 9) envelope_578), (placed21 1 (1, 3) envelope_622), (placed21 7 (9, 9) envelope_622), (placed21 0 (0, 1) envelope_716), (placed21 6 (10, 11) envelope_716)] +theorem common_sub_717 : commonEnvelope childrenD_717 ⊆ insert (6, 6) required_717 := by decide +kernel +theorem child_required_sub_717 : ∀ j, childrenC_717 j ⊆ insert (6, 6) required_717 := by decide +kernel +theorem child_envelope_sub_717 : ∀ j, childrenD_717 j ⊆ envelope_717 := by decide +kernel +theorem pivot_mem_717 : (6, 6) ∈ envelope_717 := by decide +kernel +theorem children_work_717 : ∀ j, Template HasSnaky 11 (childrenC_717 j) (childrenD_717 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_192 1 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_192 7 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_550 2 (10, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_550 4 (0, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_578 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_578 6 (7, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_622 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_622 7 (9, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_716 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_716 6 (10, 11)).mono (by decide +kernel) +theorem row_works_717 : Template HasSnaky 12 required_717 envelope_717 := by + refine compose HasSnaky 11 childrenC_717 childrenD_717 children_work_717 (6, 6) + required_717 envelope_717 pivot_mem_717 child_required_sub_717 child_envelope_sub_717 ?_ + intro b hb + exact common_sub_717 (mem_commonEnvelope childrenD_717 b hb) +def required_723_i0 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_723_i0 : Finset Cell := ⟨(([(1, 4), (1, 6), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_723_i0 : Fin 2 → Finset Cell := ![(placed21 6 (5, 7) required_46), (placed21 0 (2, 1) required_321)] +def childrenD_723_i0 : Fin 2 → Finset Cell := ![(placed21 6 (5, 7) envelope_46), (placed21 0 (2, 1) envelope_321)] +theorem common_sub_723_i0 : commonEnvelope childrenD_723_i0 ⊆ insert (4, 5) required_723_i0 := by decide +kernel +theorem child_required_sub_723_i0 : ∀ j, childrenC_723_i0 j ⊆ insert (4, 5) required_723_i0 := by decide +kernel +theorem child_envelope_sub_723_i0 : ∀ j, childrenD_723_i0 j ⊆ envelope_723_i0 := by decide +kernel +theorem pivot_mem_723_i0 : (4, 5) ∈ envelope_723_i0 := by decide +kernel +theorem children_work_723_i0 : ∀ j, Template HasSnaky 8 (childrenC_723_i0 j) (childrenD_723_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_46 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_321 0 (2, 1)).mono (by decide +kernel) +theorem row_works_723_i0 : Template HasSnaky 9 required_723_i0 envelope_723_i0 := by + refine compose HasSnaky 8 childrenC_723_i0 childrenD_723_i0 children_work_723_i0 (4, 5) + required_723_i0 envelope_723_i0 pivot_mem_723_i0 child_required_sub_723_i0 child_envelope_sub_723_i0 ?_ + intro b hb + exact common_sub_723_i0 (mem_commonEnvelope childrenD_723_i0 b hb) +def required_723_i1 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_723_i1 : Finset Cell := ⟨(([(1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_723_i1 : Fin 3 → Finset Cell := ![(placed21 6 (3, 8) required_53), (placed21 0 (2, 2) required_53), (placed21 1 (1, 4) required_310)] +def childrenD_723_i1 : Fin 3 → Finset Cell := ![(placed21 6 (3, 8) envelope_53), (placed21 0 (2, 2) envelope_53), (placed21 1 (1, 4) envelope_310)] +theorem common_sub_723_i1 : commonEnvelope childrenD_723_i1 ⊆ insert (2, 4) required_723_i1 := by decide +kernel +theorem child_required_sub_723_i1 : ∀ j, childrenC_723_i1 j ⊆ insert (2, 4) required_723_i1 := by decide +kernel +theorem child_envelope_sub_723_i1 : ∀ j, childrenD_723_i1 j ⊆ envelope_723_i1 := by decide +kernel +theorem pivot_mem_723_i1 : (2, 4) ∈ envelope_723_i1 := by decide +kernel +theorem children_work_723_i1 : ∀ j, Template HasSnaky 3 (childrenC_723_i1 j) (childrenD_723_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 6 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_53 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_310 1 (1, 4)).mono (by decide +kernel) +theorem row_works_723_i1 : Template HasSnaky 4 required_723_i1 envelope_723_i1 := by + refine compose HasSnaky 3 childrenC_723_i1 childrenD_723_i1 children_work_723_i1 (2, 4) + required_723_i1 envelope_723_i1 pivot_mem_723_i1 child_required_sub_723_i1 child_envelope_sub_723_i1 ?_ + intro b hb + exact common_sub_723_i1 (mem_commonEnvelope childrenD_723_i1 b hb) +def required_723_i4 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (3, 7), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_723_i4 : Finset Cell := ⟨(([(0, 6), (1, 6), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 6), (4, 7), (4, 8), (5, 7), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_723_i4 : Fin 3 → Finset Cell := ![(placed21 6 (4, 8) required_9), (placed21 3 (2, 7) required_90), (placed21 5 (6, 4) required_99)] +def childrenD_723_i4 : Fin 3 → Finset Cell := ![(placed21 6 (4, 8) envelope_9), (placed21 3 (2, 7) envelope_90), (placed21 5 (6, 4) envelope_99)] +theorem common_sub_723_i4 : commonEnvelope childrenD_723_i4 ⊆ insert (3, 4) required_723_i4 := by decide +kernel +theorem child_required_sub_723_i4 : ∀ j, childrenC_723_i4 j ⊆ insert (3, 4) required_723_i4 := by decide +kernel +theorem child_envelope_sub_723_i4 : ∀ j, childrenD_723_i4 j ⊆ envelope_723_i4 := by decide +kernel +theorem pivot_mem_723_i4 : (3, 4) ∈ envelope_723_i4 := by decide +kernel +theorem children_work_723_i4 : ∀ j, Template HasSnaky 4 (childrenC_723_i4 j) (childrenD_723_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 6 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_90 3 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_99 5 (6, 4)).mono (by decide +kernel) +theorem row_works_723_i4 : Template HasSnaky 5 required_723_i4 envelope_723_i4 := by + refine compose HasSnaky 4 childrenC_723_i4 childrenD_723_i4 children_work_723_i4 (3, 4) + required_723_i4 envelope_723_i4 pivot_mem_723_i4 child_required_sub_723_i4 child_envelope_sub_723_i4 ?_ + intro b hb + exact common_sub_723_i4 (mem_commonEnvelope childrenD_723_i4 b hb) +def required_723_i3 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_723_i3 : Finset Cell := ⟨(([(0, 6), (0, 8), (1, 6), (1, 8), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 8), (2, 9), (2, 10), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 7), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_723_i3 : Fin 4 → Finset Cell := ![(placed21 6 (3, 8) required_44), (placed21 6 (3, 8) required_52), (placed21 5 (5, 4) required_180), required_723_i4] +def childrenD_723_i3 : Fin 4 → Finset Cell := ![(placed21 6 (3, 8) envelope_44), (placed21 6 (3, 8) envelope_52), (placed21 5 (5, 4) envelope_180), envelope_723_i4] +theorem common_sub_723_i3 : commonEnvelope childrenD_723_i3 ⊆ insert (3, 7) required_723_i3 := by decide +kernel +theorem child_required_sub_723_i3 : ∀ j, childrenC_723_i3 j ⊆ insert (3, 7) required_723_i3 := by decide +kernel +theorem child_envelope_sub_723_i3 : ∀ j, childrenD_723_i3 j ⊆ envelope_723_i3 := by decide +kernel +theorem pivot_mem_723_i3 : (3, 7) ∈ envelope_723_i3 := by decide +kernel +theorem children_work_723_i3 : ∀ j, Template HasSnaky 6 (childrenC_723_i3 j) (childrenD_723_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_180 5 (5, 4)).mono (by decide +kernel) + · exact row_works_723_i4.mono (by decide +kernel) +theorem row_works_723_i3 : Template HasSnaky 7 required_723_i3 envelope_723_i3 := by + refine compose HasSnaky 6 childrenC_723_i3 childrenD_723_i3 children_work_723_i3 (3, 7) + required_723_i3 envelope_723_i3 pivot_mem_723_i3 child_required_sub_723_i3 child_envelope_sub_723_i3 ?_ + intro b hb + exact common_sub_723_i3 (mem_commonEnvelope childrenD_723_i3 b hb) +def required_723_i5 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (5, 5), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_723_i5 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 7), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_723_i5 : Fin 4 → Finset Cell := ![(placed21 0 (2, 4) required_82), (placed21 4 (2, 8) required_176), (placed21 1 (2, 5) required_218), (placed21 6 (6, 10) required_369)] +def childrenD_723_i5 : Fin 4 → Finset Cell := ![(placed21 0 (2, 4) envelope_82), (placed21 4 (2, 8) envelope_176), (placed21 1 (2, 5) envelope_218), (placed21 6 (6, 10) envelope_369)] +theorem common_sub_723_i5 : commonEnvelope childrenD_723_i5 ⊆ insert (5, 6) required_723_i5 := by decide +kernel +theorem child_required_sub_723_i5 : ∀ j, childrenC_723_i5 j ⊆ insert (5, 6) required_723_i5 := by decide +kernel +theorem child_envelope_sub_723_i5 : ∀ j, childrenD_723_i5 j ⊆ envelope_723_i5 := by decide +kernel +theorem pivot_mem_723_i5 : (5, 6) ∈ envelope_723_i5 := by decide +kernel +theorem children_work_723_i5 : ∀ j, Template HasSnaky 6 (childrenC_723_i5 j) (childrenD_723_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_82 0 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_176 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_218 1 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_369 6 (6, 10)).mono (by decide +kernel) +theorem row_works_723_i5 : Template HasSnaky 7 required_723_i5 envelope_723_i5 := by + refine compose HasSnaky 6 childrenC_723_i5 childrenD_723_i5 children_work_723_i5 (5, 6) + required_723_i5 envelope_723_i5 pivot_mem_723_i5 child_required_sub_723_i5 child_envelope_sub_723_i5 ?_ + intro b hb + exact common_sub_723_i5 (mem_commonEnvelope childrenD_723_i5 b hb) +def required_723_i7 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (3, 7), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_723_i7 : Finset Cell := ⟨(([(2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 7), (4, 8), (5, 7), (6, 6), (6, 7), (6, 8), (7, 6), (7, 7), (7, 8), (8, 6), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_723_i7 : Fin 2 → Finset Cell := ![(placed21 1 (2, 4) required_145), (placed21 3 (2, 7) required_314)] +def childrenD_723_i7 : Fin 2 → Finset Cell := ![(placed21 1 (2, 4) envelope_145), (placed21 3 (2, 7) envelope_314)] +theorem common_sub_723_i7 : commonEnvelope childrenD_723_i7 ⊆ insert (3, 4) required_723_i7 := by decide +kernel +theorem child_required_sub_723_i7 : ∀ j, childrenC_723_i7 j ⊆ insert (3, 4) required_723_i7 := by decide +kernel +theorem child_envelope_sub_723_i7 : ∀ j, childrenD_723_i7 j ⊆ envelope_723_i7 := by decide +kernel +theorem pivot_mem_723_i7 : (3, 4) ∈ envelope_723_i7 := by decide +kernel +theorem children_work_723_i7 : ∀ j, Template HasSnaky 5 (childrenC_723_i7 j) (childrenD_723_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_145 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_314 3 (2, 7)).mono (by decide +kernel) +theorem row_works_723_i7 : Template HasSnaky 6 required_723_i7 envelope_723_i7 := by + refine compose HasSnaky 5 childrenC_723_i7 childrenD_723_i7 children_work_723_i7 (3, 4) + required_723_i7 envelope_723_i7 pivot_mem_723_i7 child_required_sub_723_i7 child_envelope_sub_723_i7 ?_ + intro b hb + exact common_sub_723_i7 (mem_commonEnvelope childrenD_723_i7 b hb) +def required_723_i6 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_723_i6 : Finset Cell := ⟨(([(0, 8), (1, 8), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 7), (4, 8), (4, 9), (4, 10), (5, 7), (6, 6), (6, 7), (6, 8), (7, 6), (7, 7), (7, 8), (8, 6), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_723_i6 : Fin 4 → Finset Cell := ![(placed21 6 (3, 8) required_44), (placed21 6 (3, 8) required_52), (placed21 5 (5, 4) required_180), required_723_i7] +def childrenD_723_i6 : Fin 4 → Finset Cell := ![(placed21 6 (3, 8) envelope_44), (placed21 6 (3, 8) envelope_52), (placed21 5 (5, 4) envelope_180), envelope_723_i7] +theorem common_sub_723_i6 : commonEnvelope childrenD_723_i6 ⊆ insert (3, 7) required_723_i6 := by decide +kernel +theorem child_required_sub_723_i6 : ∀ j, childrenC_723_i6 j ⊆ insert (3, 7) required_723_i6 := by decide +kernel +theorem child_envelope_sub_723_i6 : ∀ j, childrenD_723_i6 j ⊆ envelope_723_i6 := by decide +kernel +theorem pivot_mem_723_i6 : (3, 7) ∈ envelope_723_i6 := by decide +kernel +theorem children_work_723_i6 : ∀ j, Template HasSnaky 6 (childrenC_723_i6 j) (childrenD_723_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_180 5 (5, 4)).mono (by decide +kernel) + · exact row_works_723_i7.mono (by decide +kernel) +theorem row_works_723_i6 : Template HasSnaky 7 required_723_i6 envelope_723_i6 := by + refine compose HasSnaky 6 childrenC_723_i6 childrenD_723_i6 children_work_723_i6 (3, 7) + required_723_i6 envelope_723_i6 pivot_mem_723_i6 child_required_sub_723_i6 child_envelope_sub_723_i6 ?_ + intro b hb + exact common_sub_723_i6 (mem_commonEnvelope childrenD_723_i6 b hb) +def required_723_i8 : Finset Cell := ⟨(([(5, 5), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_723_i8 : Finset Cell := ⟨(([(2, 8), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6), (8, 7), (8, 8), (8, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_723_i8 : Fin 6 → Finset Cell := ![(placed21 2 (6, 3) required_13), (placed21 4 (4, 9) required_192), (placed21 6 (6, 10) required_369), (placed21 1 (2, 4) required_435), (placed21 1 (3, 4) required_474), (placed21 3 (3, 8) required_477)] +def childrenD_723_i8 : Fin 6 → Finset Cell := ![(placed21 2 (6, 3) envelope_13), (placed21 4 (4, 9) envelope_192), (placed21 6 (6, 10) envelope_369), (placed21 1 (2, 4) envelope_435), (placed21 1 (3, 4) envelope_474), (placed21 3 (3, 8) envelope_477)] +theorem common_sub_723_i8 : commonEnvelope childrenD_723_i8 ⊆ insert (5, 6) required_723_i8 := by decide +kernel +theorem child_required_sub_723_i8 : ∀ j, childrenC_723_i8 j ⊆ insert (5, 6) required_723_i8 := by decide +kernel +theorem child_envelope_sub_723_i8 : ∀ j, childrenD_723_i8 j ⊆ envelope_723_i8 := by decide +kernel +theorem pivot_mem_723_i8 : (5, 6) ∈ envelope_723_i8 := by decide +kernel +theorem children_work_723_i8 : ∀ j, Template HasSnaky 9 (childrenC_723_i8 j) (childrenD_723_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_192 4 (4, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_369 6 (6, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_435 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_474 1 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_477 3 (3, 8)).mono (by decide +kernel) +theorem row_works_723_i8 : Template HasSnaky 10 required_723_i8 envelope_723_i8 := by + refine compose HasSnaky 9 childrenC_723_i8 childrenD_723_i8 children_work_723_i8 (5, 6) + required_723_i8 envelope_723_i8 pivot_mem_723_i8 child_required_sub_723_i8 child_envelope_sub_723_i8 ?_ + intro b hb + exact common_sub_723_i8 (mem_commonEnvelope childrenD_723_i8 b hb) +def required_723_i2 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_723_i2 : Finset Cell := ⟨(([(0, 6), (0, 7), (0, 8), (0, 9), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6), (8, 7), (8, 8), (8, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_723_i2 : Fin 6 → Finset Cell := ![required_723_i3, required_723_i5, required_723_i6, required_723_i8, (placed21 0 (0, 2) required_721), (placed21 0 (1, 2) required_722)] +def childrenD_723_i2 : Fin 6 → Finset Cell := ![envelope_723_i3, envelope_723_i5, envelope_723_i6, envelope_723_i8, (placed21 0 (0, 2) envelope_721), (placed21 0 (1, 2) envelope_722)] +theorem common_sub_723_i2 : commonEnvelope childrenD_723_i2 ⊆ insert (5, 7) required_723_i2 := by decide +kernel +theorem child_required_sub_723_i2 : ∀ j, childrenC_723_i2 j ⊆ insert (5, 7) required_723_i2 := by decide +kernel +theorem child_envelope_sub_723_i2 : ∀ j, childrenD_723_i2 j ⊆ envelope_723_i2 := by decide +kernel +theorem pivot_mem_723_i2 : (5, 7) ∈ envelope_723_i2 := by decide +kernel +theorem children_work_723_i2 : ∀ j, Template HasSnaky 10 (childrenC_723_i2 j) (childrenD_723_i2 j) := by + intro j + fin_cases j + · exact row_works_723_i3.mono (by decide +kernel) + · exact row_works_723_i5.mono (by decide +kernel) + · exact row_works_723_i6.mono (by decide +kernel) + · exact row_works_723_i8.mono (by decide +kernel) + · exact (placed21_template row_works_721 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_722 0 (1, 2)).mono (by decide +kernel) +theorem row_works_723_i2 : Template HasSnaky 11 required_723_i2 envelope_723_i2 := by + refine compose HasSnaky 10 childrenC_723_i2 childrenD_723_i2 children_work_723_i2 (5, 7) + required_723_i2 envelope_723_i2 pivot_mem_723_i2 child_required_sub_723_i2 child_envelope_sub_723_i2 ?_ + intro b hb + exact common_sub_723_i2 (mem_commonEnvelope childrenD_723_i2 b hb) +def required_723 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_723 : Finset Cell := ⟨(([(0, 6), (0, 7), (0, 8), (0, 9), (1, 4), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6), (8, 7), (8, 8), (8, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_723 : Fin 5 → Finset Cell := ![(placed21 0 (1, 1) required_328), (placed21 0 (1, 1) required_330), required_723_i0, required_723_i1, required_723_i2] +def childrenD_723 : Fin 5 → Finset Cell := ![(placed21 0 (1, 1) envelope_328), (placed21 0 (1, 1) envelope_330), envelope_723_i0, envelope_723_i1, envelope_723_i2] +theorem common_sub_723 : commonEnvelope childrenD_723 ⊆ insert (5, 5) required_723 := by decide +kernel +theorem child_required_sub_723 : ∀ j, childrenC_723 j ⊆ insert (5, 5) required_723 := by decide +kernel +theorem child_envelope_sub_723 : ∀ j, childrenD_723 j ⊆ envelope_723 := by decide +kernel +theorem pivot_mem_723 : (5, 5) ∈ envelope_723 := by decide +kernel +theorem children_work_723 : ∀ j, Template HasSnaky 11 (childrenC_723 j) (childrenD_723 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_328 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_330 0 (1, 1)).mono (by decide +kernel) + · exact row_works_723_i0.mono (by decide +kernel) + · exact row_works_723_i1.mono (by decide +kernel) + · exact row_works_723_i2.mono (by decide +kernel) +theorem row_works_723 : Template HasSnaky 12 required_723 envelope_723 := by + refine compose HasSnaky 11 childrenC_723 childrenD_723 children_work_723 (5, 5) + required_723 envelope_723 pivot_mem_723 child_required_sub_723 child_envelope_sub_723 ?_ + intro b hb + exact common_sub_723 (mem_commonEnvelope childrenD_723 b hb) +def height_715_i1 : ℕ := 8 +def childrenH_715_i1 : Fin 4 → ℕ := ![height_53, height_53, height_111, height_394] +theorem height_exact_715_i1 : height_715_i1 = 1 + Finset.univ.sup childrenH_715_i1 := by decide +kernel +theorem required_origin_715_i1 : ∀ x ∈ required_715_i1, + (∃ j, x ∈ childrenC_715_i1 j) ∨ ∀ j, x ∈ childrenD_715_i1 j := by decide +kernel +theorem required_exact_715_i1 : required_715_i1 = + ((Finset.univ.biUnion childrenC_715_i1) ∪ commonEnvelope childrenD_715_i1).erase (4, 4) := by + exact required_eq_combination childrenC_715_i1 childrenD_715_i1 (4, 4) required_715_i1 + (by decide +kernel) child_required_sub_715_i1 common_sub_715_i1 required_origin_715_i1 +theorem envelope_origin_715_i1 : ∀ x ∈ envelope_715_i1, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_715_i1 j := by decide +kernel +theorem envelope_exact_715_i1 : envelope_715_i1 = + insert (4, 4) (Finset.univ.biUnion childrenD_715_i1) := by + exact envelope_eq_combination childrenD_715_i1 (4, 4) envelope_715_i1 + pivot_mem_715_i1 child_envelope_sub_715_i1 envelope_origin_715_i1 +def checked_715_i1 : CheckedCard where + required := required_715_i1 + envelope := envelope_715_i1 + height := height_715_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_715_i1 +def height_715_i0 : ℕ := 9 +def childrenH_715_i0 : Fin 4 → ℕ := ![height_44, height_52, height_134, height_715_i1] +theorem height_exact_715_i0 : height_715_i0 = 1 + Finset.univ.sup childrenH_715_i0 := by decide +kernel +theorem required_origin_715_i0 : ∀ x ∈ required_715_i0, + (∃ j, x ∈ childrenC_715_i0 j) ∨ ∀ j, x ∈ childrenD_715_i0 j := by decide +kernel +theorem required_exact_715_i0 : required_715_i0 = + ((Finset.univ.biUnion childrenC_715_i0) ∪ commonEnvelope childrenD_715_i0).erase (3, 5) := by + exact required_eq_combination childrenC_715_i0 childrenD_715_i0 (3, 5) required_715_i0 + (by decide +kernel) child_required_sub_715_i0 common_sub_715_i0 required_origin_715_i0 +theorem envelope_origin_715_i0 : ∀ x ∈ envelope_715_i0, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_715_i0 j := by decide +kernel +theorem envelope_exact_715_i0 : envelope_715_i0 = + insert (3, 5) (Finset.univ.biUnion childrenD_715_i0) := by + exact envelope_eq_combination childrenD_715_i0 (3, 5) envelope_715_i0 + pivot_mem_715_i0 child_envelope_sub_715_i0 envelope_origin_715_i0 +def checked_715_i0 : CheckedCard where + required := required_715_i0 + envelope := envelope_715_i0 + height := height_715_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_715_i0 +def height_715_i4 : ℕ := 8 +def childrenH_715_i4 : Fin 4 → ℕ := ![height_30, height_110, height_296, height_511] +theorem height_exact_715_i4 : height_715_i4 = 1 + Finset.univ.sup childrenH_715_i4 := by decide +kernel +theorem required_origin_715_i4 : ∀ x ∈ required_715_i4, + (∃ j, x ∈ childrenC_715_i4 j) ∨ ∀ j, x ∈ childrenD_715_i4 j := by decide +kernel +theorem required_exact_715_i4 : required_715_i4 = + ((Finset.univ.biUnion childrenC_715_i4) ∪ commonEnvelope childrenD_715_i4).erase (7, 6) := by + exact required_eq_combination childrenC_715_i4 childrenD_715_i4 (7, 6) required_715_i4 + (by decide +kernel) child_required_sub_715_i4 common_sub_715_i4 required_origin_715_i4 +theorem envelope_origin_715_i4 : ∀ x ∈ envelope_715_i4, + x = (7, 6) ∨ ∃ j, x ∈ childrenD_715_i4 j := by decide +kernel +theorem envelope_exact_715_i4 : envelope_715_i4 = + insert (7, 6) (Finset.univ.biUnion childrenD_715_i4) := by + exact envelope_eq_combination childrenD_715_i4 (7, 6) envelope_715_i4 + pivot_mem_715_i4 child_envelope_sub_715_i4 envelope_origin_715_i4 +def checked_715_i4 : CheckedCard where + required := required_715_i4 + envelope := envelope_715_i4 + height := height_715_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_715_i4 +def height_715_i3 : ℕ := 10 +def childrenH_715_i3 : Fin 4 → ℕ := ![height_22, height_74, height_325, height_715_i4] +theorem height_exact_715_i3 : height_715_i3 = 1 + Finset.univ.sup childrenH_715_i3 := by decide +kernel +theorem required_origin_715_i3 : ∀ x ∈ required_715_i3, + (∃ j, x ∈ childrenC_715_i3 j) ∨ ∀ j, x ∈ childrenD_715_i3 j := by decide +kernel +theorem required_exact_715_i3 : required_715_i3 = + ((Finset.univ.biUnion childrenC_715_i3) ∪ commonEnvelope childrenD_715_i3).erase (7, 5) := by + exact required_eq_combination childrenC_715_i3 childrenD_715_i3 (7, 5) required_715_i3 + (by decide +kernel) child_required_sub_715_i3 common_sub_715_i3 required_origin_715_i3 +theorem envelope_origin_715_i3 : ∀ x ∈ envelope_715_i3, + x = (7, 5) ∨ ∃ j, x ∈ childrenD_715_i3 j := by decide +kernel +theorem envelope_exact_715_i3 : envelope_715_i3 = + insert (7, 5) (Finset.univ.biUnion childrenD_715_i3) := by + exact envelope_eq_combination childrenD_715_i3 (7, 5) envelope_715_i3 + pivot_mem_715_i3 child_envelope_sub_715_i3 envelope_origin_715_i3 +def checked_715_i3 : CheckedCard where + required := required_715_i3 + envelope := envelope_715_i3 + height := height_715_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_715_i3 +def height_715_i2 : ℕ := 11 +def childrenH_715_i2 : Fin 5 → ℕ := ![height_361, height_408, height_621, height_714, height_715_i3] +theorem height_exact_715_i2 : height_715_i2 = 1 + Finset.univ.sup childrenH_715_i2 := by decide +kernel +theorem required_origin_715_i2 : ∀ x ∈ required_715_i2, + (∃ j, x ∈ childrenC_715_i2 j) ∨ ∀ j, x ∈ childrenD_715_i2 j := by decide +kernel +theorem required_exact_715_i2 : required_715_i2 = + ((Finset.univ.biUnion childrenC_715_i2) ∪ commonEnvelope childrenD_715_i2).erase (4, 6) := by + exact required_eq_combination childrenC_715_i2 childrenD_715_i2 (4, 6) required_715_i2 + (by decide +kernel) child_required_sub_715_i2 common_sub_715_i2 required_origin_715_i2 +theorem envelope_origin_715_i2 : ∀ x ∈ envelope_715_i2, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_715_i2 j := by decide +kernel +theorem envelope_exact_715_i2 : envelope_715_i2 = + insert (4, 6) (Finset.univ.biUnion childrenD_715_i2) := by + exact envelope_eq_combination childrenD_715_i2 (4, 6) envelope_715_i2 + pivot_mem_715_i2 child_envelope_sub_715_i2 envelope_origin_715_i2 +def checked_715_i2 : CheckedCard where + required := required_715_i2 + envelope := envelope_715_i2 + height := height_715_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_715_i2 +def height_715 : ℕ := 12 +def childrenH_715 : Fin 8 → ℕ := ![height_523, height_532, height_536, height_545, height_655, height_664, height_715_i0, height_715_i2] +theorem height_exact_715 : height_715 = 1 + Finset.univ.sup childrenH_715 := by decide +kernel +theorem required_origin_715 : ∀ x ∈ required_715, + (∃ j, x ∈ childrenC_715 j) ∨ ∀ j, x ∈ childrenD_715 j := by decide +kernel +theorem required_exact_715 : required_715 = + ((Finset.univ.biUnion childrenC_715) ∪ commonEnvelope childrenD_715).erase (5, 6) := by + exact required_eq_combination childrenC_715 childrenD_715 (5, 6) required_715 + (by decide +kernel) child_required_sub_715 common_sub_715 required_origin_715 +theorem envelope_origin_715 : ∀ x ∈ envelope_715, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_715 j := by decide +kernel +theorem envelope_exact_715 : envelope_715 = + insert (5, 6) (Finset.univ.biUnion childrenD_715) := by + exact envelope_eq_combination childrenD_715 (5, 6) envelope_715 + pivot_mem_715 child_envelope_sub_715 envelope_origin_715 +def checked_715 : CheckedCard where + required := required_715 + envelope := envelope_715 + height := height_715 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_715 +def height_717 : ℕ := 12 +def childrenH_717 : Fin 10 → ℕ := ![height_192, height_192, height_550, height_550, height_578, height_578, height_622, height_622, height_716, height_716] +theorem height_exact_717 : height_717 = 1 + Finset.univ.sup childrenH_717 := by decide +kernel +theorem required_origin_717 : ∀ x ∈ required_717, + (∃ j, x ∈ childrenC_717 j) ∨ ∀ j, x ∈ childrenD_717 j := by decide +kernel +theorem required_exact_717 : required_717 = + ((Finset.univ.biUnion childrenC_717) ∪ commonEnvelope childrenD_717).erase (6, 6) := by + exact required_eq_combination childrenC_717 childrenD_717 (6, 6) required_717 + (by decide +kernel) child_required_sub_717 common_sub_717 required_origin_717 +theorem envelope_origin_717 : ∀ x ∈ envelope_717, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_717 j := by decide +kernel +theorem envelope_exact_717 : envelope_717 = + insert (6, 6) (Finset.univ.biUnion childrenD_717) := by + exact envelope_eq_combination childrenD_717 (6, 6) envelope_717 + pivot_mem_717 child_envelope_sub_717 envelope_origin_717 +def checked_717 : CheckedCard where + required := required_717 + envelope := envelope_717 + height := height_717 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_717 +def height_723_i0 : ℕ := 9 +def childrenH_723_i0 : Fin 2 → ℕ := ![height_46, height_321] +theorem height_exact_723_i0 : height_723_i0 = 1 + Finset.univ.sup childrenH_723_i0 := by decide +kernel +theorem required_origin_723_i0 : ∀ x ∈ required_723_i0, + (∃ j, x ∈ childrenC_723_i0 j) ∨ ∀ j, x ∈ childrenD_723_i0 j := by decide +kernel +theorem required_exact_723_i0 : required_723_i0 = + ((Finset.univ.biUnion childrenC_723_i0) ∪ commonEnvelope childrenD_723_i0).erase (4, 5) := by + exact required_eq_combination childrenC_723_i0 childrenD_723_i0 (4, 5) required_723_i0 + (by decide +kernel) child_required_sub_723_i0 common_sub_723_i0 required_origin_723_i0 +theorem envelope_origin_723_i0 : ∀ x ∈ envelope_723_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_723_i0 j := by decide +kernel +theorem envelope_exact_723_i0 : envelope_723_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_723_i0) := by + exact envelope_eq_combination childrenD_723_i0 (4, 5) envelope_723_i0 + pivot_mem_723_i0 child_envelope_sub_723_i0 envelope_origin_723_i0 +def checked_723_i0 : CheckedCard where + required := required_723_i0 + envelope := envelope_723_i0 + height := height_723_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_723_i0 +def height_723_i1 : ℕ := 4 +def childrenH_723_i1 : Fin 3 → ℕ := ![height_53, height_53, height_310] +theorem height_exact_723_i1 : height_723_i1 = 1 + Finset.univ.sup childrenH_723_i1 := by decide +kernel +theorem required_origin_723_i1 : ∀ x ∈ required_723_i1, + (∃ j, x ∈ childrenC_723_i1 j) ∨ ∀ j, x ∈ childrenD_723_i1 j := by decide +kernel +theorem required_exact_723_i1 : required_723_i1 = + ((Finset.univ.biUnion childrenC_723_i1) ∪ commonEnvelope childrenD_723_i1).erase (2, 4) := by + exact required_eq_combination childrenC_723_i1 childrenD_723_i1 (2, 4) required_723_i1 + (by decide +kernel) child_required_sub_723_i1 common_sub_723_i1 required_origin_723_i1 +theorem envelope_origin_723_i1 : ∀ x ∈ envelope_723_i1, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_723_i1 j := by decide +kernel +theorem envelope_exact_723_i1 : envelope_723_i1 = + insert (2, 4) (Finset.univ.biUnion childrenD_723_i1) := by + exact envelope_eq_combination childrenD_723_i1 (2, 4) envelope_723_i1 + pivot_mem_723_i1 child_envelope_sub_723_i1 envelope_origin_723_i1 +def checked_723_i1 : CheckedCard where + required := required_723_i1 + envelope := envelope_723_i1 + height := height_723_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_723_i1 +def height_723_i4 : ℕ := 5 +def childrenH_723_i4 : Fin 3 → ℕ := ![height_9, height_90, height_99] +theorem height_exact_723_i4 : height_723_i4 = 1 + Finset.univ.sup childrenH_723_i4 := by decide +kernel +theorem required_origin_723_i4 : ∀ x ∈ required_723_i4, + (∃ j, x ∈ childrenC_723_i4 j) ∨ ∀ j, x ∈ childrenD_723_i4 j := by decide +kernel +theorem required_exact_723_i4 : required_723_i4 = + ((Finset.univ.biUnion childrenC_723_i4) ∪ commonEnvelope childrenD_723_i4).erase (3, 4) := by + exact required_eq_combination childrenC_723_i4 childrenD_723_i4 (3, 4) required_723_i4 + (by decide +kernel) child_required_sub_723_i4 common_sub_723_i4 required_origin_723_i4 +theorem envelope_origin_723_i4 : ∀ x ∈ envelope_723_i4, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_723_i4 j := by decide +kernel +theorem envelope_exact_723_i4 : envelope_723_i4 = + insert (3, 4) (Finset.univ.biUnion childrenD_723_i4) := by + exact envelope_eq_combination childrenD_723_i4 (3, 4) envelope_723_i4 + pivot_mem_723_i4 child_envelope_sub_723_i4 envelope_origin_723_i4 +def checked_723_i4 : CheckedCard where + required := required_723_i4 + envelope := envelope_723_i4 + height := height_723_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_723_i4 +def height_723_i3 : ℕ := 7 +def childrenH_723_i3 : Fin 4 → ℕ := ![height_44, height_52, height_180, height_723_i4] +theorem height_exact_723_i3 : height_723_i3 = 1 + Finset.univ.sup childrenH_723_i3 := by decide +kernel +theorem required_origin_723_i3 : ∀ x ∈ required_723_i3, + (∃ j, x ∈ childrenC_723_i3 j) ∨ ∀ j, x ∈ childrenD_723_i3 j := by decide +kernel +theorem required_exact_723_i3 : required_723_i3 = + ((Finset.univ.biUnion childrenC_723_i3) ∪ commonEnvelope childrenD_723_i3).erase (3, 7) := by + exact required_eq_combination childrenC_723_i3 childrenD_723_i3 (3, 7) required_723_i3 + (by decide +kernel) child_required_sub_723_i3 common_sub_723_i3 required_origin_723_i3 +theorem envelope_origin_723_i3 : ∀ x ∈ envelope_723_i3, + x = (3, 7) ∨ ∃ j, x ∈ childrenD_723_i3 j := by decide +kernel +theorem envelope_exact_723_i3 : envelope_723_i3 = + insert (3, 7) (Finset.univ.biUnion childrenD_723_i3) := by + exact envelope_eq_combination childrenD_723_i3 (3, 7) envelope_723_i3 + pivot_mem_723_i3 child_envelope_sub_723_i3 envelope_origin_723_i3 +def checked_723_i3 : CheckedCard where + required := required_723_i3 + envelope := envelope_723_i3 + height := height_723_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_723_i3 +def height_723_i5 : ℕ := 7 +def childrenH_723_i5 : Fin 4 → ℕ := ![height_82, height_176, height_218, height_369] +theorem height_exact_723_i5 : height_723_i5 = 1 + Finset.univ.sup childrenH_723_i5 := by decide +kernel +theorem required_origin_723_i5 : ∀ x ∈ required_723_i5, + (∃ j, x ∈ childrenC_723_i5 j) ∨ ∀ j, x ∈ childrenD_723_i5 j := by decide +kernel +theorem required_exact_723_i5 : required_723_i5 = + ((Finset.univ.biUnion childrenC_723_i5) ∪ commonEnvelope childrenD_723_i5).erase (5, 6) := by + exact required_eq_combination childrenC_723_i5 childrenD_723_i5 (5, 6) required_723_i5 + (by decide +kernel) child_required_sub_723_i5 common_sub_723_i5 required_origin_723_i5 +theorem envelope_origin_723_i5 : ∀ x ∈ envelope_723_i5, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_723_i5 j := by decide +kernel +theorem envelope_exact_723_i5 : envelope_723_i5 = + insert (5, 6) (Finset.univ.biUnion childrenD_723_i5) := by + exact envelope_eq_combination childrenD_723_i5 (5, 6) envelope_723_i5 + pivot_mem_723_i5 child_envelope_sub_723_i5 envelope_origin_723_i5 +def checked_723_i5 : CheckedCard where + required := required_723_i5 + envelope := envelope_723_i5 + height := height_723_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_723_i5 +def height_723_i7 : ℕ := 6 +def childrenH_723_i7 : Fin 2 → ℕ := ![height_145, height_314] +theorem height_exact_723_i7 : height_723_i7 = 1 + Finset.univ.sup childrenH_723_i7 := by decide +kernel +theorem required_origin_723_i7 : ∀ x ∈ required_723_i7, + (∃ j, x ∈ childrenC_723_i7 j) ∨ ∀ j, x ∈ childrenD_723_i7 j := by decide +kernel +theorem required_exact_723_i7 : required_723_i7 = + ((Finset.univ.biUnion childrenC_723_i7) ∪ commonEnvelope childrenD_723_i7).erase (3, 4) := by + exact required_eq_combination childrenC_723_i7 childrenD_723_i7 (3, 4) required_723_i7 + (by decide +kernel) child_required_sub_723_i7 common_sub_723_i7 required_origin_723_i7 +theorem envelope_origin_723_i7 : ∀ x ∈ envelope_723_i7, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_723_i7 j := by decide +kernel +theorem envelope_exact_723_i7 : envelope_723_i7 = + insert (3, 4) (Finset.univ.biUnion childrenD_723_i7) := by + exact envelope_eq_combination childrenD_723_i7 (3, 4) envelope_723_i7 + pivot_mem_723_i7 child_envelope_sub_723_i7 envelope_origin_723_i7 +def checked_723_i7 : CheckedCard where + required := required_723_i7 + envelope := envelope_723_i7 + height := height_723_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_723_i7 +def height_723_i6 : ℕ := 7 +def childrenH_723_i6 : Fin 4 → ℕ := ![height_44, height_52, height_180, height_723_i7] +theorem height_exact_723_i6 : height_723_i6 = 1 + Finset.univ.sup childrenH_723_i6 := by decide +kernel +theorem required_origin_723_i6 : ∀ x ∈ required_723_i6, + (∃ j, x ∈ childrenC_723_i6 j) ∨ ∀ j, x ∈ childrenD_723_i6 j := by decide +kernel +theorem required_exact_723_i6 : required_723_i6 = + ((Finset.univ.biUnion childrenC_723_i6) ∪ commonEnvelope childrenD_723_i6).erase (3, 7) := by + exact required_eq_combination childrenC_723_i6 childrenD_723_i6 (3, 7) required_723_i6 + (by decide +kernel) child_required_sub_723_i6 common_sub_723_i6 required_origin_723_i6 +theorem envelope_origin_723_i6 : ∀ x ∈ envelope_723_i6, + x = (3, 7) ∨ ∃ j, x ∈ childrenD_723_i6 j := by decide +kernel +theorem envelope_exact_723_i6 : envelope_723_i6 = + insert (3, 7) (Finset.univ.biUnion childrenD_723_i6) := by + exact envelope_eq_combination childrenD_723_i6 (3, 7) envelope_723_i6 + pivot_mem_723_i6 child_envelope_sub_723_i6 envelope_origin_723_i6 +def checked_723_i6 : CheckedCard where + required := required_723_i6 + envelope := envelope_723_i6 + height := height_723_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_723_i6 +def height_723_i8 : ℕ := 10 +def childrenH_723_i8 : Fin 6 → ℕ := ![height_13, height_192, height_369, height_435, height_474, height_477] +theorem height_exact_723_i8 : height_723_i8 = 1 + Finset.univ.sup childrenH_723_i8 := by decide +kernel +theorem required_origin_723_i8 : ∀ x ∈ required_723_i8, + (∃ j, x ∈ childrenC_723_i8 j) ∨ ∀ j, x ∈ childrenD_723_i8 j := by decide +kernel +theorem required_exact_723_i8 : required_723_i8 = + ((Finset.univ.biUnion childrenC_723_i8) ∪ commonEnvelope childrenD_723_i8).erase (5, 6) := by + exact required_eq_combination childrenC_723_i8 childrenD_723_i8 (5, 6) required_723_i8 + (by decide +kernel) child_required_sub_723_i8 common_sub_723_i8 required_origin_723_i8 +theorem envelope_origin_723_i8 : ∀ x ∈ envelope_723_i8, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_723_i8 j := by decide +kernel +theorem envelope_exact_723_i8 : envelope_723_i8 = + insert (5, 6) (Finset.univ.biUnion childrenD_723_i8) := by + exact envelope_eq_combination childrenD_723_i8 (5, 6) envelope_723_i8 + pivot_mem_723_i8 child_envelope_sub_723_i8 envelope_origin_723_i8 +def checked_723_i8 : CheckedCard where + required := required_723_i8 + envelope := envelope_723_i8 + height := height_723_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_723_i8 +def height_723_i2 : ℕ := 11 +def childrenH_723_i2 : Fin 6 → ℕ := ![height_723_i3, height_723_i5, height_723_i6, height_723_i8, height_721, height_722] +theorem height_exact_723_i2 : height_723_i2 = 1 + Finset.univ.sup childrenH_723_i2 := by decide +kernel +theorem required_origin_723_i2 : ∀ x ∈ required_723_i2, + (∃ j, x ∈ childrenC_723_i2 j) ∨ ∀ j, x ∈ childrenD_723_i2 j := by decide +kernel +theorem required_exact_723_i2 : required_723_i2 = + ((Finset.univ.biUnion childrenC_723_i2) ∪ commonEnvelope childrenD_723_i2).erase (5, 7) := by + exact required_eq_combination childrenC_723_i2 childrenD_723_i2 (5, 7) required_723_i2 + (by decide +kernel) child_required_sub_723_i2 common_sub_723_i2 required_origin_723_i2 +theorem envelope_origin_723_i2 : ∀ x ∈ envelope_723_i2, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_723_i2 j := by decide +kernel +theorem envelope_exact_723_i2 : envelope_723_i2 = + insert (5, 7) (Finset.univ.biUnion childrenD_723_i2) := by + exact envelope_eq_combination childrenD_723_i2 (5, 7) envelope_723_i2 + pivot_mem_723_i2 child_envelope_sub_723_i2 envelope_origin_723_i2 +def checked_723_i2 : CheckedCard where + required := required_723_i2 + envelope := envelope_723_i2 + height := height_723_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_723_i2 +def height_723 : ℕ := 12 +def childrenH_723 : Fin 5 → ℕ := ![height_328, height_330, height_723_i0, height_723_i1, height_723_i2] +theorem height_exact_723 : height_723 = 1 + Finset.univ.sup childrenH_723 := by decide +kernel +theorem required_origin_723 : ∀ x ∈ required_723, + (∃ j, x ∈ childrenC_723 j) ∨ ∀ j, x ∈ childrenD_723 j := by decide +kernel +theorem required_exact_723 : required_723 = + ((Finset.univ.biUnion childrenC_723) ∪ commonEnvelope childrenD_723).erase (5, 5) := by + exact required_eq_combination childrenC_723 childrenD_723 (5, 5) required_723 + (by decide +kernel) child_required_sub_723 common_sub_723 required_origin_723 +theorem envelope_origin_723 : ∀ x ∈ envelope_723, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_723 j := by decide +kernel +theorem envelope_exact_723 : envelope_723 = + insert (5, 5) (Finset.univ.biUnion childrenD_723) := by + exact envelope_eq_combination childrenD_723 (5, 5) envelope_723 + pivot_mem_723 child_envelope_sub_723 envelope_origin_723 +def checked_723 : CheckedCard where + required := required_723 + envelope := envelope_723 + height := height_723 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_723 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part01.lean new file mode 100644 index 0000000..9319f1e --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part01.lean @@ -0,0 +1,820 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_462 : Finset Cell := ⟨(([(1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_462 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (0, 8), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 5), (5, 7), (6, 1), (6, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_462 : Fin 7 → Finset Cell := ![(placed21 2 (2, 1) required_13), (placed21 6 (2, 7) required_14), (placed21 4 (0, 7) required_31), (placed21 2 (2, 1) required_189), (placed21 4 (0, 7) required_367), (placed21 4 (0, 6) required_428), (placed21 0 (0, 2) required_457)] +def childrenD_462 : Fin 7 → Finset Cell := ![(placed21 2 (2, 1) envelope_13), (placed21 6 (2, 7) envelope_14), (placed21 4 (0, 7) envelope_31), (placed21 2 (2, 1) envelope_189), (placed21 4 (0, 7) envelope_367), (placed21 4 (0, 6) envelope_428), (placed21 0 (0, 2) envelope_457)] +theorem common_sub_462 : commonEnvelope childrenD_462 ⊆ insert (1, 5) required_462 := by decide +kernel +theorem child_required_sub_462 : ∀ j, childrenC_462 j ⊆ insert (1, 5) required_462 := by decide +kernel +theorem child_envelope_sub_462 : ∀ j, childrenD_462 j ⊆ envelope_462 := by decide +kernel +theorem pivot_mem_462 : (1, 5) ∈ envelope_462 := by decide +kernel +theorem children_work_462 : ∀ j, Template HasSnaky 12 (childrenC_462 j) (childrenD_462 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 2 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_14 6 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_31 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_189 2 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_367 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_428 4 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_457 0 (0, 2)).mono (by decide +kernel) +theorem row_works_462 : Template HasSnaky 13 required_462 envelope_462 := by + refine compose HasSnaky 12 childrenC_462 childrenD_462 children_work_462 (1, 5) + required_462 envelope_462 pivot_mem_462 child_required_sub_462 child_envelope_sub_462 ?_ + intro b hb + exact common_sub_462 (mem_commonEnvelope childrenD_462 b hb) +def required_490 : Finset Cell := ⟨(([(2, 7), (3, 7), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_490 : Finset Cell := ⟨(([(0, 3), (0, 5), (0, 9), (0, 11), (1, 3), (1, 4), (1, 5), (1, 6), (1, 8), (1, 9), (1, 10), (1, 11), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (3, 9), (3, 10), (3, 11), (3, 12), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 3), (9, 5), (9, 6), (9, 8), (9, 9), (9, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_490 : Fin 6 → Finset Cell := ![(placed21 0 (2, 3) required_321), (placed21 4 (2, 11) required_321), (placed21 1 (0, 6) required_485), (placed21 3 (0, 8) required_485), (placed21 0 (0, 2) required_489), (placed21 4 (0, 12) required_489)] +def childrenD_490 : Fin 6 → Finset Cell := ![(placed21 0 (2, 3) envelope_321), (placed21 4 (2, 11) envelope_321), (placed21 1 (0, 6) envelope_485), (placed21 3 (0, 8) envelope_485), (placed21 0 (0, 2) envelope_489), (placed21 4 (0, 12) envelope_489)] +theorem common_sub_490 : commonEnvelope childrenD_490 ⊆ insert (5, 7) required_490 := by decide +kernel +theorem child_required_sub_490 : ∀ j, childrenC_490 j ⊆ insert (5, 7) required_490 := by decide +kernel +theorem child_envelope_sub_490 : ∀ j, childrenD_490 j ⊆ envelope_490 := by decide +kernel +theorem pivot_mem_490 : (5, 7) ∈ envelope_490 := by decide +kernel +theorem children_work_490 : ∀ j, Template HasSnaky 12 (childrenC_490 j) (childrenD_490 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_321 0 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_321 4 (2, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_485 1 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_485 3 (0, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_489 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_489 4 (0, 12)).mono (by decide +kernel) +theorem row_works_490 : Template HasSnaky 13 required_490 envelope_490 := by + refine compose HasSnaky 12 childrenC_490 childrenD_490 children_work_490 (5, 7) + required_490 envelope_490 pivot_mem_490 child_required_sub_490 child_envelope_sub_490 ?_ + intro b hb + exact common_sub_490 (mem_commonEnvelope childrenD_490 b hb) +def required_538_i0 : Finset Cell := ⟨(([(1, 6), (2, 6), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538_i0 : Finset Cell := ⟨(([(1, 6), (1, 8), (1, 9), (2, 6), (2, 8), (2, 9), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 6), (7, 7), (7, 8), (8, 6), (8, 7), (8, 8), (9, 6), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538_i0 : Fin 6 → Finset Cell := ![(placed21 0 (3, 3) required_190), (placed21 2 (7, 3) required_190), (placed21 5 (8, 5) required_258), (placed21 4 (1, 9) required_273), (placed21 0 (1, 4) required_415), (placed21 1 (2, 4) required_507)] +def childrenD_538_i0 : Fin 6 → Finset Cell := ![(placed21 0 (3, 3) envelope_190), (placed21 2 (7, 3) envelope_190), (placed21 5 (8, 5) envelope_258), (placed21 4 (1, 9) envelope_273), (placed21 0 (1, 4) envelope_415), (placed21 1 (2, 4) envelope_507)] +theorem common_sub_538_i0 : commonEnvelope childrenD_538_i0 ⊆ insert (5, 7) required_538_i0 := by decide +kernel +theorem child_required_sub_538_i0 : ∀ j, childrenC_538_i0 j ⊆ insert (5, 7) required_538_i0 := by decide +kernel +theorem child_envelope_sub_538_i0 : ∀ j, childrenD_538_i0 j ⊆ envelope_538_i0 := by decide +kernel +theorem pivot_mem_538_i0 : (5, 7) ∈ envelope_538_i0 := by decide +kernel +theorem children_work_538_i0 : ∀ j, Template HasSnaky 8 (childrenC_538_i0 j) (childrenD_538_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_190 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_190 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_258 5 (8, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_273 4 (1, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_415 0 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_507 1 (2, 4)).mono (by decide +kernel) +theorem row_works_538_i0 : Template HasSnaky 9 required_538_i0 envelope_538_i0 := by + refine compose HasSnaky 8 childrenC_538_i0 childrenD_538_i0 children_work_538_i0 (5, 7) + required_538_i0 envelope_538_i0 pivot_mem_538_i0 child_required_sub_538_i0 child_envelope_sub_538_i0 ?_ + intro b hb + exact common_sub_538_i0 (mem_commonEnvelope childrenD_538_i0 b hb) +def required_538_i1 : Finset Cell := ⟨(([(1, 6), (2, 6), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538_i1 : Finset Cell := ⟨(([(1, 6), (2, 6), (3, 6), (3, 7), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) required_2), (placed21 4 (3, 9) required_512)] +def childrenD_538_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) envelope_2), (placed21 4 (3, 9) envelope_512)] +theorem common_sub_538_i1 : commonEnvelope childrenD_538_i1 ⊆ insert (4, 6) required_538_i1 := by decide +kernel +theorem child_required_sub_538_i1 : ∀ j, childrenC_538_i1 j ⊆ insert (4, 6) required_538_i1 := by decide +kernel +theorem child_envelope_sub_538_i1 : ∀ j, childrenD_538_i1 j ⊆ envelope_538_i1 := by decide +kernel +theorem pivot_mem_538_i1 : (4, 6) ∈ envelope_538_i1 := by decide +kernel +theorem children_work_538_i1 : ∀ j, Template HasSnaky 9 (childrenC_538_i1 j) (childrenD_538_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_512 4 (3, 9)).mono (by decide +kernel) +theorem row_works_538_i1 : Template HasSnaky 10 required_538_i1 envelope_538_i1 := by + refine compose HasSnaky 9 childrenC_538_i1 childrenD_538_i1 children_work_538_i1 (4, 6) + required_538_i1 envelope_538_i1 pivot_mem_538_i1 child_required_sub_538_i1 child_envelope_sub_538_i1 ?_ + intro b hb + exact common_sub_538_i1 (mem_commonEnvelope childrenD_538_i1 b hb) +def required_538_i3 : Finset Cell := ⟨(([(2, 6), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538_i3 : Finset Cell := ⟨(([(2, 6), (3, 6), (3, 7), (4, 6), (4, 7), (4, 8), (4, 9), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538_i3 : Fin 3 → Finset Cell := ![(placed21 0 (5, 3) required_7), (placed21 2 (6, 3) required_9), (placed21 5 (6, 4) required_354)] +def childrenD_538_i3 : Fin 3 → Finset Cell := ![(placed21 0 (5, 3) envelope_7), (placed21 2 (6, 3) envelope_9), (placed21 5 (6, 4) envelope_354)] +theorem common_sub_538_i3 : commonEnvelope childrenD_538_i3 ⊆ insert (5, 7) required_538_i3 := by decide +kernel +theorem child_required_sub_538_i3 : ∀ j, childrenC_538_i3 j ⊆ insert (5, 7) required_538_i3 := by decide +kernel +theorem child_envelope_sub_538_i3 : ∀ j, childrenD_538_i3 j ⊆ envelope_538_i3 := by decide +kernel +theorem pivot_mem_538_i3 : (5, 7) ∈ envelope_538_i3 := by decide +kernel +theorem children_work_538_i3 : ∀ j, Template HasSnaky 4 (childrenC_538_i3 j) (childrenD_538_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_354 5 (6, 4)).mono (by decide +kernel) +theorem row_works_538_i3 : Template HasSnaky 5 required_538_i3 envelope_538_i3 := by + refine compose HasSnaky 4 childrenC_538_i3 childrenD_538_i3 children_work_538_i3 (5, 7) + required_538_i3 envelope_538_i3 pivot_mem_538_i3 child_required_sub_538_i3 child_envelope_sub_538_i3 ?_ + intro b hb + exact common_sub_538_i3 (mem_commonEnvelope childrenD_538_i3 b hb) +def required_538_i4 : Finset Cell := ⟨(([(1, 6), (2, 6), (4, 5), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538_i4 : Finset Cell := ⟨(([(1, 6), (2, 6), (3, 6), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538_i4 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) required_2), (placed21 2 (5, 3) required_15)] +def childrenD_538_i4 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) envelope_2), (placed21 2 (5, 3) envelope_15)] +theorem common_sub_538_i4 : commonEnvelope childrenD_538_i4 ⊆ insert (4, 6) required_538_i4 := by decide +kernel +theorem child_required_sub_538_i4 : ∀ j, childrenC_538_i4 j ⊆ insert (4, 6) required_538_i4 := by decide +kernel +theorem child_envelope_sub_538_i4 : ∀ j, childrenD_538_i4 j ⊆ envelope_538_i4 := by decide +kernel +theorem pivot_mem_538_i4 : (4, 6) ∈ envelope_538_i4 := by decide +kernel +theorem children_work_538_i4 : ∀ j, Template HasSnaky 2 (childrenC_538_i4 j) (childrenD_538_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_15 2 (5, 3)).mono (by decide +kernel) +theorem row_works_538_i4 : Template HasSnaky 3 required_538_i4 envelope_538_i4 := by + refine compose HasSnaky 2 childrenC_538_i4 childrenD_538_i4 children_work_538_i4 (4, 6) + required_538_i4 envelope_538_i4 pivot_mem_538_i4 child_required_sub_538_i4 child_envelope_sub_538_i4 ?_ + intro b hb + exact common_sub_538_i4 (mem_commonEnvelope childrenD_538_i4 b hb) +def required_538_i5 : Finset Cell := ⟨(([(1, 3), (2, 3), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538_i5 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3), (4, 2), (4, 3), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 7), (6, 8), (6, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538_i5 : Fin 2 → Finset Cell := ![(placed21 1 (4, 4) required_8), (placed21 7 (6, 7) required_505)] +def childrenD_538_i5 : Fin 2 → Finset Cell := ![(placed21 1 (4, 4) envelope_8), (placed21 7 (6, 7) envelope_505)] +theorem common_sub_538_i5 : commonEnvelope childrenD_538_i5 ⊆ insert (5, 7) required_538_i5 := by decide +kernel +theorem child_required_sub_538_i5 : ∀ j, childrenC_538_i5 j ⊆ insert (5, 7) required_538_i5 := by decide +kernel +theorem child_envelope_sub_538_i5 : ∀ j, childrenD_538_i5 j ⊆ envelope_538_i5 := by decide +kernel +theorem pivot_mem_538_i5 : (5, 7) ∈ envelope_538_i5 := by decide +kernel +theorem children_work_538_i5 : ∀ j, Template HasSnaky 5 (childrenC_538_i5 j) (childrenD_538_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_505 7 (6, 7)).mono (by decide +kernel) +theorem row_works_538_i5 : Template HasSnaky 6 required_538_i5 envelope_538_i5 := by + refine compose HasSnaky 5 childrenC_538_i5 childrenD_538_i5 children_work_538_i5 (5, 7) + required_538_i5 envelope_538_i5 pivot_mem_538_i5 child_required_sub_538_i5 child_envelope_sub_538_i5 ?_ + intro b hb + exact common_sub_538_i5 (mem_commonEnvelope childrenD_538_i5 b hb) +def required_538_i2 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 6), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538_i2 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 6), (2, 2), (2, 3), (2, 6), (3, 3), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (7, 4), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538_i2 : Fin 4 → Finset Cell := ![(placed21 4 (3, 7) required_136), required_538_i3, required_538_i4, required_538_i5] +def childrenD_538_i2 : Fin 4 → Finset Cell := ![(placed21 4 (3, 7) envelope_136), envelope_538_i3, envelope_538_i4, envelope_538_i5] +theorem common_sub_538_i2 : commonEnvelope childrenD_538_i2 ⊆ insert (5, 4) required_538_i2 := by decide +kernel +theorem child_required_sub_538_i2 : ∀ j, childrenC_538_i2 j ⊆ insert (5, 4) required_538_i2 := by decide +kernel +theorem child_envelope_sub_538_i2 : ∀ j, childrenD_538_i2 j ⊆ envelope_538_i2 := by decide +kernel +theorem pivot_mem_538_i2 : (5, 4) ∈ envelope_538_i2 := by decide +kernel +theorem children_work_538_i2 : ∀ j, Template HasSnaky 6 (childrenC_538_i2 j) (childrenD_538_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_136 4 (3, 7)).mono (by decide +kernel) + · exact row_works_538_i3.mono (by decide +kernel) + · exact row_works_538_i4.mono (by decide +kernel) + · exact row_works_538_i5.mono (by decide +kernel) +theorem row_works_538_i2 : Template HasSnaky 7 required_538_i2 envelope_538_i2 := by + refine compose HasSnaky 6 childrenC_538_i2 childrenD_538_i2 children_work_538_i2 (5, 4) + required_538_i2 envelope_538_i2 pivot_mem_538_i2 child_required_sub_538_i2 child_envelope_sub_538_i2 ?_ + intro b hb + exact common_sub_538_i2 (mem_commonEnvelope childrenD_538_i2 b hb) +def required_538_i6 : Finset Cell := ⟨(([(1, 6), (2, 6), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538_i6 : Finset Cell := ⟨(([(1, 6), (2, 6), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538_i6 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) required_2), (placed21 0 (3, 2) required_517)] +def childrenD_538_i6 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) envelope_2), (placed21 0 (3, 2) envelope_517)] +theorem common_sub_538_i6 : commonEnvelope childrenD_538_i6 ⊆ insert (4, 6) required_538_i6 := by decide +kernel +theorem child_required_sub_538_i6 : ∀ j, childrenC_538_i6 j ⊆ insert (4, 6) required_538_i6 := by decide +kernel +theorem child_envelope_sub_538_i6 : ∀ j, childrenD_538_i6 j ⊆ envelope_538_i6 := by decide +kernel +theorem pivot_mem_538_i6 : (4, 6) ∈ envelope_538_i6 := by decide +kernel +theorem children_work_538_i6 : ∀ j, Template HasSnaky 11 (childrenC_538_i6 j) (childrenD_538_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_517 0 (3, 2)).mono (by decide +kernel) +theorem row_works_538_i6 : Template HasSnaky 12 required_538_i6 envelope_538_i6 := by + refine compose HasSnaky 11 childrenC_538_i6 childrenD_538_i6 children_work_538_i6 (4, 6) + required_538_i6 envelope_538_i6 pivot_mem_538_i6 child_required_sub_538_i6 child_envelope_sub_538_i6 ?_ + intro b hb + exact common_sub_538_i6 (mem_commonEnvelope childrenD_538_i6 b hb) +def required_538_i7 : Finset Cell := ⟨(([(1, 6), (2, 6), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538_i7 : Finset Cell := ⟨(([(1, 6), (1, 8), (1, 9), (2, 6), (2, 8), (2, 9), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 6), (7, 7), (7, 8), (8, 6), (8, 7), (8, 8), (9, 6), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538_i7 : Fin 7 → Finset Cell := ![(placed21 3 (2, 8) required_116), (placed21 5 (7, 4) required_180), (placed21 5 (8, 5) required_258), (placed21 4 (1, 9) required_273), (placed21 1 (3, 4) required_275), (placed21 0 (1, 4) required_415), (placed21 2 (8, 2) required_518)] +def childrenD_538_i7 : Fin 7 → Finset Cell := ![(placed21 3 (2, 8) envelope_116), (placed21 5 (7, 4) envelope_180), (placed21 5 (8, 5) envelope_258), (placed21 4 (1, 9) envelope_273), (placed21 1 (3, 4) envelope_275), (placed21 0 (1, 4) envelope_415), (placed21 2 (8, 2) envelope_518)] +theorem common_sub_538_i7 : commonEnvelope childrenD_538_i7 ⊆ insert (5, 7) required_538_i7 := by decide +kernel +theorem child_required_sub_538_i7 : ∀ j, childrenC_538_i7 j ⊆ insert (5, 7) required_538_i7 := by decide +kernel +theorem child_envelope_sub_538_i7 : ∀ j, childrenD_538_i7 j ⊆ envelope_538_i7 := by decide +kernel +theorem pivot_mem_538_i7 : (5, 7) ∈ envelope_538_i7 := by decide +kernel +theorem children_work_538_i7 : ∀ j, Template HasSnaky 8 (childrenC_538_i7 j) (childrenD_538_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_116 3 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_180 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_258 5 (8, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_273 4 (1, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_275 1 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_415 0 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_518 2 (8, 2)).mono (by decide +kernel) +theorem row_works_538_i7 : Template HasSnaky 9 required_538_i7 envelope_538_i7 := by + refine compose HasSnaky 8 childrenC_538_i7 childrenD_538_i7 children_work_538_i7 (5, 7) + required_538_i7 envelope_538_i7 pivot_mem_538_i7 child_required_sub_538_i7 child_envelope_sub_538_i7 ?_ + intro b hb + exact common_sub_538_i7 (mem_commonEnvelope childrenD_538_i7 b hb) +def required_538_i8 : Finset Cell := ⟨(([(1, 6), (2, 6), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538_i8 : Finset Cell := ⟨(([(1, 6), (2, 6), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 4), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538_i8 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) required_2), (placed21 4 (3, 9) required_527)] +def childrenD_538_i8 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) envelope_2), (placed21 4 (3, 9) envelope_527)] +theorem common_sub_538_i8 : commonEnvelope childrenD_538_i8 ⊆ insert (4, 6) required_538_i8 := by decide +kernel +theorem child_required_sub_538_i8 : ∀ j, childrenC_538_i8 j ⊆ insert (4, 6) required_538_i8 := by decide +kernel +theorem child_envelope_sub_538_i8 : ∀ j, childrenD_538_i8 j ⊆ envelope_538_i8 := by decide +kernel +theorem pivot_mem_538_i8 : (4, 6) ∈ envelope_538_i8 := by decide +kernel +theorem children_work_538_i8 : ∀ j, Template HasSnaky 11 (childrenC_538_i8 j) (childrenD_538_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_527 4 (3, 9)).mono (by decide +kernel) +theorem row_works_538_i8 : Template HasSnaky 12 required_538_i8 envelope_538_i8 := by + refine compose HasSnaky 11 childrenC_538_i8 childrenD_538_i8 children_work_538_i8 (4, 6) + required_538_i8 envelope_538_i8 pivot_mem_538_i8 child_required_sub_538_i8 child_envelope_sub_538_i8 ?_ + intro b hb + exact common_sub_538_i8 (mem_commonEnvelope childrenD_538_i8 b hb) +def required_538_i9 : Finset Cell := ⟨(([(1, 6), (2, 6), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538_i9 : Finset Cell := ⟨(([(1, 6), (2, 6), (3, 6), (3, 7), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538_i9 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) required_2), (placed21 4 (3, 9) required_537)] +def childrenD_538_i9 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) envelope_2), (placed21 4 (3, 9) envelope_537)] +theorem common_sub_538_i9 : commonEnvelope childrenD_538_i9 ⊆ insert (4, 6) required_538_i9 := by decide +kernel +theorem child_required_sub_538_i9 : ∀ j, childrenC_538_i9 j ⊆ insert (4, 6) required_538_i9 := by decide +kernel +theorem child_envelope_sub_538_i9 : ∀ j, childrenD_538_i9 j ⊆ envelope_538_i9 := by decide +kernel +theorem pivot_mem_538_i9 : (4, 6) ∈ envelope_538_i9 := by decide +kernel +theorem children_work_538_i9 : ∀ j, Template HasSnaky 9 (childrenC_538_i9 j) (childrenD_538_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_537 4 (3, 9)).mono (by decide +kernel) +theorem row_works_538_i9 : Template HasSnaky 10 required_538_i9 envelope_538_i9 := by + refine compose HasSnaky 9 childrenC_538_i9 childrenD_538_i9 children_work_538_i9 (4, 6) + required_538_i9 envelope_538_i9 pivot_mem_538_i9 child_required_sub_538_i9 child_envelope_sub_538_i9 ?_ + intro b hb + exact common_sub_538_i9 (mem_commonEnvelope childrenD_538_i9 b hb) +def required_538 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 6), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_538 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 6), (1, 8), (1, 9), (2, 2), (2, 3), (2, 6), (2, 8), (2, 9), (3, 3), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_538 : Fin 10 → Finset Cell := ![(placed21 0 (4, 1) required_459), required_538_i0, required_538_i1, required_538_i2, required_538_i6, required_538_i7, required_538_i8, (placed21 0 (0, 1) required_529), (placed21 4 (3, 10) required_535), required_538_i9] +def childrenD_538 : Fin 10 → Finset Cell := ![(placed21 0 (4, 1) envelope_459), envelope_538_i0, envelope_538_i1, envelope_538_i2, envelope_538_i6, envelope_538_i7, envelope_538_i8, (placed21 0 (0, 1) envelope_529), (placed21 4 (3, 10) envelope_535), envelope_538_i9] +theorem common_sub_538 : commonEnvelope childrenD_538 ⊆ insert (5, 6) required_538 := by decide +kernel +theorem child_required_sub_538 : ∀ j, childrenC_538 j ⊆ insert (5, 6) required_538 := by decide +kernel +theorem child_envelope_sub_538 : ∀ j, childrenD_538 j ⊆ envelope_538 := by decide +kernel +theorem pivot_mem_538 : (5, 6) ∈ envelope_538 := by decide +kernel +theorem children_work_538 : ∀ j, Template HasSnaky 12 (childrenC_538 j) (childrenD_538 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_459 0 (4, 1)).mono (by decide +kernel) + · exact row_works_538_i0.mono (by decide +kernel) + · exact row_works_538_i1.mono (by decide +kernel) + · exact row_works_538_i2.mono (by decide +kernel) + · exact row_works_538_i6.mono (by decide +kernel) + · exact row_works_538_i7.mono (by decide +kernel) + · exact row_works_538_i8.mono (by decide +kernel) + · exact (placed21_template row_works_529 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_535 4 (3, 10)).mono (by decide +kernel) + · exact row_works_538_i9.mono (by decide +kernel) +theorem row_works_538 : Template HasSnaky 13 required_538 envelope_538 := by + refine compose HasSnaky 12 childrenC_538 childrenD_538 children_work_538 (5, 6) + required_538 envelope_538 pivot_mem_538 child_required_sub_538 child_envelope_sub_538 ?_ + intro b hb + exact common_sub_538 (mem_commonEnvelope childrenD_538 b hb) +def required_552_i1 : Finset Cell := ⟨(([(3, 7), (4, 7), (6, 6), (7, 6), (7, 7), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_552_i1 : Finset Cell := ⟨(([(3, 7), (4, 6), (4, 7), (5, 6), (6, 6), (6, 7), (7, 6), (7, 7), (8, 6), (8, 7), (9, 6), (9, 7), (10, 6), (10, 7), (11, 6), (11, 7), (12, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_552_i1 : Fin 2 → Finset Cell := ![(placed21 2 (7, 6) required_3), (placed21 1 (5, 6) required_389)] +def childrenD_552_i1 : Fin 2 → Finset Cell := ![(placed21 2 (7, 6) envelope_3), (placed21 1 (5, 6) envelope_389)] +theorem common_sub_552_i1 : commonEnvelope childrenD_552_i1 ⊆ insert (5, 6) required_552_i1 := by decide +kernel +theorem child_required_sub_552_i1 : ∀ j, childrenC_552_i1 j ⊆ insert (5, 6) required_552_i1 := by decide +kernel +theorem child_envelope_sub_552_i1 : ∀ j, childrenD_552_i1 j ⊆ envelope_552_i1 := by decide +kernel +theorem pivot_mem_552_i1 : (5, 6) ∈ envelope_552_i1 := by decide +kernel +theorem children_work_552_i1 : ∀ j, Template HasSnaky 5 (childrenC_552_i1 j) (childrenD_552_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 2 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_389 1 (5, 6)).mono (by decide +kernel) +theorem row_works_552_i1 : Template HasSnaky 6 required_552_i1 envelope_552_i1 := by + refine compose HasSnaky 5 childrenC_552_i1 childrenD_552_i1 children_work_552_i1 (5, 6) + required_552_i1 envelope_552_i1 pivot_mem_552_i1 child_required_sub_552_i1 child_envelope_sub_552_i1 ?_ + intro b hb + exact common_sub_552_i1 (mem_commonEnvelope childrenD_552_i1 b hb) +def required_552_i0 : Finset Cell := ⟨(([(3, 7), (4, 7), (6, 6), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_552_i0 : Finset Cell := ⟨(([(3, 7), (4, 6), (4, 7), (5, 6), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 6), (9, 7), (9, 8), (9, 9), (10, 6), (10, 7), (10, 8), (10, 9), (11, 6), (11, 7), (11, 8), (11, 9), (12, 7), (12, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_552_i0 : Fin 5 → Finset Cell := ![(placed21 1 (4, 4) required_544), (placed21 4 (6, 11) required_545), (placed21 0 (6, 2) required_546), required_552_i1, (placed21 0 (6, 1) required_548)] +def childrenD_552_i0 : Fin 5 → Finset Cell := ![(placed21 1 (4, 4) envelope_544), (placed21 4 (6, 11) envelope_545), (placed21 0 (6, 2) envelope_546), envelope_552_i1, (placed21 0 (6, 1) envelope_548)] +theorem common_sub_552_i0 : commonEnvelope childrenD_552_i0 ⊆ insert (7, 7) required_552_i0 := by decide +kernel +theorem child_required_sub_552_i0 : ∀ j, childrenC_552_i0 j ⊆ insert (7, 7) required_552_i0 := by decide +kernel +theorem child_envelope_sub_552_i0 : ∀ j, childrenD_552_i0 j ⊆ envelope_552_i0 := by decide +kernel +theorem pivot_mem_552_i0 : (7, 7) ∈ envelope_552_i0 := by decide +kernel +theorem children_work_552_i0 : ∀ j, Template HasSnaky 10 (childrenC_552_i0 j) (childrenD_552_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_544 1 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_545 4 (6, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_546 0 (6, 2)).mono (by decide +kernel) + · exact row_works_552_i1.mono (by decide +kernel) + · exact (placed21_template row_works_548 0 (6, 1)).mono (by decide +kernel) +theorem row_works_552_i0 : Template HasSnaky 11 required_552_i0 envelope_552_i0 := by + refine compose HasSnaky 10 childrenC_552_i0 childrenD_552_i0 children_work_552_i0 (7, 7) + required_552_i0 envelope_552_i0 pivot_mem_552_i0 child_required_sub_552_i0 child_envelope_sub_552_i0 ?_ + intro b hb + exact common_sub_552_i0 (mem_commonEnvelope childrenD_552_i0 b hb) +def required_552 : Finset Cell := ⟨(([(3, 4), (3, 7), (4, 4), (4, 7), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_552 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (12, 5), (12, 7), (12, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_552 : Fin 6 → Finset Cell := ![(placed21 1 (4, 4) required_188), (placed21 0 (6, 3) required_258), (placed21 4 (3, 10) required_326), (placed21 3 (0, 8) required_543), required_552_i0, (placed21 0 (2, 1) required_551)] +def childrenD_552 : Fin 6 → Finset Cell := ![(placed21 1 (4, 4) envelope_188), (placed21 0 (6, 3) envelope_258), (placed21 4 (3, 10) envelope_326), (placed21 3 (0, 8) envelope_543), envelope_552_i0, (placed21 0 (2, 1) envelope_551)] +theorem common_sub_552 : commonEnvelope childrenD_552 ⊆ insert (8, 6) required_552 := by decide +kernel +theorem child_required_sub_552 : ∀ j, childrenC_552 j ⊆ insert (8, 6) required_552 := by decide +kernel +theorem child_envelope_sub_552 : ∀ j, childrenD_552 j ⊆ envelope_552 := by decide +kernel +theorem pivot_mem_552 : (8, 6) ∈ envelope_552 := by decide +kernel +theorem children_work_552 : ∀ j, Template HasSnaky 12 (childrenC_552 j) (childrenD_552 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_188 1 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_258 0 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_326 4 (3, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_543 3 (0, 8)).mono (by decide +kernel) + · exact row_works_552_i0.mono (by decide +kernel) + · exact (placed21_template row_works_551 0 (2, 1)).mono (by decide +kernel) +theorem row_works_552 : Template HasSnaky 13 required_552 envelope_552 := by + refine compose HasSnaky 12 childrenC_552 childrenD_552 children_work_552 (8, 6) + required_552 envelope_552 pivot_mem_552 child_required_sub_552 child_envelope_sub_552 ?_ + intro b hb + exact common_sub_552 (mem_commonEnvelope childrenD_552 b hb) +def required_555_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_555_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (2, 3), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_555_i0 : Fin 3 → Finset Cell := ![(placed21 6 (3, 6) required_61), (placed21 0 (2, 2) required_194), (placed21 0 (0, 1) required_224)] +def childrenD_555_i0 : Fin 3 → Finset Cell := ![(placed21 6 (3, 6) envelope_61), (placed21 0 (2, 2) envelope_194), (placed21 0 (0, 1) envelope_224)] +theorem common_sub_555_i0 : commonEnvelope childrenD_555_i0 ⊆ insert (2, 2) required_555_i0 := by decide +kernel +theorem child_required_sub_555_i0 : ∀ j, childrenC_555_i0 j ⊆ insert (2, 2) required_555_i0 := by decide +kernel +theorem child_envelope_sub_555_i0 : ∀ j, childrenD_555_i0 j ⊆ envelope_555_i0 := by decide +kernel +theorem pivot_mem_555_i0 : (2, 2) ∈ envelope_555_i0 := by decide +kernel +theorem children_work_555_i0 : ∀ j, Template HasSnaky 4 (childrenC_555_i0 j) (childrenD_555_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_61 6 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_194 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_224 0 (0, 1)).mono (by decide +kernel) +theorem row_works_555_i0 : Template HasSnaky 5 required_555_i0 envelope_555_i0 := by + refine compose HasSnaky 4 childrenC_555_i0 childrenD_555_i0 children_work_555_i0 (2, 2) + required_555_i0 envelope_555_i0 pivot_mem_555_i0 child_required_sub_555_i0 child_envelope_sub_555_i0 ?_ + intro b hb + exact common_sub_555_i0 (mem_commonEnvelope childrenD_555_i0 b hb) +def required_555 : Finset Cell := ⟨(([(0, 2), (1, 2), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_555 : Finset Cell := ⟨(([(0, 2), (1, 2), (2, 0), (2, 1), (2, 2), (2, 3), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 5), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_555 : Fin 7 → Finset Cell := ![(placed21 6 (4, 7) required_13), (placed21 2 (4, 1) required_14), (placed21 0 (2, 1) required_31), (placed21 7 (5, 6) required_230), (placed21 0 (2, 1) required_367), (placed21 0 (2, 2) required_428), required_555_i0] +def childrenD_555 : Fin 7 → Finset Cell := ![(placed21 6 (4, 7) envelope_13), (placed21 2 (4, 1) envelope_14), (placed21 0 (2, 1) envelope_31), (placed21 7 (5, 6) envelope_230), (placed21 0 (2, 1) envelope_367), (placed21 0 (2, 2) envelope_428), envelope_555_i0] +theorem common_sub_555 : commonEnvelope childrenD_555 ⊆ insert (3, 3) required_555 := by decide +kernel +theorem child_required_sub_555 : ∀ j, childrenC_555 j ⊆ insert (3, 3) required_555 := by decide +kernel +theorem child_envelope_sub_555 : ∀ j, childrenD_555 j ⊆ envelope_555 := by decide +kernel +theorem pivot_mem_555 : (3, 3) ∈ envelope_555 := by decide +kernel +theorem children_work_555 : ∀ j, Template HasSnaky 12 (childrenC_555 j) (childrenD_555 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_14 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_31 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_230 7 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_367 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_428 0 (2, 2)).mono (by decide +kernel) + · exact row_works_555_i0.mono (by decide +kernel) +theorem row_works_555 : Template HasSnaky 13 required_555 envelope_555 := by + refine compose HasSnaky 12 childrenC_555 childrenD_555 children_work_555 (3, 3) + required_555 envelope_555 pivot_mem_555 child_required_sub_555 child_envelope_sub_555 ?_ + intro b hb + exact common_sub_555 (mem_commonEnvelope childrenD_555 b hb) +def height_462 : ℕ := 13 +def childrenH_462 : Fin 7 → ℕ := ![height_13, height_14, height_31, height_189, height_367, height_428, height_457] +theorem height_exact_462 : height_462 = 1 + Finset.univ.sup childrenH_462 := by decide +kernel +theorem required_origin_462 : ∀ x ∈ required_462, + (∃ j, x ∈ childrenC_462 j) ∨ ∀ j, x ∈ childrenD_462 j := by decide +kernel +theorem required_exact_462 : required_462 = + ((Finset.univ.biUnion childrenC_462) ∪ commonEnvelope childrenD_462).erase (1, 5) := by + exact required_eq_combination childrenC_462 childrenD_462 (1, 5) required_462 + (by decide +kernel) child_required_sub_462 common_sub_462 required_origin_462 +theorem envelope_origin_462 : ∀ x ∈ envelope_462, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_462 j := by decide +kernel +theorem envelope_exact_462 : envelope_462 = + insert (1, 5) (Finset.univ.biUnion childrenD_462) := by + exact envelope_eq_combination childrenD_462 (1, 5) envelope_462 + pivot_mem_462 child_envelope_sub_462 envelope_origin_462 +def checked_462 : CheckedCard where + required := required_462 + envelope := envelope_462 + height := height_462 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_462 +def height_490 : ℕ := 13 +def childrenH_490 : Fin 6 → ℕ := ![height_321, height_321, height_485, height_485, height_489, height_489] +theorem height_exact_490 : height_490 = 1 + Finset.univ.sup childrenH_490 := by decide +kernel +theorem required_origin_490 : ∀ x ∈ required_490, + (∃ j, x ∈ childrenC_490 j) ∨ ∀ j, x ∈ childrenD_490 j := by decide +kernel +theorem required_exact_490 : required_490 = + ((Finset.univ.biUnion childrenC_490) ∪ commonEnvelope childrenD_490).erase (5, 7) := by + exact required_eq_combination childrenC_490 childrenD_490 (5, 7) required_490 + (by decide +kernel) child_required_sub_490 common_sub_490 required_origin_490 +theorem envelope_origin_490 : ∀ x ∈ envelope_490, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_490 j := by decide +kernel +theorem envelope_exact_490 : envelope_490 = + insert (5, 7) (Finset.univ.biUnion childrenD_490) := by + exact envelope_eq_combination childrenD_490 (5, 7) envelope_490 + pivot_mem_490 child_envelope_sub_490 envelope_origin_490 +def checked_490 : CheckedCard where + required := required_490 + envelope := envelope_490 + height := height_490 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_490 +def height_538_i0 : ℕ := 9 +def childrenH_538_i0 : Fin 6 → ℕ := ![height_190, height_190, height_258, height_273, height_415, height_507] +theorem height_exact_538_i0 : height_538_i0 = 1 + Finset.univ.sup childrenH_538_i0 := by decide +kernel +theorem required_origin_538_i0 : ∀ x ∈ required_538_i0, + (∃ j, x ∈ childrenC_538_i0 j) ∨ ∀ j, x ∈ childrenD_538_i0 j := by decide +kernel +theorem required_exact_538_i0 : required_538_i0 = + ((Finset.univ.biUnion childrenC_538_i0) ∪ commonEnvelope childrenD_538_i0).erase (5, 7) := by + exact required_eq_combination childrenC_538_i0 childrenD_538_i0 (5, 7) required_538_i0 + (by decide +kernel) child_required_sub_538_i0 common_sub_538_i0 required_origin_538_i0 +theorem envelope_origin_538_i0 : ∀ x ∈ envelope_538_i0, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_538_i0 j := by decide +kernel +theorem envelope_exact_538_i0 : envelope_538_i0 = + insert (5, 7) (Finset.univ.biUnion childrenD_538_i0) := by + exact envelope_eq_combination childrenD_538_i0 (5, 7) envelope_538_i0 + pivot_mem_538_i0 child_envelope_sub_538_i0 envelope_origin_538_i0 +def checked_538_i0 : CheckedCard where + required := required_538_i0 + envelope := envelope_538_i0 + height := height_538_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538_i0 +def height_538_i1 : ℕ := 10 +def childrenH_538_i1 : Fin 2 → ℕ := ![height_2, height_512] +theorem height_exact_538_i1 : height_538_i1 = 1 + Finset.univ.sup childrenH_538_i1 := by decide +kernel +theorem required_origin_538_i1 : ∀ x ∈ required_538_i1, + (∃ j, x ∈ childrenC_538_i1 j) ∨ ∀ j, x ∈ childrenD_538_i1 j := by decide +kernel +theorem required_exact_538_i1 : required_538_i1 = + ((Finset.univ.biUnion childrenC_538_i1) ∪ commonEnvelope childrenD_538_i1).erase (4, 6) := by + exact required_eq_combination childrenC_538_i1 childrenD_538_i1 (4, 6) required_538_i1 + (by decide +kernel) child_required_sub_538_i1 common_sub_538_i1 required_origin_538_i1 +theorem envelope_origin_538_i1 : ∀ x ∈ envelope_538_i1, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_538_i1 j := by decide +kernel +theorem envelope_exact_538_i1 : envelope_538_i1 = + insert (4, 6) (Finset.univ.biUnion childrenD_538_i1) := by + exact envelope_eq_combination childrenD_538_i1 (4, 6) envelope_538_i1 + pivot_mem_538_i1 child_envelope_sub_538_i1 envelope_origin_538_i1 +def checked_538_i1 : CheckedCard where + required := required_538_i1 + envelope := envelope_538_i1 + height := height_538_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538_i1 +def height_538_i3 : ℕ := 5 +def childrenH_538_i3 : Fin 3 → ℕ := ![height_7, height_9, height_354] +theorem height_exact_538_i3 : height_538_i3 = 1 + Finset.univ.sup childrenH_538_i3 := by decide +kernel +theorem required_origin_538_i3 : ∀ x ∈ required_538_i3, + (∃ j, x ∈ childrenC_538_i3 j) ∨ ∀ j, x ∈ childrenD_538_i3 j := by decide +kernel +theorem required_exact_538_i3 : required_538_i3 = + ((Finset.univ.biUnion childrenC_538_i3) ∪ commonEnvelope childrenD_538_i3).erase (5, 7) := by + exact required_eq_combination childrenC_538_i3 childrenD_538_i3 (5, 7) required_538_i3 + (by decide +kernel) child_required_sub_538_i3 common_sub_538_i3 required_origin_538_i3 +theorem envelope_origin_538_i3 : ∀ x ∈ envelope_538_i3, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_538_i3 j := by decide +kernel +theorem envelope_exact_538_i3 : envelope_538_i3 = + insert (5, 7) (Finset.univ.biUnion childrenD_538_i3) := by + exact envelope_eq_combination childrenD_538_i3 (5, 7) envelope_538_i3 + pivot_mem_538_i3 child_envelope_sub_538_i3 envelope_origin_538_i3 +def checked_538_i3 : CheckedCard where + required := required_538_i3 + envelope := envelope_538_i3 + height := height_538_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538_i3 +def height_538_i4 : ℕ := 3 +def childrenH_538_i4 : Fin 2 → ℕ := ![height_2, height_15] +theorem height_exact_538_i4 : height_538_i4 = 1 + Finset.univ.sup childrenH_538_i4 := by decide +kernel +theorem required_origin_538_i4 : ∀ x ∈ required_538_i4, + (∃ j, x ∈ childrenC_538_i4 j) ∨ ∀ j, x ∈ childrenD_538_i4 j := by decide +kernel +theorem required_exact_538_i4 : required_538_i4 = + ((Finset.univ.biUnion childrenC_538_i4) ∪ commonEnvelope childrenD_538_i4).erase (4, 6) := by + exact required_eq_combination childrenC_538_i4 childrenD_538_i4 (4, 6) required_538_i4 + (by decide +kernel) child_required_sub_538_i4 common_sub_538_i4 required_origin_538_i4 +theorem envelope_origin_538_i4 : ∀ x ∈ envelope_538_i4, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_538_i4 j := by decide +kernel +theorem envelope_exact_538_i4 : envelope_538_i4 = + insert (4, 6) (Finset.univ.biUnion childrenD_538_i4) := by + exact envelope_eq_combination childrenD_538_i4 (4, 6) envelope_538_i4 + pivot_mem_538_i4 child_envelope_sub_538_i4 envelope_origin_538_i4 +def checked_538_i4 : CheckedCard where + required := required_538_i4 + envelope := envelope_538_i4 + height := height_538_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538_i4 +def height_538_i5 : ℕ := 6 +def childrenH_538_i5 : Fin 2 → ℕ := ![height_8, height_505] +theorem height_exact_538_i5 : height_538_i5 = 1 + Finset.univ.sup childrenH_538_i5 := by decide +kernel +theorem required_origin_538_i5 : ∀ x ∈ required_538_i5, + (∃ j, x ∈ childrenC_538_i5 j) ∨ ∀ j, x ∈ childrenD_538_i5 j := by decide +kernel +theorem required_exact_538_i5 : required_538_i5 = + ((Finset.univ.biUnion childrenC_538_i5) ∪ commonEnvelope childrenD_538_i5).erase (5, 7) := by + exact required_eq_combination childrenC_538_i5 childrenD_538_i5 (5, 7) required_538_i5 + (by decide +kernel) child_required_sub_538_i5 common_sub_538_i5 required_origin_538_i5 +theorem envelope_origin_538_i5 : ∀ x ∈ envelope_538_i5, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_538_i5 j := by decide +kernel +theorem envelope_exact_538_i5 : envelope_538_i5 = + insert (5, 7) (Finset.univ.biUnion childrenD_538_i5) := by + exact envelope_eq_combination childrenD_538_i5 (5, 7) envelope_538_i5 + pivot_mem_538_i5 child_envelope_sub_538_i5 envelope_origin_538_i5 +def checked_538_i5 : CheckedCard where + required := required_538_i5 + envelope := envelope_538_i5 + height := height_538_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538_i5 +def height_538_i2 : ℕ := 7 +def childrenH_538_i2 : Fin 4 → ℕ := ![height_136, height_538_i3, height_538_i4, height_538_i5] +theorem height_exact_538_i2 : height_538_i2 = 1 + Finset.univ.sup childrenH_538_i2 := by decide +kernel +theorem required_origin_538_i2 : ∀ x ∈ required_538_i2, + (∃ j, x ∈ childrenC_538_i2 j) ∨ ∀ j, x ∈ childrenD_538_i2 j := by decide +kernel +theorem required_exact_538_i2 : required_538_i2 = + ((Finset.univ.biUnion childrenC_538_i2) ∪ commonEnvelope childrenD_538_i2).erase (5, 4) := by + exact required_eq_combination childrenC_538_i2 childrenD_538_i2 (5, 4) required_538_i2 + (by decide +kernel) child_required_sub_538_i2 common_sub_538_i2 required_origin_538_i2 +theorem envelope_origin_538_i2 : ∀ x ∈ envelope_538_i2, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_538_i2 j := by decide +kernel +theorem envelope_exact_538_i2 : envelope_538_i2 = + insert (5, 4) (Finset.univ.biUnion childrenD_538_i2) := by + exact envelope_eq_combination childrenD_538_i2 (5, 4) envelope_538_i2 + pivot_mem_538_i2 child_envelope_sub_538_i2 envelope_origin_538_i2 +def checked_538_i2 : CheckedCard where + required := required_538_i2 + envelope := envelope_538_i2 + height := height_538_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538_i2 +def height_538_i6 : ℕ := 12 +def childrenH_538_i6 : Fin 2 → ℕ := ![height_2, height_517] +theorem height_exact_538_i6 : height_538_i6 = 1 + Finset.univ.sup childrenH_538_i6 := by decide +kernel +theorem required_origin_538_i6 : ∀ x ∈ required_538_i6, + (∃ j, x ∈ childrenC_538_i6 j) ∨ ∀ j, x ∈ childrenD_538_i6 j := by decide +kernel +theorem required_exact_538_i6 : required_538_i6 = + ((Finset.univ.biUnion childrenC_538_i6) ∪ commonEnvelope childrenD_538_i6).erase (4, 6) := by + exact required_eq_combination childrenC_538_i6 childrenD_538_i6 (4, 6) required_538_i6 + (by decide +kernel) child_required_sub_538_i6 common_sub_538_i6 required_origin_538_i6 +theorem envelope_origin_538_i6 : ∀ x ∈ envelope_538_i6, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_538_i6 j := by decide +kernel +theorem envelope_exact_538_i6 : envelope_538_i6 = + insert (4, 6) (Finset.univ.biUnion childrenD_538_i6) := by + exact envelope_eq_combination childrenD_538_i6 (4, 6) envelope_538_i6 + pivot_mem_538_i6 child_envelope_sub_538_i6 envelope_origin_538_i6 +def checked_538_i6 : CheckedCard where + required := required_538_i6 + envelope := envelope_538_i6 + height := height_538_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538_i6 +def height_538_i7 : ℕ := 9 +def childrenH_538_i7 : Fin 7 → ℕ := ![height_116, height_180, height_258, height_273, height_275, height_415, height_518] +theorem height_exact_538_i7 : height_538_i7 = 1 + Finset.univ.sup childrenH_538_i7 := by decide +kernel +theorem required_origin_538_i7 : ∀ x ∈ required_538_i7, + (∃ j, x ∈ childrenC_538_i7 j) ∨ ∀ j, x ∈ childrenD_538_i7 j := by decide +kernel +theorem required_exact_538_i7 : required_538_i7 = + ((Finset.univ.biUnion childrenC_538_i7) ∪ commonEnvelope childrenD_538_i7).erase (5, 7) := by + exact required_eq_combination childrenC_538_i7 childrenD_538_i7 (5, 7) required_538_i7 + (by decide +kernel) child_required_sub_538_i7 common_sub_538_i7 required_origin_538_i7 +theorem envelope_origin_538_i7 : ∀ x ∈ envelope_538_i7, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_538_i7 j := by decide +kernel +theorem envelope_exact_538_i7 : envelope_538_i7 = + insert (5, 7) (Finset.univ.biUnion childrenD_538_i7) := by + exact envelope_eq_combination childrenD_538_i7 (5, 7) envelope_538_i7 + pivot_mem_538_i7 child_envelope_sub_538_i7 envelope_origin_538_i7 +def checked_538_i7 : CheckedCard where + required := required_538_i7 + envelope := envelope_538_i7 + height := height_538_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538_i7 +def height_538_i8 : ℕ := 12 +def childrenH_538_i8 : Fin 2 → ℕ := ![height_2, height_527] +theorem height_exact_538_i8 : height_538_i8 = 1 + Finset.univ.sup childrenH_538_i8 := by decide +kernel +theorem required_origin_538_i8 : ∀ x ∈ required_538_i8, + (∃ j, x ∈ childrenC_538_i8 j) ∨ ∀ j, x ∈ childrenD_538_i8 j := by decide +kernel +theorem required_exact_538_i8 : required_538_i8 = + ((Finset.univ.biUnion childrenC_538_i8) ∪ commonEnvelope childrenD_538_i8).erase (4, 6) := by + exact required_eq_combination childrenC_538_i8 childrenD_538_i8 (4, 6) required_538_i8 + (by decide +kernel) child_required_sub_538_i8 common_sub_538_i8 required_origin_538_i8 +theorem envelope_origin_538_i8 : ∀ x ∈ envelope_538_i8, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_538_i8 j := by decide +kernel +theorem envelope_exact_538_i8 : envelope_538_i8 = + insert (4, 6) (Finset.univ.biUnion childrenD_538_i8) := by + exact envelope_eq_combination childrenD_538_i8 (4, 6) envelope_538_i8 + pivot_mem_538_i8 child_envelope_sub_538_i8 envelope_origin_538_i8 +def checked_538_i8 : CheckedCard where + required := required_538_i8 + envelope := envelope_538_i8 + height := height_538_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538_i8 +def height_538_i9 : ℕ := 10 +def childrenH_538_i9 : Fin 2 → ℕ := ![height_2, height_537] +theorem height_exact_538_i9 : height_538_i9 = 1 + Finset.univ.sup childrenH_538_i9 := by decide +kernel +theorem required_origin_538_i9 : ∀ x ∈ required_538_i9, + (∃ j, x ∈ childrenC_538_i9 j) ∨ ∀ j, x ∈ childrenD_538_i9 j := by decide +kernel +theorem required_exact_538_i9 : required_538_i9 = + ((Finset.univ.biUnion childrenC_538_i9) ∪ commonEnvelope childrenD_538_i9).erase (4, 6) := by + exact required_eq_combination childrenC_538_i9 childrenD_538_i9 (4, 6) required_538_i9 + (by decide +kernel) child_required_sub_538_i9 common_sub_538_i9 required_origin_538_i9 +theorem envelope_origin_538_i9 : ∀ x ∈ envelope_538_i9, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_538_i9 j := by decide +kernel +theorem envelope_exact_538_i9 : envelope_538_i9 = + insert (4, 6) (Finset.univ.biUnion childrenD_538_i9) := by + exact envelope_eq_combination childrenD_538_i9 (4, 6) envelope_538_i9 + pivot_mem_538_i9 child_envelope_sub_538_i9 envelope_origin_538_i9 +def checked_538_i9 : CheckedCard where + required := required_538_i9 + envelope := envelope_538_i9 + height := height_538_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538_i9 +def height_538 : ℕ := 13 +def childrenH_538 : Fin 10 → ℕ := ![height_459, height_538_i0, height_538_i1, height_538_i2, height_538_i6, height_538_i7, height_538_i8, height_529, height_535, height_538_i9] +theorem height_exact_538 : height_538 = 1 + Finset.univ.sup childrenH_538 := by decide +kernel +theorem required_origin_538 : ∀ x ∈ required_538, + (∃ j, x ∈ childrenC_538 j) ∨ ∀ j, x ∈ childrenD_538 j := by decide +kernel +theorem required_exact_538 : required_538 = + ((Finset.univ.biUnion childrenC_538) ∪ commonEnvelope childrenD_538).erase (5, 6) := by + exact required_eq_combination childrenC_538 childrenD_538 (5, 6) required_538 + (by decide +kernel) child_required_sub_538 common_sub_538 required_origin_538 +theorem envelope_origin_538 : ∀ x ∈ envelope_538, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_538 j := by decide +kernel +theorem envelope_exact_538 : envelope_538 = + insert (5, 6) (Finset.univ.biUnion childrenD_538) := by + exact envelope_eq_combination childrenD_538 (5, 6) envelope_538 + pivot_mem_538 child_envelope_sub_538 envelope_origin_538 +def checked_538 : CheckedCard where + required := required_538 + envelope := envelope_538 + height := height_538 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_538 +def height_552_i1 : ℕ := 6 +def childrenH_552_i1 : Fin 2 → ℕ := ![height_3, height_389] +theorem height_exact_552_i1 : height_552_i1 = 1 + Finset.univ.sup childrenH_552_i1 := by decide +kernel +theorem required_origin_552_i1 : ∀ x ∈ required_552_i1, + (∃ j, x ∈ childrenC_552_i1 j) ∨ ∀ j, x ∈ childrenD_552_i1 j := by decide +kernel +theorem required_exact_552_i1 : required_552_i1 = + ((Finset.univ.biUnion childrenC_552_i1) ∪ commonEnvelope childrenD_552_i1).erase (5, 6) := by + exact required_eq_combination childrenC_552_i1 childrenD_552_i1 (5, 6) required_552_i1 + (by decide +kernel) child_required_sub_552_i1 common_sub_552_i1 required_origin_552_i1 +theorem envelope_origin_552_i1 : ∀ x ∈ envelope_552_i1, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_552_i1 j := by decide +kernel +theorem envelope_exact_552_i1 : envelope_552_i1 = + insert (5, 6) (Finset.univ.biUnion childrenD_552_i1) := by + exact envelope_eq_combination childrenD_552_i1 (5, 6) envelope_552_i1 + pivot_mem_552_i1 child_envelope_sub_552_i1 envelope_origin_552_i1 +def checked_552_i1 : CheckedCard where + required := required_552_i1 + envelope := envelope_552_i1 + height := height_552_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_552_i1 +def height_552_i0 : ℕ := 11 +def childrenH_552_i0 : Fin 5 → ℕ := ![height_544, height_545, height_546, height_552_i1, height_548] +theorem height_exact_552_i0 : height_552_i0 = 1 + Finset.univ.sup childrenH_552_i0 := by decide +kernel +theorem required_origin_552_i0 : ∀ x ∈ required_552_i0, + (∃ j, x ∈ childrenC_552_i0 j) ∨ ∀ j, x ∈ childrenD_552_i0 j := by decide +kernel +theorem required_exact_552_i0 : required_552_i0 = + ((Finset.univ.biUnion childrenC_552_i0) ∪ commonEnvelope childrenD_552_i0).erase (7, 7) := by + exact required_eq_combination childrenC_552_i0 childrenD_552_i0 (7, 7) required_552_i0 + (by decide +kernel) child_required_sub_552_i0 common_sub_552_i0 required_origin_552_i0 +theorem envelope_origin_552_i0 : ∀ x ∈ envelope_552_i0, + x = (7, 7) ∨ ∃ j, x ∈ childrenD_552_i0 j := by decide +kernel +theorem envelope_exact_552_i0 : envelope_552_i0 = + insert (7, 7) (Finset.univ.biUnion childrenD_552_i0) := by + exact envelope_eq_combination childrenD_552_i0 (7, 7) envelope_552_i0 + pivot_mem_552_i0 child_envelope_sub_552_i0 envelope_origin_552_i0 +def checked_552_i0 : CheckedCard where + required := required_552_i0 + envelope := envelope_552_i0 + height := height_552_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_552_i0 +def height_552 : ℕ := 13 +def childrenH_552 : Fin 6 → ℕ := ![height_188, height_258, height_326, height_543, height_552_i0, height_551] +theorem height_exact_552 : height_552 = 1 + Finset.univ.sup childrenH_552 := by decide +kernel +theorem required_origin_552 : ∀ x ∈ required_552, + (∃ j, x ∈ childrenC_552 j) ∨ ∀ j, x ∈ childrenD_552 j := by decide +kernel +theorem required_exact_552 : required_552 = + ((Finset.univ.biUnion childrenC_552) ∪ commonEnvelope childrenD_552).erase (8, 6) := by + exact required_eq_combination childrenC_552 childrenD_552 (8, 6) required_552 + (by decide +kernel) child_required_sub_552 common_sub_552 required_origin_552 +theorem envelope_origin_552 : ∀ x ∈ envelope_552, + x = (8, 6) ∨ ∃ j, x ∈ childrenD_552 j := by decide +kernel +theorem envelope_exact_552 : envelope_552 = + insert (8, 6) (Finset.univ.biUnion childrenD_552) := by + exact envelope_eq_combination childrenD_552 (8, 6) envelope_552 + pivot_mem_552 child_envelope_sub_552 envelope_origin_552 +def checked_552 : CheckedCard where + required := required_552 + envelope := envelope_552 + height := height_552 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_552 +def height_555_i0 : ℕ := 5 +def childrenH_555_i0 : Fin 3 → ℕ := ![height_61, height_194, height_224] +theorem height_exact_555_i0 : height_555_i0 = 1 + Finset.univ.sup childrenH_555_i0 := by decide +kernel +theorem required_origin_555_i0 : ∀ x ∈ required_555_i0, + (∃ j, x ∈ childrenC_555_i0 j) ∨ ∀ j, x ∈ childrenD_555_i0 j := by decide +kernel +theorem required_exact_555_i0 : required_555_i0 = + ((Finset.univ.biUnion childrenC_555_i0) ∪ commonEnvelope childrenD_555_i0).erase (2, 2) := by + exact required_eq_combination childrenC_555_i0 childrenD_555_i0 (2, 2) required_555_i0 + (by decide +kernel) child_required_sub_555_i0 common_sub_555_i0 required_origin_555_i0 +theorem envelope_origin_555_i0 : ∀ x ∈ envelope_555_i0, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_555_i0 j := by decide +kernel +theorem envelope_exact_555_i0 : envelope_555_i0 = + insert (2, 2) (Finset.univ.biUnion childrenD_555_i0) := by + exact envelope_eq_combination childrenD_555_i0 (2, 2) envelope_555_i0 + pivot_mem_555_i0 child_envelope_sub_555_i0 envelope_origin_555_i0 +def checked_555_i0 : CheckedCard where + required := required_555_i0 + envelope := envelope_555_i0 + height := height_555_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_555_i0 +def height_555 : ℕ := 13 +def childrenH_555 : Fin 7 → ℕ := ![height_13, height_14, height_31, height_230, height_367, height_428, height_555_i0] +theorem height_exact_555 : height_555 = 1 + Finset.univ.sup childrenH_555 := by decide +kernel +theorem required_origin_555 : ∀ x ∈ required_555, + (∃ j, x ∈ childrenC_555 j) ∨ ∀ j, x ∈ childrenD_555 j := by decide +kernel +theorem required_exact_555 : required_555 = + ((Finset.univ.biUnion childrenC_555) ∪ commonEnvelope childrenD_555).erase (3, 3) := by + exact required_eq_combination childrenC_555 childrenD_555 (3, 3) required_555 + (by decide +kernel) child_required_sub_555 common_sub_555 required_origin_555 +theorem envelope_origin_555 : ∀ x ∈ envelope_555, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_555 j := by decide +kernel +theorem envelope_exact_555 : envelope_555 = + insert (3, 3) (Finset.univ.biUnion childrenD_555) := by + exact envelope_eq_combination childrenD_555 (3, 3) envelope_555 + pivot_mem_555 child_envelope_sub_555 envelope_origin_555 +def checked_555 : CheckedCard where + required := required_555 + envelope := envelope_555 + height := height_555 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_555 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part02.lean new file mode 100644 index 0000000..f6fed48 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part02.lean @@ -0,0 +1,961 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_564_i2 : Finset Cell := ⟨(([(3, 4), (4, 4), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_564_i2 : Finset Cell := ⟨(([(1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_564_i2 : Fin 2 → Finset Cell := ![(placed21 0 (2, 4) required_5), (placed21 2 (5, 3) required_453)] +def childrenD_564_i2 : Fin 2 → Finset Cell := ![(placed21 0 (2, 4) envelope_5), (placed21 2 (5, 3) envelope_453)] +theorem common_sub_564_i2 : commonEnvelope childrenD_564_i2 ⊆ insert (2, 4) required_564_i2 := by decide +kernel +theorem child_required_sub_564_i2 : ∀ j, childrenC_564_i2 j ⊆ insert (2, 4) required_564_i2 := by decide +kernel +theorem child_envelope_sub_564_i2 : ∀ j, childrenD_564_i2 j ⊆ envelope_564_i2 := by decide +kernel +theorem pivot_mem_564_i2 : (2, 4) ∈ envelope_564_i2 := by decide +kernel +theorem children_work_564_i2 : ∀ j, Template HasSnaky 7 (childrenC_564_i2 j) (childrenD_564_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_453 2 (5, 3)).mono (by decide +kernel) +theorem row_works_564_i2 : Template HasSnaky 8 required_564_i2 envelope_564_i2 := by + refine compose HasSnaky 7 childrenC_564_i2 childrenD_564_i2 children_work_564_i2 (2, 4) + required_564_i2 envelope_564_i2 pivot_mem_564_i2 child_required_sub_564_i2 child_envelope_sub_564_i2 ?_ + intro b hb + exact common_sub_564_i2 (mem_commonEnvelope childrenD_564_i2 b hb) +def required_564_i7 : Finset Cell := ⟨(([(2, 5), (3, 4), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_564_i7 : Finset Cell := ⟨(([(1, 6), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 5), (5, 5), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_564_i7 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) required_5), (placed21 2 (5, 2) required_55)] +def childrenD_564_i7 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) envelope_5), (placed21 2 (5, 2) envelope_55)] +theorem common_sub_564_i7 : commonEnvelope childrenD_564_i7 ⊆ insert (3, 5) required_564_i7 := by decide +kernel +theorem child_required_sub_564_i7 : ∀ j, childrenC_564_i7 j ⊆ insert (3, 5) required_564_i7 := by decide +kernel +theorem child_envelope_sub_564_i7 : ∀ j, childrenD_564_i7 j ⊆ envelope_564_i7 := by decide +kernel +theorem pivot_mem_564_i7 : (3, 5) ∈ envelope_564_i7 := by decide +kernel +theorem children_work_564_i7 : ∀ j, Template HasSnaky 4 (childrenC_564_i7 j) (childrenD_564_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_55 2 (5, 2)).mono (by decide +kernel) +theorem row_works_564_i7 : Template HasSnaky 5 required_564_i7 envelope_564_i7 := by + refine compose HasSnaky 4 childrenC_564_i7 childrenD_564_i7 children_work_564_i7 (3, 5) + required_564_i7 envelope_564_i7 pivot_mem_564_i7 child_required_sub_564_i7 child_envelope_sub_564_i7 ?_ + intro b hb + exact common_sub_564_i7 (mem_commonEnvelope childrenD_564_i7 b hb) +def required_564_i8 : Finset Cell := ⟨(([(2, 5), (3, 4), (4, 4), (4, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_564_i8 : Finset Cell := ⟨(([(1, 3), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 3), (3, 4), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_564_i8 : Fin 2 → Finset Cell := ![(placed21 2 (5, 4) required_5), (placed21 2 (5, 2) required_342)] +def childrenD_564_i8 : Fin 2 → Finset Cell := ![(placed21 2 (5, 4) envelope_5), (placed21 2 (5, 2) envelope_342)] +theorem common_sub_564_i8 : commonEnvelope childrenD_564_i8 ⊆ insert (2, 4) required_564_i8 := by decide +kernel +theorem child_required_sub_564_i8 : ∀ j, childrenC_564_i8 j ⊆ insert (2, 4) required_564_i8 := by decide +kernel +theorem child_envelope_sub_564_i8 : ∀ j, childrenD_564_i8 j ⊆ envelope_564_i8 := by decide +kernel +theorem pivot_mem_564_i8 : (2, 4) ∈ envelope_564_i8 := by decide +kernel +theorem children_work_564_i8 : ∀ j, Template HasSnaky 5 (childrenC_564_i8 j) (childrenD_564_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_342 2 (5, 2)).mono (by decide +kernel) +theorem row_works_564_i8 : Template HasSnaky 6 required_564_i8 envelope_564_i8 := by + refine compose HasSnaky 5 childrenC_564_i8 childrenD_564_i8 children_work_564_i8 (2, 4) + required_564_i8 envelope_564_i8 pivot_mem_564_i8 child_required_sub_564_i8 child_envelope_sub_564_i8 ?_ + intro b hb + exact common_sub_564_i8 (mem_commonEnvelope childrenD_564_i8 b hb) +def required_564_i6 : Finset Cell := ⟨(([(3, 4), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_564_i6 : Finset Cell := ⟨(([(1, 3), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_564_i6 : Fin 3 → Finset Cell := ![(placed21 5 (6, 4) required_102), required_564_i7, required_564_i8] +def childrenD_564_i6 : Fin 3 → Finset Cell := ![(placed21 5 (6, 4) envelope_102), envelope_564_i7, envelope_564_i8] +theorem common_sub_564_i6 : commonEnvelope childrenD_564_i6 ⊆ insert (2, 5) required_564_i6 := by decide +kernel +theorem child_required_sub_564_i6 : ∀ j, childrenC_564_i6 j ⊆ insert (2, 5) required_564_i6 := by decide +kernel +theorem child_envelope_sub_564_i6 : ∀ j, childrenD_564_i6 j ⊆ envelope_564_i6 := by decide +kernel +theorem pivot_mem_564_i6 : (2, 5) ∈ envelope_564_i6 := by decide +kernel +theorem children_work_564_i6 : ∀ j, Template HasSnaky 6 (childrenC_564_i6 j) (childrenD_564_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_102 5 (6, 4)).mono (by decide +kernel) + · exact row_works_564_i7.mono (by decide +kernel) + · exact row_works_564_i8.mono (by decide +kernel) +theorem row_works_564_i6 : Template HasSnaky 7 required_564_i6 envelope_564_i6 := by + refine compose HasSnaky 6 childrenC_564_i6 childrenD_564_i6 children_work_564_i6 (2, 5) + required_564_i6 envelope_564_i6 pivot_mem_564_i6 child_required_sub_564_i6 child_envelope_sub_564_i6 ?_ + intro b hb + exact common_sub_564_i6 (mem_commonEnvelope childrenD_564_i6 b hb) +def required_564_i5 : Finset Cell := ⟨(([(3, 4), (4, 4), (5, 4), (5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_564_i5 : Finset Cell := ⟨(([(1, 3), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_564_i5 : Fin 2 → Finset Cell := ![(placed21 7 (5, 8) required_0), required_564_i6] +def childrenD_564_i5 : Fin 2 → Finset Cell := ![(placed21 7 (5, 8) envelope_0), envelope_564_i6] +theorem common_sub_564_i5 : commonEnvelope childrenD_564_i5 ⊆ insert (4, 5) required_564_i5 := by decide +kernel +theorem child_required_sub_564_i5 : ∀ j, childrenC_564_i5 j ⊆ insert (4, 5) required_564_i5 := by decide +kernel +theorem child_envelope_sub_564_i5 : ∀ j, childrenD_564_i5 j ⊆ envelope_564_i5 := by decide +kernel +theorem pivot_mem_564_i5 : (4, 5) ∈ envelope_564_i5 := by decide +kernel +theorem children_work_564_i5 : ∀ j, Template HasSnaky 7 (childrenC_564_i5 j) (childrenD_564_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (5, 8)).mono (by decide +kernel) + · exact row_works_564_i6.mono (by decide +kernel) +theorem row_works_564_i5 : Template HasSnaky 8 required_564_i5 envelope_564_i5 := by + refine compose HasSnaky 7 childrenC_564_i5 childrenD_564_i5 children_work_564_i5 (4, 5) + required_564_i5 envelope_564_i5 pivot_mem_564_i5 child_required_sub_564_i5 child_envelope_sub_564_i5 ?_ + intro b hb + exact common_sub_564_i5 (mem_commonEnvelope childrenD_564_i5 b hb) +def required_564_i4 : Finset Cell := ⟨(([(3, 4), (4, 4), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_564_i4 : Finset Cell := ⟨(([(1, 3), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_564_i4 : Fin 3 → Finset Cell := ![(placed21 2 (5, 4) required_16), (placed21 6 (6, 8) required_235), required_564_i5] +def childrenD_564_i4 : Fin 3 → Finset Cell := ![(placed21 2 (5, 4) envelope_16), (placed21 6 (6, 8) envelope_235), envelope_564_i5] +theorem common_sub_564_i4 : commonEnvelope childrenD_564_i4 ⊆ insert (5, 7) required_564_i4 := by decide +kernel +theorem child_required_sub_564_i4 : ∀ j, childrenC_564_i4 j ⊆ insert (5, 7) required_564_i4 := by decide +kernel +theorem child_envelope_sub_564_i4 : ∀ j, childrenD_564_i4 j ⊆ envelope_564_i4 := by decide +kernel +theorem pivot_mem_564_i4 : (5, 7) ∈ envelope_564_i4 := by decide +kernel +theorem children_work_564_i4 : ∀ j, Template HasSnaky 8 (childrenC_564_i4 j) (childrenD_564_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_16 2 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_235 6 (6, 8)).mono (by decide +kernel) + · exact row_works_564_i5.mono (by decide +kernel) +theorem row_works_564_i4 : Template HasSnaky 9 required_564_i4 envelope_564_i4 := by + refine compose HasSnaky 8 childrenC_564_i4 childrenD_564_i4 children_work_564_i4 (5, 7) + required_564_i4 envelope_564_i4 pivot_mem_564_i4 child_required_sub_564_i4 child_envelope_sub_564_i4 ?_ + intro b hb + exact common_sub_564_i4 (mem_commonEnvelope childrenD_564_i4 b hb) +def required_564_i3 : Finset Cell := ⟨(([(3, 4), (4, 4), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_564_i3 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_564_i3 : Fin 7 → Finset Cell := ![(placed21 2 (6, 2) required_67), (placed21 5 (7, 3) required_134), (placed21 5 (7, 3) required_180), (placed21 7 (9, 7) required_327), (placed21 0 (2, 2) required_504), (placed21 5 (7, 4) required_558), required_564_i4] +def childrenD_564_i3 : Fin 7 → Finset Cell := ![(placed21 2 (6, 2) envelope_67), (placed21 5 (7, 3) envelope_134), (placed21 5 (7, 3) envelope_180), (placed21 7 (9, 7) envelope_327), (placed21 0 (2, 2) envelope_504), (placed21 5 (7, 4) envelope_558), envelope_564_i4] +theorem common_sub_564_i3 : commonEnvelope childrenD_564_i3 ⊆ insert (5, 6) required_564_i3 := by decide +kernel +theorem child_required_sub_564_i3 : ∀ j, childrenC_564_i3 j ⊆ insert (5, 6) required_564_i3 := by decide +kernel +theorem child_envelope_sub_564_i3 : ∀ j, childrenD_564_i3 j ⊆ envelope_564_i3 := by decide +kernel +theorem pivot_mem_564_i3 : (5, 6) ∈ envelope_564_i3 := by decide +kernel +theorem children_work_564_i3 : ∀ j, Template HasSnaky 9 (childrenC_564_i3 j) (childrenD_564_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_67 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_134 5 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_180 5 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_327 7 (9, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_504 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_558 5 (7, 4)).mono (by decide +kernel) + · exact row_works_564_i4.mono (by decide +kernel) +theorem row_works_564_i3 : Template HasSnaky 10 required_564_i3 envelope_564_i3 := by + refine compose HasSnaky 9 childrenC_564_i3 childrenD_564_i3 children_work_564_i3 (5, 6) + required_564_i3 envelope_564_i3 pivot_mem_564_i3 child_required_sub_564_i3 child_envelope_sub_564_i3 ?_ + intro b hb + exact common_sub_564_i3 (mem_commonEnvelope childrenD_564_i3 b hb) +def required_564_i1 : Finset Cell := ⟨(([(3, 4), (4, 1), (4, 2), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_564_i1 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 5), (8, 6), (8, 7), (9, 5), (9, 6), (9, 7), (10, 5), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_564_i1 : Fin 5 → Finset Cell := ![(placed21 1 (2, 4) required_44), required_564_i2, required_564_i3, (placed21 1 (1, 1) required_560), (placed21 1 (0, 3) required_563)] +def childrenD_564_i1 : Fin 5 → Finset Cell := ![(placed21 1 (2, 4) envelope_44), envelope_564_i2, envelope_564_i3, (placed21 1 (1, 1) envelope_560), (placed21 1 (0, 3) envelope_563)] +theorem common_sub_564_i1 : commonEnvelope childrenD_564_i1 ⊆ insert (5, 5) required_564_i1 := by decide +kernel +theorem child_required_sub_564_i1 : ∀ j, childrenC_564_i1 j ⊆ insert (5, 5) required_564_i1 := by decide +kernel +theorem child_envelope_sub_564_i1 : ∀ j, childrenD_564_i1 j ⊆ envelope_564_i1 := by decide +kernel +theorem pivot_mem_564_i1 : (5, 5) ∈ envelope_564_i1 := by decide +kernel +theorem children_work_564_i1 : ∀ j, Template HasSnaky 10 (childrenC_564_i1 j) (childrenD_564_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 1 (2, 4)).mono (by decide +kernel) + · exact row_works_564_i2.mono (by decide +kernel) + · exact row_works_564_i3.mono (by decide +kernel) + · exact (placed21_template row_works_560 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_563 1 (0, 3)).mono (by decide +kernel) +theorem row_works_564_i1 : Template HasSnaky 11 required_564_i1 envelope_564_i1 := by + refine compose HasSnaky 10 childrenC_564_i1 childrenD_564_i1 children_work_564_i1 (5, 5) + required_564_i1 envelope_564_i1 pivot_mem_564_i1 child_required_sub_564_i1 child_envelope_sub_564_i1 ?_ + intro b hb + exact common_sub_564_i1 (mem_commonEnvelope childrenD_564_i1 b hb) +def required_564_i0 : Finset Cell := ⟨(([(3, 4), (4, 1), (4, 2), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_564_i0 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 3), (8, 5), (8, 6), (8, 7), (9, 5), (9, 6), (9, 7), (10, 5), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_564_i0 : Fin 6 → Finset Cell := ![(placed21 1 (1, 3) required_12), (placed21 3 (1, 5) required_12), (placed21 1 (2, 1) required_79), (placed21 1 (1, 2) required_135), (placed21 3 (1, 6) required_182), required_564_i1] +def childrenD_564_i0 : Fin 6 → Finset Cell := ![(placed21 1 (1, 3) envelope_12), (placed21 3 (1, 5) envelope_12), (placed21 1 (2, 1) envelope_79), (placed21 1 (1, 2) envelope_135), (placed21 3 (1, 6) envelope_182), envelope_564_i1] +theorem common_sub_564_i0 : commonEnvelope childrenD_564_i0 ⊆ insert (5, 4) required_564_i0 := by decide +kernel +theorem child_required_sub_564_i0 : ∀ j, childrenC_564_i0 j ⊆ insert (5, 4) required_564_i0 := by decide +kernel +theorem child_envelope_sub_564_i0 : ∀ j, childrenD_564_i0 j ⊆ envelope_564_i0 := by decide +kernel +theorem pivot_mem_564_i0 : (5, 4) ∈ envelope_564_i0 := by decide +kernel +theorem children_work_564_i0 : ∀ j, Template HasSnaky 11 (childrenC_564_i0 j) (childrenD_564_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_12 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_79 1 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_135 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_182 3 (1, 6)).mono (by decide +kernel) + · exact row_works_564_i1.mono (by decide +kernel) +theorem row_works_564_i0 : Template HasSnaky 12 required_564_i0 envelope_564_i0 := by + refine compose HasSnaky 11 childrenC_564_i0 childrenD_564_i0 children_work_564_i0 (5, 4) + required_564_i0 envelope_564_i0 pivot_mem_564_i0 child_required_sub_564_i0 child_envelope_sub_564_i0 ?_ + intro b hb + exact common_sub_564_i0 (mem_commonEnvelope childrenD_564_i0 b hb) +def required_564 : Finset Cell := ⟨(([(1, 1), (1, 2), (3, 4), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_564 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (1, 1), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 3), (8, 5), (8, 6), (8, 7), (9, 5), (9, 6), (9, 7), (10, 5), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_564 : Fin 4 → Finset Cell := ![(placed21 1 (1, 1) required_119), (placed21 2 (4, 0) required_497), required_498, required_564_i0] +def childrenD_564 : Fin 4 → Finset Cell := ![(placed21 1 (1, 1) envelope_119), (placed21 2 (4, 0) envelope_497), envelope_498, envelope_564_i0] +theorem common_sub_564 : commonEnvelope childrenD_564 ⊆ insert (4, 4) required_564 := by decide +kernel +theorem child_required_sub_564 : ∀ j, childrenC_564 j ⊆ insert (4, 4) required_564 := by decide +kernel +theorem child_envelope_sub_564 : ∀ j, childrenD_564 j ⊆ envelope_564 := by decide +kernel +theorem pivot_mem_564 : (4, 4) ∈ envelope_564 := by decide +kernel +theorem children_work_564 : ∀ j, Template HasSnaky 12 (childrenC_564 j) (childrenD_564 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_119 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_497 2 (4, 0)).mono (by decide +kernel) + · exact row_works_498.mono (by decide +kernel) + · exact row_works_564_i0.mono (by decide +kernel) +theorem row_works_564 : Template HasSnaky 13 required_564 envelope_564 := by + refine compose HasSnaky 12 childrenC_564 childrenD_564 children_work_564 (4, 4) + required_564 envelope_564 pivot_mem_564 child_required_sub_564 child_envelope_sub_564 ?_ + intro b hb + exact common_sub_564 (mem_commonEnvelope childrenD_564 b hb) +def required_568_i0 : Finset Cell := ⟨(([(1, 1), (1, 2), (3, 4), (4, 1), (4, 2), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_568_i0 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (1, 1), (1, 2), (1, 4), (1, 5), (2, 1), (2, 3), (2, 4), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_568_i0 : Fin 2 → Finset Cell := ![(placed21 5 (7, 1) required_255), (placed21 2 (4, 0) required_496)] +def childrenD_568_i0 : Fin 2 → Finset Cell := ![(placed21 5 (7, 1) envelope_255), (placed21 2 (4, 0) envelope_496)] +theorem common_sub_568_i0 : commonEnvelope childrenD_568_i0 ⊆ insert (4, 3) required_568_i0 := by decide +kernel +theorem child_required_sub_568_i0 : ∀ j, childrenC_568_i0 j ⊆ insert (4, 3) required_568_i0 := by decide +kernel +theorem child_envelope_sub_568_i0 : ∀ j, childrenD_568_i0 j ⊆ envelope_568_i0 := by decide +kernel +theorem pivot_mem_568_i0 : (4, 3) ∈ envelope_568_i0 := by decide +kernel +theorem children_work_568_i0 : ∀ j, Template HasSnaky 6 (childrenC_568_i0 j) (childrenD_568_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_255 5 (7, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_496 2 (4, 0)).mono (by decide +kernel) +theorem row_works_568_i0 : Template HasSnaky 7 required_568_i0 envelope_568_i0 := by + refine compose HasSnaky 6 childrenC_568_i0 childrenD_568_i0 children_work_568_i0 (4, 3) + required_568_i0 envelope_568_i0 pivot_mem_568_i0 child_required_sub_568_i0 child_envelope_sub_568_i0 ?_ + intro b hb + exact common_sub_568_i0 (mem_commonEnvelope childrenD_568_i0 b hb) +def required_568_i3 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 1), (4, 2), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_568_i3 : Finset Cell := ⟨(([(2, 3), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 4), (4, 5), (5, 4), (6, 3), (6, 4), (7, 3), (7, 4), (8, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_568_i3 : Fin 2 → Finset Cell := ![(placed21 4 (3, 5) required_24), (placed21 3 (2, 5) required_77)] +def childrenD_568_i3 : Fin 2 → Finset Cell := ![(placed21 4 (3, 5) envelope_24), (placed21 3 (2, 5) envelope_77)] +theorem common_sub_568_i3 : commonEnvelope childrenD_568_i3 ⊆ insert (6, 4) required_568_i3 := by decide +kernel +theorem child_required_sub_568_i3 : ∀ j, childrenC_568_i3 j ⊆ insert (6, 4) required_568_i3 := by decide +kernel +theorem child_envelope_sub_568_i3 : ∀ j, childrenD_568_i3 j ⊆ envelope_568_i3 := by decide +kernel +theorem pivot_mem_568_i3 : (6, 4) ∈ envelope_568_i3 := by decide +kernel +theorem children_work_568_i3 : ∀ j, Template HasSnaky 3 (childrenC_568_i3 j) (childrenD_568_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_24 4 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_77 3 (2, 5)).mono (by decide +kernel) +theorem row_works_568_i3 : Template HasSnaky 4 required_568_i3 envelope_568_i3 := by + refine compose HasSnaky 3 childrenC_568_i3 childrenD_568_i3 children_work_568_i3 (6, 4) + required_568_i3 envelope_568_i3 pivot_mem_568_i3 child_required_sub_568_i3 child_envelope_sub_568_i3 ?_ + intro b hb + exact common_sub_568_i3 (mem_commonEnvelope childrenD_568_i3 b hb) +def required_568_i6 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_568_i6 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 6), (4, 7), (4, 8), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_568_i6 : Fin 2 → Finset Cell := ![(placed21 0 (3, 3) required_6), (placed21 5 (5, 3) required_132)] +def childrenD_568_i6 : Fin 2 → Finset Cell := ![(placed21 0 (3, 3) envelope_6), (placed21 5 (5, 3) envelope_132)] +theorem common_sub_568_i6 : commonEnvelope childrenD_568_i6 ⊆ insert (3, 7) required_568_i6 := by decide +kernel +theorem child_required_sub_568_i6 : ∀ j, childrenC_568_i6 j ⊆ insert (3, 7) required_568_i6 := by decide +kernel +theorem child_envelope_sub_568_i6 : ∀ j, childrenD_568_i6 j ⊆ envelope_568_i6 := by decide +kernel +theorem pivot_mem_568_i6 : (3, 7) ∈ envelope_568_i6 := by decide +kernel +theorem children_work_568_i6 : ∀ j, Template HasSnaky 4 (childrenC_568_i6 j) (childrenD_568_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_132 5 (5, 3)).mono (by decide +kernel) +theorem row_works_568_i6 : Template HasSnaky 5 required_568_i6 envelope_568_i6 := by + refine compose HasSnaky 4 childrenC_568_i6 childrenD_568_i6 children_work_568_i6 (3, 7) + required_568_i6 envelope_568_i6 pivot_mem_568_i6 child_required_sub_568_i6 child_envelope_sub_568_i6 ?_ + intro b hb + exact common_sub_568_i6 (mem_commonEnvelope childrenD_568_i6 b hb) +def required_568_i7 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_568_i7 : Finset Cell := ⟨(([(2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_568_i7 : Fin 2 → Finset Cell := ![(placed21 2 (3, 3) required_6), (placed21 2 (4, 3) required_124)] +def childrenD_568_i7 : Fin 2 → Finset Cell := ![(placed21 2 (3, 3) envelope_6), (placed21 2 (4, 3) envelope_124)] +theorem common_sub_568_i7 : commonEnvelope childrenD_568_i7 ⊆ insert (3, 7) required_568_i7 := by decide +kernel +theorem child_required_sub_568_i7 : ∀ j, childrenC_568_i7 j ⊆ insert (3, 7) required_568_i7 := by decide +kernel +theorem child_envelope_sub_568_i7 : ∀ j, childrenD_568_i7 j ⊆ envelope_568_i7 := by decide +kernel +theorem pivot_mem_568_i7 : (3, 7) ∈ envelope_568_i7 := by decide +kernel +theorem children_work_568_i7 : ∀ j, Template HasSnaky 3 (childrenC_568_i7 j) (childrenD_568_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 2 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_124 2 (4, 3)).mono (by decide +kernel) +theorem row_works_568_i7 : Template HasSnaky 4 required_568_i7 envelope_568_i7 := by + refine compose HasSnaky 3 childrenC_568_i7 childrenD_568_i7 children_work_568_i7 (3, 7) + required_568_i7 envelope_568_i7 pivot_mem_568_i7 child_required_sub_568_i7 child_envelope_sub_568_i7 ?_ + intro b hb + exact common_sub_568_i7 (mem_commonEnvelope childrenD_568_i7 b hb) +def required_568_i5 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_568_i5 : Finset Cell := ⟨(([(0, 5), (0, 6), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_568_i5 : Fin 4 → Finset Cell := ![(placed21 5 (4, 3) required_8), (placed21 2 (5, 3) required_387), required_568_i6, required_568_i7] +def childrenD_568_i5 : Fin 4 → Finset Cell := ![(placed21 5 (4, 3) envelope_8), (placed21 2 (5, 3) envelope_387), envelope_568_i6, envelope_568_i7] +theorem common_sub_568_i5 : commonEnvelope childrenD_568_i5 ⊆ insert (3, 6) required_568_i5 := by decide +kernel +theorem child_required_sub_568_i5 : ∀ j, childrenC_568_i5 j ⊆ insert (3, 6) required_568_i5 := by decide +kernel +theorem child_envelope_sub_568_i5 : ∀ j, childrenD_568_i5 j ⊆ envelope_568_i5 := by decide +kernel +theorem pivot_mem_568_i5 : (3, 6) ∈ envelope_568_i5 := by decide +kernel +theorem children_work_568_i5 : ∀ j, Template HasSnaky 6 (childrenC_568_i5 j) (childrenD_568_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 5 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_387 2 (5, 3)).mono (by decide +kernel) + · exact row_works_568_i6.mono (by decide +kernel) + · exact row_works_568_i7.mono (by decide +kernel) +theorem row_works_568_i5 : Template HasSnaky 7 required_568_i5 envelope_568_i5 := by + refine compose HasSnaky 6 childrenC_568_i5 childrenD_568_i5 children_work_568_i5 (3, 6) + required_568_i5 envelope_568_i5 pivot_mem_568_i5 child_required_sub_568_i5 child_envelope_sub_568_i5 ?_ + intro b hb + exact common_sub_568_i5 (mem_commonEnvelope childrenD_568_i5 b hb) +def required_568_i4 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 1), (4, 2), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_568_i4 : Finset Cell := ⟨(([(0, 5), (0, 6), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_568_i4 : Fin 2 → Finset Cell := ![(placed21 3 (3, 5) required_3), required_568_i5] +def childrenD_568_i4 : Fin 2 → Finset Cell := ![(placed21 3 (3, 5) envelope_3), envelope_568_i5] +theorem common_sub_568_i4 : commonEnvelope childrenD_568_i4 ⊆ insert (3, 3) required_568_i4 := by decide +kernel +theorem child_required_sub_568_i4 : ∀ j, childrenC_568_i4 j ⊆ insert (3, 3) required_568_i4 := by decide +kernel +theorem child_envelope_sub_568_i4 : ∀ j, childrenD_568_i4 j ⊆ envelope_568_i4 := by decide +kernel +theorem pivot_mem_568_i4 : (3, 3) ∈ envelope_568_i4 := by decide +kernel +theorem children_work_568_i4 : ∀ j, Template HasSnaky 7 (childrenC_568_i4 j) (childrenD_568_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 3 (3, 5)).mono (by decide +kernel) + · exact row_works_568_i5.mono (by decide +kernel) +theorem row_works_568_i4 : Template HasSnaky 8 required_568_i4 envelope_568_i4 := by + refine compose HasSnaky 7 childrenC_568_i4 childrenD_568_i4 children_work_568_i4 (3, 3) + required_568_i4 envelope_568_i4 pivot_mem_568_i4 child_required_sub_568_i4 child_envelope_sub_568_i4 ?_ + intro b hb + exact common_sub_568_i4 (mem_commonEnvelope childrenD_568_i4 b hb) +def required_568_i2 : Finset Cell := ⟨(([(3, 4), (4, 1), (4, 2), (4, 4), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_568_i2 : Finset Cell := ⟨(([(0, 5), (0, 6), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (6, 3), (6, 4), (7, 3), (7, 4), (8, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_568_i2 : Fin 3 → Finset Cell := ![(placed21 5 (6, 4) required_52), required_568_i3, required_568_i4] +def childrenD_568_i2 : Fin 3 → Finset Cell := ![(placed21 5 (6, 4) envelope_52), envelope_568_i3, envelope_568_i4] +theorem common_sub_568_i2 : commonEnvelope childrenD_568_i2 ⊆ insert (3, 5) required_568_i2 := by decide +kernel +theorem child_required_sub_568_i2 : ∀ j, childrenC_568_i2 j ⊆ insert (3, 5) required_568_i2 := by decide +kernel +theorem child_envelope_sub_568_i2 : ∀ j, childrenD_568_i2 j ⊆ envelope_568_i2 := by decide +kernel +theorem pivot_mem_568_i2 : (3, 5) ∈ envelope_568_i2 := by decide +kernel +theorem children_work_568_i2 : ∀ j, Template HasSnaky 8 (childrenC_568_i2 j) (childrenD_568_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 5 (6, 4)).mono (by decide +kernel) + · exact row_works_568_i3.mono (by decide +kernel) + · exact row_works_568_i4.mono (by decide +kernel) +theorem row_works_568_i2 : Template HasSnaky 9 required_568_i2 envelope_568_i2 := by + refine compose HasSnaky 8 childrenC_568_i2 childrenD_568_i2 children_work_568_i2 (3, 5) + required_568_i2 envelope_568_i2 pivot_mem_568_i2 child_required_sub_568_i2 child_envelope_sub_568_i2 ?_ + intro b hb + exact common_sub_568_i2 (mem_commonEnvelope childrenD_568_i2 b hb) +def required_568_i1 : Finset Cell := ⟨(([(3, 4), (4, 1), (4, 2), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_568_i1 : Finset Cell := ⟨(([(0, 5), (0, 6), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (9, 4), (9, 5), (9, 6), (9, 7), (10, 5), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_568_i1 : Fin 6 → Finset Cell := ![(placed21 1 (2, 1) required_79), (placed21 3 (1, 5) required_189), (placed21 3 (0, 7) required_518), required_568_i2, (placed21 4 (1, 7) required_565), (placed21 1 (0, 1) required_567)] +def childrenD_568_i1 : Fin 6 → Finset Cell := ![(placed21 1 (2, 1) envelope_79), (placed21 3 (1, 5) envelope_189), (placed21 3 (0, 7) envelope_518), envelope_568_i2, (placed21 4 (1, 7) envelope_565), (placed21 1 (0, 1) envelope_567)] +theorem common_sub_568_i1 : commonEnvelope childrenD_568_i1 ⊆ insert (5, 4) required_568_i1 := by decide +kernel +theorem child_required_sub_568_i1 : ∀ j, childrenC_568_i1 j ⊆ insert (5, 4) required_568_i1 := by decide +kernel +theorem child_envelope_sub_568_i1 : ∀ j, childrenD_568_i1 j ⊆ envelope_568_i1 := by decide +kernel +theorem pivot_mem_568_i1 : (5, 4) ∈ envelope_568_i1 := by decide +kernel +theorem children_work_568_i1 : ∀ j, Template HasSnaky 11 (childrenC_568_i1 j) (childrenD_568_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_79 1 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_189 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_518 3 (0, 7)).mono (by decide +kernel) + · exact row_works_568_i2.mono (by decide +kernel) + · exact (placed21_template row_works_565 4 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_567 1 (0, 1)).mono (by decide +kernel) +theorem row_works_568_i1 : Template HasSnaky 12 required_568_i1 envelope_568_i1 := by + refine compose HasSnaky 11 childrenC_568_i1 childrenD_568_i1 children_work_568_i1 (5, 4) + required_568_i1 envelope_568_i1 pivot_mem_568_i1 child_required_sub_568_i1 child_envelope_sub_568_i1 ?_ + intro b hb + exact common_sub_568_i1 (mem_commonEnvelope childrenD_568_i1 b hb) +def required_568 : Finset Cell := ⟨(([(1, 1), (1, 2), (3, 4), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_568 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 4), (0, 5), (0, 6), (1, 1), (1, 2), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (9, 4), (9, 5), (9, 6), (9, 7), (10, 5), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_568 : Fin 4 → Finset Cell := ![(placed21 1 (1, 1) required_110), (placed21 2 (4, 0) required_497), required_568_i0, required_568_i1] +def childrenD_568 : Fin 4 → Finset Cell := ![(placed21 1 (1, 1) envelope_110), (placed21 2 (4, 0) envelope_497), envelope_568_i0, envelope_568_i1] +theorem common_sub_568 : commonEnvelope childrenD_568 ⊆ insert (4, 4) required_568 := by decide +kernel +theorem child_required_sub_568 : ∀ j, childrenC_568 j ⊆ insert (4, 4) required_568 := by decide +kernel +theorem child_envelope_sub_568 : ∀ j, childrenD_568 j ⊆ envelope_568 := by decide +kernel +theorem pivot_mem_568 : (4, 4) ∈ envelope_568 := by decide +kernel +theorem children_work_568 : ∀ j, Template HasSnaky 12 (childrenC_568 j) (childrenD_568 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_110 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_497 2 (4, 0)).mono (by decide +kernel) + · exact row_works_568_i0.mono (by decide +kernel) + · exact row_works_568_i1.mono (by decide +kernel) +theorem row_works_568 : Template HasSnaky 13 required_568 envelope_568 := by + refine compose HasSnaky 12 childrenC_568 childrenD_568 children_work_568 (4, 4) + required_568 envelope_568 pivot_mem_568 child_required_sub_568 child_envelope_sub_568 ?_ + intro b hb + exact common_sub_568 (mem_commonEnvelope childrenD_568 b hb) +def required_572_i0 : Finset Cell := ⟨(([(1, 6), (1, 7), (3, 3), (3, 4), (3, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_572_i0 : Finset Cell := ⟨(([(0, 7), (1, 6), (1, 7), (2, 6), (3, 3), (3, 4), (3, 6), (4, 4), (4, 5), (4, 6), (4, 7), (5, 5), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_572_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 6) required_5), (placed21 4 (1, 7) required_78)] +def childrenD_572_i0 : Fin 2 → Finset Cell := ![(placed21 2 (4, 6) envelope_5), (placed21 4 (1, 7) envelope_78)] +theorem common_sub_572_i0 : commonEnvelope childrenD_572_i0 ⊆ insert (2, 6) required_572_i0 := by decide +kernel +theorem child_required_sub_572_i0 : ∀ j, childrenC_572_i0 j ⊆ insert (2, 6) required_572_i0 := by decide +kernel +theorem child_envelope_sub_572_i0 : ∀ j, childrenD_572_i0 j ⊆ envelope_572_i0 := by decide +kernel +theorem pivot_mem_572_i0 : (2, 6) ∈ envelope_572_i0 := by decide +kernel +theorem children_work_572_i0 : ∀ j, Template HasSnaky 3 (childrenC_572_i0 j) (childrenD_572_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_78 4 (1, 7)).mono (by decide +kernel) +theorem row_works_572_i0 : Template HasSnaky 4 required_572_i0 envelope_572_i0 := by + refine compose HasSnaky 3 childrenC_572_i0 childrenD_572_i0 children_work_572_i0 (2, 6) + required_572_i0 envelope_572_i0 pivot_mem_572_i0 child_required_sub_572_i0 child_envelope_sub_572_i0 ?_ + intro b hb + exact common_sub_572_i0 (mem_commonEnvelope childrenD_572_i0 b hb) +def required_572 : Finset Cell := ⟨(([(0, 3), (1, 6), (1, 7), (3, 3), (3, 4), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_572 : Finset Cell := ⟨(([(0, 3), (0, 7), (1, 3), (1, 6), (1, 7), (2, 3), (2, 6), (2, 7), (3, 3), (3, 4), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_572 : Fin 4 → Finset Cell := ![(placed21 3 (0, 7) required_97), (placed21 1 (0, 6) required_98), required_572_i0, required_571] +def childrenD_572 : Fin 4 → Finset Cell := ![(placed21 3 (0, 7) envelope_97), (placed21 1 (0, 6) envelope_98), envelope_572_i0, envelope_571] +theorem common_sub_572 : commonEnvelope childrenD_572 ⊆ insert (4, 6) required_572 := by decide +kernel +theorem child_required_sub_572 : ∀ j, childrenC_572 j ⊆ insert (4, 6) required_572 := by decide +kernel +theorem child_envelope_sub_572 : ∀ j, childrenD_572 j ⊆ envelope_572 := by decide +kernel +theorem pivot_mem_572 : (4, 6) ∈ envelope_572 := by decide +kernel +theorem children_work_572 : ∀ j, Template HasSnaky 12 (childrenC_572 j) (childrenD_572 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_97 3 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_98 1 (0, 6)).mono (by decide +kernel) + · exact row_works_572_i0.mono (by decide +kernel) + · exact row_works_571.mono (by decide +kernel) +theorem row_works_572 : Template HasSnaky 13 required_572 envelope_572 := by + refine compose HasSnaky 12 childrenC_572 childrenD_572 children_work_572 (4, 6) + required_572 envelope_572 pivot_mem_572 child_required_sub_572 child_envelope_sub_572 ?_ + intro b hb + exact common_sub_572 (mem_commonEnvelope childrenD_572 b hb) +def required_590 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 3), (4, 1), (4, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_590 : Finset Cell := ⟨(([(0, 2), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 0), (5, 1), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_590 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) required_52), required_588] +def childrenD_590 : Fin 2 → Finset Cell := ![(placed21 0 (1, 0) envelope_52), envelope_588] +theorem common_sub_590 : commonEnvelope childrenD_590 ⊆ insert (2, 3) required_590 := by decide +kernel +theorem child_required_sub_590 : ∀ j, childrenC_590 j ⊆ insert (2, 3) required_590 := by decide +kernel +theorem child_envelope_sub_590 : ∀ j, childrenD_590 j ⊆ envelope_590 := by decide +kernel +theorem pivot_mem_590 : (2, 3) ∈ envelope_590 := by decide +kernel +theorem children_work_590 : ∀ j, Template HasSnaky 12 (childrenC_590 j) (childrenD_590 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 0 (1, 0)).mono (by decide +kernel) + · exact row_works_588.mono (by decide +kernel) +theorem row_works_590 : Template HasSnaky 13 required_590 envelope_590 := by + refine compose HasSnaky 12 childrenC_590 childrenD_590 children_work_590 (2, 3) + required_590 envelope_590 pivot_mem_590 child_required_sub_590 child_envelope_sub_590 ?_ + intro b hb + exact common_sub_590 (mem_commonEnvelope childrenD_590 b hb) +def height_564_i2 : ℕ := 8 +def childrenH_564_i2 : Fin 2 → ℕ := ![height_5, height_453] +theorem height_exact_564_i2 : height_564_i2 = 1 + Finset.univ.sup childrenH_564_i2 := by decide +kernel +theorem required_origin_564_i2 : ∀ x ∈ required_564_i2, + (∃ j, x ∈ childrenC_564_i2 j) ∨ ∀ j, x ∈ childrenD_564_i2 j := by decide +kernel +theorem required_exact_564_i2 : required_564_i2 = + ((Finset.univ.biUnion childrenC_564_i2) ∪ commonEnvelope childrenD_564_i2).erase (2, 4) := by + exact required_eq_combination childrenC_564_i2 childrenD_564_i2 (2, 4) required_564_i2 + (by decide +kernel) child_required_sub_564_i2 common_sub_564_i2 required_origin_564_i2 +theorem envelope_origin_564_i2 : ∀ x ∈ envelope_564_i2, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_564_i2 j := by decide +kernel +theorem envelope_exact_564_i2 : envelope_564_i2 = + insert (2, 4) (Finset.univ.biUnion childrenD_564_i2) := by + exact envelope_eq_combination childrenD_564_i2 (2, 4) envelope_564_i2 + pivot_mem_564_i2 child_envelope_sub_564_i2 envelope_origin_564_i2 +def checked_564_i2 : CheckedCard where + required := required_564_i2 + envelope := envelope_564_i2 + height := height_564_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_564_i2 +def height_564_i7 : ℕ := 5 +def childrenH_564_i7 : Fin 2 → ℕ := ![height_5, height_55] +theorem height_exact_564_i7 : height_564_i7 = 1 + Finset.univ.sup childrenH_564_i7 := by decide +kernel +theorem required_origin_564_i7 : ∀ x ∈ required_564_i7, + (∃ j, x ∈ childrenC_564_i7 j) ∨ ∀ j, x ∈ childrenD_564_i7 j := by decide +kernel +theorem required_exact_564_i7 : required_564_i7 = + ((Finset.univ.biUnion childrenC_564_i7) ∪ commonEnvelope childrenD_564_i7).erase (3, 5) := by + exact required_eq_combination childrenC_564_i7 childrenD_564_i7 (3, 5) required_564_i7 + (by decide +kernel) child_required_sub_564_i7 common_sub_564_i7 required_origin_564_i7 +theorem envelope_origin_564_i7 : ∀ x ∈ envelope_564_i7, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_564_i7 j := by decide +kernel +theorem envelope_exact_564_i7 : envelope_564_i7 = + insert (3, 5) (Finset.univ.biUnion childrenD_564_i7) := by + exact envelope_eq_combination childrenD_564_i7 (3, 5) envelope_564_i7 + pivot_mem_564_i7 child_envelope_sub_564_i7 envelope_origin_564_i7 +def checked_564_i7 : CheckedCard where + required := required_564_i7 + envelope := envelope_564_i7 + height := height_564_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_564_i7 +def height_564_i8 : ℕ := 6 +def childrenH_564_i8 : Fin 2 → ℕ := ![height_5, height_342] +theorem height_exact_564_i8 : height_564_i8 = 1 + Finset.univ.sup childrenH_564_i8 := by decide +kernel +theorem required_origin_564_i8 : ∀ x ∈ required_564_i8, + (∃ j, x ∈ childrenC_564_i8 j) ∨ ∀ j, x ∈ childrenD_564_i8 j := by decide +kernel +theorem required_exact_564_i8 : required_564_i8 = + ((Finset.univ.biUnion childrenC_564_i8) ∪ commonEnvelope childrenD_564_i8).erase (2, 4) := by + exact required_eq_combination childrenC_564_i8 childrenD_564_i8 (2, 4) required_564_i8 + (by decide +kernel) child_required_sub_564_i8 common_sub_564_i8 required_origin_564_i8 +theorem envelope_origin_564_i8 : ∀ x ∈ envelope_564_i8, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_564_i8 j := by decide +kernel +theorem envelope_exact_564_i8 : envelope_564_i8 = + insert (2, 4) (Finset.univ.biUnion childrenD_564_i8) := by + exact envelope_eq_combination childrenD_564_i8 (2, 4) envelope_564_i8 + pivot_mem_564_i8 child_envelope_sub_564_i8 envelope_origin_564_i8 +def checked_564_i8 : CheckedCard where + required := required_564_i8 + envelope := envelope_564_i8 + height := height_564_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_564_i8 +def height_564_i6 : ℕ := 7 +def childrenH_564_i6 : Fin 3 → ℕ := ![height_102, height_564_i7, height_564_i8] +theorem height_exact_564_i6 : height_564_i6 = 1 + Finset.univ.sup childrenH_564_i6 := by decide +kernel +theorem required_origin_564_i6 : ∀ x ∈ required_564_i6, + (∃ j, x ∈ childrenC_564_i6 j) ∨ ∀ j, x ∈ childrenD_564_i6 j := by decide +kernel +theorem required_exact_564_i6 : required_564_i6 = + ((Finset.univ.biUnion childrenC_564_i6) ∪ commonEnvelope childrenD_564_i6).erase (2, 5) := by + exact required_eq_combination childrenC_564_i6 childrenD_564_i6 (2, 5) required_564_i6 + (by decide +kernel) child_required_sub_564_i6 common_sub_564_i6 required_origin_564_i6 +theorem envelope_origin_564_i6 : ∀ x ∈ envelope_564_i6, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_564_i6 j := by decide +kernel +theorem envelope_exact_564_i6 : envelope_564_i6 = + insert (2, 5) (Finset.univ.biUnion childrenD_564_i6) := by + exact envelope_eq_combination childrenD_564_i6 (2, 5) envelope_564_i6 + pivot_mem_564_i6 child_envelope_sub_564_i6 envelope_origin_564_i6 +def checked_564_i6 : CheckedCard where + required := required_564_i6 + envelope := envelope_564_i6 + height := height_564_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_564_i6 +def height_564_i5 : ℕ := 8 +def childrenH_564_i5 : Fin 2 → ℕ := ![height_0, height_564_i6] +theorem height_exact_564_i5 : height_564_i5 = 1 + Finset.univ.sup childrenH_564_i5 := by decide +kernel +theorem required_origin_564_i5 : ∀ x ∈ required_564_i5, + (∃ j, x ∈ childrenC_564_i5 j) ∨ ∀ j, x ∈ childrenD_564_i5 j := by decide +kernel +theorem required_exact_564_i5 : required_564_i5 = + ((Finset.univ.biUnion childrenC_564_i5) ∪ commonEnvelope childrenD_564_i5).erase (4, 5) := by + exact required_eq_combination childrenC_564_i5 childrenD_564_i5 (4, 5) required_564_i5 + (by decide +kernel) child_required_sub_564_i5 common_sub_564_i5 required_origin_564_i5 +theorem envelope_origin_564_i5 : ∀ x ∈ envelope_564_i5, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_564_i5 j := by decide +kernel +theorem envelope_exact_564_i5 : envelope_564_i5 = + insert (4, 5) (Finset.univ.biUnion childrenD_564_i5) := by + exact envelope_eq_combination childrenD_564_i5 (4, 5) envelope_564_i5 + pivot_mem_564_i5 child_envelope_sub_564_i5 envelope_origin_564_i5 +def checked_564_i5 : CheckedCard where + required := required_564_i5 + envelope := envelope_564_i5 + height := height_564_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_564_i5 +def height_564_i4 : ℕ := 9 +def childrenH_564_i4 : Fin 3 → ℕ := ![height_16, height_235, height_564_i5] +theorem height_exact_564_i4 : height_564_i4 = 1 + Finset.univ.sup childrenH_564_i4 := by decide +kernel +theorem required_origin_564_i4 : ∀ x ∈ required_564_i4, + (∃ j, x ∈ childrenC_564_i4 j) ∨ ∀ j, x ∈ childrenD_564_i4 j := by decide +kernel +theorem required_exact_564_i4 : required_564_i4 = + ((Finset.univ.biUnion childrenC_564_i4) ∪ commonEnvelope childrenD_564_i4).erase (5, 7) := by + exact required_eq_combination childrenC_564_i4 childrenD_564_i4 (5, 7) required_564_i4 + (by decide +kernel) child_required_sub_564_i4 common_sub_564_i4 required_origin_564_i4 +theorem envelope_origin_564_i4 : ∀ x ∈ envelope_564_i4, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_564_i4 j := by decide +kernel +theorem envelope_exact_564_i4 : envelope_564_i4 = + insert (5, 7) (Finset.univ.biUnion childrenD_564_i4) := by + exact envelope_eq_combination childrenD_564_i4 (5, 7) envelope_564_i4 + pivot_mem_564_i4 child_envelope_sub_564_i4 envelope_origin_564_i4 +def checked_564_i4 : CheckedCard where + required := required_564_i4 + envelope := envelope_564_i4 + height := height_564_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_564_i4 +def height_564_i3 : ℕ := 10 +def childrenH_564_i3 : Fin 7 → ℕ := ![height_67, height_134, height_180, height_327, height_504, height_558, height_564_i4] +theorem height_exact_564_i3 : height_564_i3 = 1 + Finset.univ.sup childrenH_564_i3 := by decide +kernel +theorem required_origin_564_i3 : ∀ x ∈ required_564_i3, + (∃ j, x ∈ childrenC_564_i3 j) ∨ ∀ j, x ∈ childrenD_564_i3 j := by decide +kernel +theorem required_exact_564_i3 : required_564_i3 = + ((Finset.univ.biUnion childrenC_564_i3) ∪ commonEnvelope childrenD_564_i3).erase (5, 6) := by + exact required_eq_combination childrenC_564_i3 childrenD_564_i3 (5, 6) required_564_i3 + (by decide +kernel) child_required_sub_564_i3 common_sub_564_i3 required_origin_564_i3 +theorem envelope_origin_564_i3 : ∀ x ∈ envelope_564_i3, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_564_i3 j := by decide +kernel +theorem envelope_exact_564_i3 : envelope_564_i3 = + insert (5, 6) (Finset.univ.biUnion childrenD_564_i3) := by + exact envelope_eq_combination childrenD_564_i3 (5, 6) envelope_564_i3 + pivot_mem_564_i3 child_envelope_sub_564_i3 envelope_origin_564_i3 +def checked_564_i3 : CheckedCard where + required := required_564_i3 + envelope := envelope_564_i3 + height := height_564_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_564_i3 +def height_564_i1 : ℕ := 11 +def childrenH_564_i1 : Fin 5 → ℕ := ![height_44, height_564_i2, height_564_i3, height_560, height_563] +theorem height_exact_564_i1 : height_564_i1 = 1 + Finset.univ.sup childrenH_564_i1 := by decide +kernel +theorem required_origin_564_i1 : ∀ x ∈ required_564_i1, + (∃ j, x ∈ childrenC_564_i1 j) ∨ ∀ j, x ∈ childrenD_564_i1 j := by decide +kernel +theorem required_exact_564_i1 : required_564_i1 = + ((Finset.univ.biUnion childrenC_564_i1) ∪ commonEnvelope childrenD_564_i1).erase (5, 5) := by + exact required_eq_combination childrenC_564_i1 childrenD_564_i1 (5, 5) required_564_i1 + (by decide +kernel) child_required_sub_564_i1 common_sub_564_i1 required_origin_564_i1 +theorem envelope_origin_564_i1 : ∀ x ∈ envelope_564_i1, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_564_i1 j := by decide +kernel +theorem envelope_exact_564_i1 : envelope_564_i1 = + insert (5, 5) (Finset.univ.biUnion childrenD_564_i1) := by + exact envelope_eq_combination childrenD_564_i1 (5, 5) envelope_564_i1 + pivot_mem_564_i1 child_envelope_sub_564_i1 envelope_origin_564_i1 +def checked_564_i1 : CheckedCard where + required := required_564_i1 + envelope := envelope_564_i1 + height := height_564_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_564_i1 +def height_564_i0 : ℕ := 12 +def childrenH_564_i0 : Fin 6 → ℕ := ![height_12, height_12, height_79, height_135, height_182, height_564_i1] +theorem height_exact_564_i0 : height_564_i0 = 1 + Finset.univ.sup childrenH_564_i0 := by decide +kernel +theorem required_origin_564_i0 : ∀ x ∈ required_564_i0, + (∃ j, x ∈ childrenC_564_i0 j) ∨ ∀ j, x ∈ childrenD_564_i0 j := by decide +kernel +theorem required_exact_564_i0 : required_564_i0 = + ((Finset.univ.biUnion childrenC_564_i0) ∪ commonEnvelope childrenD_564_i0).erase (5, 4) := by + exact required_eq_combination childrenC_564_i0 childrenD_564_i0 (5, 4) required_564_i0 + (by decide +kernel) child_required_sub_564_i0 common_sub_564_i0 required_origin_564_i0 +theorem envelope_origin_564_i0 : ∀ x ∈ envelope_564_i0, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_564_i0 j := by decide +kernel +theorem envelope_exact_564_i0 : envelope_564_i0 = + insert (5, 4) (Finset.univ.biUnion childrenD_564_i0) := by + exact envelope_eq_combination childrenD_564_i0 (5, 4) envelope_564_i0 + pivot_mem_564_i0 child_envelope_sub_564_i0 envelope_origin_564_i0 +def checked_564_i0 : CheckedCard where + required := required_564_i0 + envelope := envelope_564_i0 + height := height_564_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_564_i0 +def height_564 : ℕ := 13 +def childrenH_564 : Fin 4 → ℕ := ![height_119, height_497, height_498, height_564_i0] +theorem height_exact_564 : height_564 = 1 + Finset.univ.sup childrenH_564 := by decide +kernel +theorem required_origin_564 : ∀ x ∈ required_564, + (∃ j, x ∈ childrenC_564 j) ∨ ∀ j, x ∈ childrenD_564 j := by decide +kernel +theorem required_exact_564 : required_564 = + ((Finset.univ.biUnion childrenC_564) ∪ commonEnvelope childrenD_564).erase (4, 4) := by + exact required_eq_combination childrenC_564 childrenD_564 (4, 4) required_564 + (by decide +kernel) child_required_sub_564 common_sub_564 required_origin_564 +theorem envelope_origin_564 : ∀ x ∈ envelope_564, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_564 j := by decide +kernel +theorem envelope_exact_564 : envelope_564 = + insert (4, 4) (Finset.univ.biUnion childrenD_564) := by + exact envelope_eq_combination childrenD_564 (4, 4) envelope_564 + pivot_mem_564 child_envelope_sub_564 envelope_origin_564 +def checked_564 : CheckedCard where + required := required_564 + envelope := envelope_564 + height := height_564 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_564 +def height_568_i0 : ℕ := 7 +def childrenH_568_i0 : Fin 2 → ℕ := ![height_255, height_496] +theorem height_exact_568_i0 : height_568_i0 = 1 + Finset.univ.sup childrenH_568_i0 := by decide +kernel +theorem required_origin_568_i0 : ∀ x ∈ required_568_i0, + (∃ j, x ∈ childrenC_568_i0 j) ∨ ∀ j, x ∈ childrenD_568_i0 j := by decide +kernel +theorem required_exact_568_i0 : required_568_i0 = + ((Finset.univ.biUnion childrenC_568_i0) ∪ commonEnvelope childrenD_568_i0).erase (4, 3) := by + exact required_eq_combination childrenC_568_i0 childrenD_568_i0 (4, 3) required_568_i0 + (by decide +kernel) child_required_sub_568_i0 common_sub_568_i0 required_origin_568_i0 +theorem envelope_origin_568_i0 : ∀ x ∈ envelope_568_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_568_i0 j := by decide +kernel +theorem envelope_exact_568_i0 : envelope_568_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_568_i0) := by + exact envelope_eq_combination childrenD_568_i0 (4, 3) envelope_568_i0 + pivot_mem_568_i0 child_envelope_sub_568_i0 envelope_origin_568_i0 +def checked_568_i0 : CheckedCard where + required := required_568_i0 + envelope := envelope_568_i0 + height := height_568_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_568_i0 +def height_568_i3 : ℕ := 4 +def childrenH_568_i3 : Fin 2 → ℕ := ![height_24, height_77] +theorem height_exact_568_i3 : height_568_i3 = 1 + Finset.univ.sup childrenH_568_i3 := by decide +kernel +theorem required_origin_568_i3 : ∀ x ∈ required_568_i3, + (∃ j, x ∈ childrenC_568_i3 j) ∨ ∀ j, x ∈ childrenD_568_i3 j := by decide +kernel +theorem required_exact_568_i3 : required_568_i3 = + ((Finset.univ.biUnion childrenC_568_i3) ∪ commonEnvelope childrenD_568_i3).erase (6, 4) := by + exact required_eq_combination childrenC_568_i3 childrenD_568_i3 (6, 4) required_568_i3 + (by decide +kernel) child_required_sub_568_i3 common_sub_568_i3 required_origin_568_i3 +theorem envelope_origin_568_i3 : ∀ x ∈ envelope_568_i3, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_568_i3 j := by decide +kernel +theorem envelope_exact_568_i3 : envelope_568_i3 = + insert (6, 4) (Finset.univ.biUnion childrenD_568_i3) := by + exact envelope_eq_combination childrenD_568_i3 (6, 4) envelope_568_i3 + pivot_mem_568_i3 child_envelope_sub_568_i3 envelope_origin_568_i3 +def checked_568_i3 : CheckedCard where + required := required_568_i3 + envelope := envelope_568_i3 + height := height_568_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_568_i3 +def height_568_i6 : ℕ := 5 +def childrenH_568_i6 : Fin 2 → ℕ := ![height_6, height_132] +theorem height_exact_568_i6 : height_568_i6 = 1 + Finset.univ.sup childrenH_568_i6 := by decide +kernel +theorem required_origin_568_i6 : ∀ x ∈ required_568_i6, + (∃ j, x ∈ childrenC_568_i6 j) ∨ ∀ j, x ∈ childrenD_568_i6 j := by decide +kernel +theorem required_exact_568_i6 : required_568_i6 = + ((Finset.univ.biUnion childrenC_568_i6) ∪ commonEnvelope childrenD_568_i6).erase (3, 7) := by + exact required_eq_combination childrenC_568_i6 childrenD_568_i6 (3, 7) required_568_i6 + (by decide +kernel) child_required_sub_568_i6 common_sub_568_i6 required_origin_568_i6 +theorem envelope_origin_568_i6 : ∀ x ∈ envelope_568_i6, + x = (3, 7) ∨ ∃ j, x ∈ childrenD_568_i6 j := by decide +kernel +theorem envelope_exact_568_i6 : envelope_568_i6 = + insert (3, 7) (Finset.univ.biUnion childrenD_568_i6) := by + exact envelope_eq_combination childrenD_568_i6 (3, 7) envelope_568_i6 + pivot_mem_568_i6 child_envelope_sub_568_i6 envelope_origin_568_i6 +def checked_568_i6 : CheckedCard where + required := required_568_i6 + envelope := envelope_568_i6 + height := height_568_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_568_i6 +def height_568_i7 : ℕ := 4 +def childrenH_568_i7 : Fin 2 → ℕ := ![height_6, height_124] +theorem height_exact_568_i7 : height_568_i7 = 1 + Finset.univ.sup childrenH_568_i7 := by decide +kernel +theorem required_origin_568_i7 : ∀ x ∈ required_568_i7, + (∃ j, x ∈ childrenC_568_i7 j) ∨ ∀ j, x ∈ childrenD_568_i7 j := by decide +kernel +theorem required_exact_568_i7 : required_568_i7 = + ((Finset.univ.biUnion childrenC_568_i7) ∪ commonEnvelope childrenD_568_i7).erase (3, 7) := by + exact required_eq_combination childrenC_568_i7 childrenD_568_i7 (3, 7) required_568_i7 + (by decide +kernel) child_required_sub_568_i7 common_sub_568_i7 required_origin_568_i7 +theorem envelope_origin_568_i7 : ∀ x ∈ envelope_568_i7, + x = (3, 7) ∨ ∃ j, x ∈ childrenD_568_i7 j := by decide +kernel +theorem envelope_exact_568_i7 : envelope_568_i7 = + insert (3, 7) (Finset.univ.biUnion childrenD_568_i7) := by + exact envelope_eq_combination childrenD_568_i7 (3, 7) envelope_568_i7 + pivot_mem_568_i7 child_envelope_sub_568_i7 envelope_origin_568_i7 +def checked_568_i7 : CheckedCard where + required := required_568_i7 + envelope := envelope_568_i7 + height := height_568_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_568_i7 +def height_568_i5 : ℕ := 7 +def childrenH_568_i5 : Fin 4 → ℕ := ![height_8, height_387, height_568_i6, height_568_i7] +theorem height_exact_568_i5 : height_568_i5 = 1 + Finset.univ.sup childrenH_568_i5 := by decide +kernel +theorem required_origin_568_i5 : ∀ x ∈ required_568_i5, + (∃ j, x ∈ childrenC_568_i5 j) ∨ ∀ j, x ∈ childrenD_568_i5 j := by decide +kernel +theorem required_exact_568_i5 : required_568_i5 = + ((Finset.univ.biUnion childrenC_568_i5) ∪ commonEnvelope childrenD_568_i5).erase (3, 6) := by + exact required_eq_combination childrenC_568_i5 childrenD_568_i5 (3, 6) required_568_i5 + (by decide +kernel) child_required_sub_568_i5 common_sub_568_i5 required_origin_568_i5 +theorem envelope_origin_568_i5 : ∀ x ∈ envelope_568_i5, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_568_i5 j := by decide +kernel +theorem envelope_exact_568_i5 : envelope_568_i5 = + insert (3, 6) (Finset.univ.biUnion childrenD_568_i5) := by + exact envelope_eq_combination childrenD_568_i5 (3, 6) envelope_568_i5 + pivot_mem_568_i5 child_envelope_sub_568_i5 envelope_origin_568_i5 +def checked_568_i5 : CheckedCard where + required := required_568_i5 + envelope := envelope_568_i5 + height := height_568_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_568_i5 +def height_568_i4 : ℕ := 8 +def childrenH_568_i4 : Fin 2 → ℕ := ![height_3, height_568_i5] +theorem height_exact_568_i4 : height_568_i4 = 1 + Finset.univ.sup childrenH_568_i4 := by decide +kernel +theorem required_origin_568_i4 : ∀ x ∈ required_568_i4, + (∃ j, x ∈ childrenC_568_i4 j) ∨ ∀ j, x ∈ childrenD_568_i4 j := by decide +kernel +theorem required_exact_568_i4 : required_568_i4 = + ((Finset.univ.biUnion childrenC_568_i4) ∪ commonEnvelope childrenD_568_i4).erase (3, 3) := by + exact required_eq_combination childrenC_568_i4 childrenD_568_i4 (3, 3) required_568_i4 + (by decide +kernel) child_required_sub_568_i4 common_sub_568_i4 required_origin_568_i4 +theorem envelope_origin_568_i4 : ∀ x ∈ envelope_568_i4, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_568_i4 j := by decide +kernel +theorem envelope_exact_568_i4 : envelope_568_i4 = + insert (3, 3) (Finset.univ.biUnion childrenD_568_i4) := by + exact envelope_eq_combination childrenD_568_i4 (3, 3) envelope_568_i4 + pivot_mem_568_i4 child_envelope_sub_568_i4 envelope_origin_568_i4 +def checked_568_i4 : CheckedCard where + required := required_568_i4 + envelope := envelope_568_i4 + height := height_568_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_568_i4 +def height_568_i2 : ℕ := 9 +def childrenH_568_i2 : Fin 3 → ℕ := ![height_52, height_568_i3, height_568_i4] +theorem height_exact_568_i2 : height_568_i2 = 1 + Finset.univ.sup childrenH_568_i2 := by decide +kernel +theorem required_origin_568_i2 : ∀ x ∈ required_568_i2, + (∃ j, x ∈ childrenC_568_i2 j) ∨ ∀ j, x ∈ childrenD_568_i2 j := by decide +kernel +theorem required_exact_568_i2 : required_568_i2 = + ((Finset.univ.biUnion childrenC_568_i2) ∪ commonEnvelope childrenD_568_i2).erase (3, 5) := by + exact required_eq_combination childrenC_568_i2 childrenD_568_i2 (3, 5) required_568_i2 + (by decide +kernel) child_required_sub_568_i2 common_sub_568_i2 required_origin_568_i2 +theorem envelope_origin_568_i2 : ∀ x ∈ envelope_568_i2, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_568_i2 j := by decide +kernel +theorem envelope_exact_568_i2 : envelope_568_i2 = + insert (3, 5) (Finset.univ.biUnion childrenD_568_i2) := by + exact envelope_eq_combination childrenD_568_i2 (3, 5) envelope_568_i2 + pivot_mem_568_i2 child_envelope_sub_568_i2 envelope_origin_568_i2 +def checked_568_i2 : CheckedCard where + required := required_568_i2 + envelope := envelope_568_i2 + height := height_568_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_568_i2 +def height_568_i1 : ℕ := 12 +def childrenH_568_i1 : Fin 6 → ℕ := ![height_79, height_189, height_518, height_568_i2, height_565, height_567] +theorem height_exact_568_i1 : height_568_i1 = 1 + Finset.univ.sup childrenH_568_i1 := by decide +kernel +theorem required_origin_568_i1 : ∀ x ∈ required_568_i1, + (∃ j, x ∈ childrenC_568_i1 j) ∨ ∀ j, x ∈ childrenD_568_i1 j := by decide +kernel +theorem required_exact_568_i1 : required_568_i1 = + ((Finset.univ.biUnion childrenC_568_i1) ∪ commonEnvelope childrenD_568_i1).erase (5, 4) := by + exact required_eq_combination childrenC_568_i1 childrenD_568_i1 (5, 4) required_568_i1 + (by decide +kernel) child_required_sub_568_i1 common_sub_568_i1 required_origin_568_i1 +theorem envelope_origin_568_i1 : ∀ x ∈ envelope_568_i1, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_568_i1 j := by decide +kernel +theorem envelope_exact_568_i1 : envelope_568_i1 = + insert (5, 4) (Finset.univ.biUnion childrenD_568_i1) := by + exact envelope_eq_combination childrenD_568_i1 (5, 4) envelope_568_i1 + pivot_mem_568_i1 child_envelope_sub_568_i1 envelope_origin_568_i1 +def checked_568_i1 : CheckedCard where + required := required_568_i1 + envelope := envelope_568_i1 + height := height_568_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_568_i1 +def height_568 : ℕ := 13 +def childrenH_568 : Fin 4 → ℕ := ![height_110, height_497, height_568_i0, height_568_i1] +theorem height_exact_568 : height_568 = 1 + Finset.univ.sup childrenH_568 := by decide +kernel +theorem required_origin_568 : ∀ x ∈ required_568, + (∃ j, x ∈ childrenC_568 j) ∨ ∀ j, x ∈ childrenD_568 j := by decide +kernel +theorem required_exact_568 : required_568 = + ((Finset.univ.biUnion childrenC_568) ∪ commonEnvelope childrenD_568).erase (4, 4) := by + exact required_eq_combination childrenC_568 childrenD_568 (4, 4) required_568 + (by decide +kernel) child_required_sub_568 common_sub_568 required_origin_568 +theorem envelope_origin_568 : ∀ x ∈ envelope_568, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_568 j := by decide +kernel +theorem envelope_exact_568 : envelope_568 = + insert (4, 4) (Finset.univ.biUnion childrenD_568) := by + exact envelope_eq_combination childrenD_568 (4, 4) envelope_568 + pivot_mem_568 child_envelope_sub_568 envelope_origin_568 +def checked_568 : CheckedCard where + required := required_568 + envelope := envelope_568 + height := height_568 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_568 +def height_572_i0 : ℕ := 4 +def childrenH_572_i0 : Fin 2 → ℕ := ![height_5, height_78] +theorem height_exact_572_i0 : height_572_i0 = 1 + Finset.univ.sup childrenH_572_i0 := by decide +kernel +theorem required_origin_572_i0 : ∀ x ∈ required_572_i0, + (∃ j, x ∈ childrenC_572_i0 j) ∨ ∀ j, x ∈ childrenD_572_i0 j := by decide +kernel +theorem required_exact_572_i0 : required_572_i0 = + ((Finset.univ.biUnion childrenC_572_i0) ∪ commonEnvelope childrenD_572_i0).erase (2, 6) := by + exact required_eq_combination childrenC_572_i0 childrenD_572_i0 (2, 6) required_572_i0 + (by decide +kernel) child_required_sub_572_i0 common_sub_572_i0 required_origin_572_i0 +theorem envelope_origin_572_i0 : ∀ x ∈ envelope_572_i0, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_572_i0 j := by decide +kernel +theorem envelope_exact_572_i0 : envelope_572_i0 = + insert (2, 6) (Finset.univ.biUnion childrenD_572_i0) := by + exact envelope_eq_combination childrenD_572_i0 (2, 6) envelope_572_i0 + pivot_mem_572_i0 child_envelope_sub_572_i0 envelope_origin_572_i0 +def checked_572_i0 : CheckedCard where + required := required_572_i0 + envelope := envelope_572_i0 + height := height_572_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_572_i0 +def height_572 : ℕ := 13 +def childrenH_572 : Fin 4 → ℕ := ![height_97, height_98, height_572_i0, height_571] +theorem height_exact_572 : height_572 = 1 + Finset.univ.sup childrenH_572 := by decide +kernel +theorem required_origin_572 : ∀ x ∈ required_572, + (∃ j, x ∈ childrenC_572 j) ∨ ∀ j, x ∈ childrenD_572 j := by decide +kernel +theorem required_exact_572 : required_572 = + ((Finset.univ.biUnion childrenC_572) ∪ commonEnvelope childrenD_572).erase (4, 6) := by + exact required_eq_combination childrenC_572 childrenD_572 (4, 6) required_572 + (by decide +kernel) child_required_sub_572 common_sub_572 required_origin_572 +theorem envelope_origin_572 : ∀ x ∈ envelope_572, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_572 j := by decide +kernel +theorem envelope_exact_572 : envelope_572 = + insert (4, 6) (Finset.univ.biUnion childrenD_572) := by + exact envelope_eq_combination childrenD_572 (4, 6) envelope_572 + pivot_mem_572 child_envelope_sub_572 envelope_origin_572 +def checked_572 : CheckedCard where + required := required_572 + envelope := envelope_572 + height := height_572 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_572 +def height_590 : ℕ := 13 +def childrenH_590 : Fin 2 → ℕ := ![height_52, height_588] +theorem height_exact_590 : height_590 = 1 + Finset.univ.sup childrenH_590 := by decide +kernel +theorem required_origin_590 : ∀ x ∈ required_590, + (∃ j, x ∈ childrenC_590 j) ∨ ∀ j, x ∈ childrenD_590 j := by decide +kernel +theorem required_exact_590 : required_590 = + ((Finset.univ.biUnion childrenC_590) ∪ commonEnvelope childrenD_590).erase (2, 3) := by + exact required_eq_combination childrenC_590 childrenD_590 (2, 3) required_590 + (by decide +kernel) child_required_sub_590 common_sub_590 required_origin_590 +theorem envelope_origin_590 : ∀ x ∈ envelope_590, + x = (2, 3) ∨ ∃ j, x ∈ childrenD_590 j := by decide +kernel +theorem envelope_exact_590 : envelope_590 = + insert (2, 3) (Finset.univ.biUnion childrenD_590) := by + exact envelope_eq_combination childrenD_590 (2, 3) envelope_590 + pivot_mem_590 child_envelope_sub_590 envelope_origin_590 +def checked_590 : CheckedCard where + required := required_590 + envelope := envelope_590 + height := height_590 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_590 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part03.lean new file mode 100644 index 0000000..2c72780 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part03.lean @@ -0,0 +1,1029 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_591_i0 : Finset Cell := ⟨(([(1, 5), (1, 6), (2, 6), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_591_i0 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 6), (2, 5), (2, 6), (3, 5), (3, 6), (4, 5), (4, 6), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_591_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 6) required_5), (placed21 1 (1, 5) required_265)] +def childrenD_591_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 6) envelope_5), (placed21 1 (1, 5) envelope_265)] +theorem common_sub_591_i0 : commonEnvelope childrenD_591_i0 ⊆ insert (3, 6) required_591_i0 := by decide +kernel +theorem child_required_sub_591_i0 : ∀ j, childrenC_591_i0 j ⊆ insert (3, 6) required_591_i0 := by decide +kernel +theorem child_envelope_sub_591_i0 : ∀ j, childrenD_591_i0 j ⊆ envelope_591_i0 := by decide +kernel +theorem pivot_mem_591_i0 : (3, 6) ∈ envelope_591_i0 := by decide +kernel +theorem children_work_591_i0 : ∀ j, Template HasSnaky 5 (childrenC_591_i0 j) (childrenD_591_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_265 1 (1, 5)).mono (by decide +kernel) +theorem row_works_591_i0 : Template HasSnaky 6 required_591_i0 envelope_591_i0 := by + refine compose HasSnaky 5 childrenC_591_i0 childrenD_591_i0 children_work_591_i0 (3, 6) + required_591_i0 envelope_591_i0 pivot_mem_591_i0 child_required_sub_591_i0 child_envelope_sub_591_i0 ?_ + intro b hb + exact common_sub_591_i0 (mem_commonEnvelope childrenD_591_i0 b hb) +def required_591_i1 : Finset Cell := ⟨(([(1, 5), (1, 6), (2, 6), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_591_i1 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 5), (1, 6), (2, 3), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_591_i1 : Fin 5 → Finset Cell := ![(placed21 4 (3, 8) required_12), (placed21 4 (3, 8) required_13), (placed21 4 (3, 8) required_14), (placed21 3 (0, 6) required_289), (placed21 3 (1, 7) required_435)] +def childrenD_591_i1 : Fin 5 → Finset Cell := ![(placed21 4 (3, 8) envelope_12), (placed21 4 (3, 8) envelope_13), (placed21 4 (3, 8) envelope_14), (placed21 3 (0, 6) envelope_289), (placed21 3 (1, 7) envelope_435)] +theorem common_sub_591_i1 : commonEnvelope childrenD_591_i1 ⊆ insert (4, 4) required_591_i1 := by decide +kernel +theorem child_required_sub_591_i1 : ∀ j, childrenC_591_i1 j ⊆ insert (4, 4) required_591_i1 := by decide +kernel +theorem child_envelope_sub_591_i1 : ∀ j, childrenD_591_i1 j ⊆ envelope_591_i1 := by decide +kernel +theorem pivot_mem_591_i1 : (4, 4) ∈ envelope_591_i1 := by decide +kernel +theorem children_work_591_i1 : ∀ j, Template HasSnaky 6 (childrenC_591_i1 j) (childrenD_591_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_13 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_14 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_289 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_435 3 (1, 7)).mono (by decide +kernel) +theorem row_works_591_i1 : Template HasSnaky 7 required_591_i1 envelope_591_i1 := by + refine compose HasSnaky 6 childrenC_591_i1 childrenD_591_i1 children_work_591_i1 (4, 4) + required_591_i1 envelope_591_i1 pivot_mem_591_i1 child_required_sub_591_i1 child_envelope_sub_591_i1 ?_ + intro b hb + exact common_sub_591_i1 (mem_commonEnvelope childrenD_591_i1 b hb) +def required_591_i4 : Finset Cell := ⟨(([(1, 5), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_591_i4 : Finset Cell := ⟨(([(1, 5), (2, 5), (3, 0), (3, 1), (3, 2), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_591_i4 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) required_17), (placed21 7 (5, 6) required_80)] +def childrenD_591_i4 : Fin 2 → Finset Cell := ![(placed21 4 (3, 6) envelope_17), (placed21 7 (5, 6) envelope_80)] +theorem common_sub_591_i4 : commonEnvelope childrenD_591_i4 ⊆ insert (3, 5) required_591_i4 := by decide +kernel +theorem child_required_sub_591_i4 : ∀ j, childrenC_591_i4 j ⊆ insert (3, 5) required_591_i4 := by decide +kernel +theorem child_envelope_sub_591_i4 : ∀ j, childrenD_591_i4 j ⊆ envelope_591_i4 := by decide +kernel +theorem pivot_mem_591_i4 : (3, 5) ∈ envelope_591_i4 := by decide +kernel +theorem children_work_591_i4 : ∀ j, Template HasSnaky 4 (childrenC_591_i4 j) (childrenD_591_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_17 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_80 7 (5, 6)).mono (by decide +kernel) +theorem row_works_591_i4 : Template HasSnaky 5 required_591_i4 envelope_591_i4 := by + refine compose HasSnaky 4 childrenC_591_i4 childrenD_591_i4 children_work_591_i4 (3, 5) + required_591_i4 envelope_591_i4 pivot_mem_591_i4 child_required_sub_591_i4 child_envelope_sub_591_i4 ?_ + intro b hb + exact common_sub_591_i4 (mem_commonEnvelope childrenD_591_i4 b hb) +def required_591_i3 : Finset Cell := ⟨(([(1, 3), (1, 5), (2, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_591_i3 : Finset Cell := ⟨(([(1, 3), (1, 5), (2, 3), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_591_i3 : Fin 3 → Finset Cell := ![(placed21 4 (1, 6) required_109), (placed21 7 (5, 6) required_157), required_591_i4] +def childrenD_591_i3 : Fin 3 → Finset Cell := ![(placed21 4 (1, 6) envelope_109), (placed21 7 (5, 6) envelope_157), envelope_591_i4] +theorem common_sub_591_i3 : commonEnvelope childrenD_591_i3 ⊆ insert (4, 3) required_591_i3 := by decide +kernel +theorem child_required_sub_591_i3 : ∀ j, childrenC_591_i3 j ⊆ insert (4, 3) required_591_i3 := by decide +kernel +theorem child_envelope_sub_591_i3 : ∀ j, childrenD_591_i3 j ⊆ envelope_591_i3 := by decide +kernel +theorem pivot_mem_591_i3 : (4, 3) ∈ envelope_591_i3 := by decide +kernel +theorem children_work_591_i3 : ∀ j, Template HasSnaky 5 (childrenC_591_i3 j) (childrenD_591_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_109 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_157 7 (5, 6)).mono (by decide +kernel) + · exact row_works_591_i4.mono (by decide +kernel) +theorem row_works_591_i3 : Template HasSnaky 6 required_591_i3 envelope_591_i3 := by + refine compose HasSnaky 5 childrenC_591_i3 childrenD_591_i3 children_work_591_i3 (4, 3) + required_591_i3 envelope_591_i3 pivot_mem_591_i3 child_required_sub_591_i3 child_envelope_sub_591_i3 ?_ + intro b hb + exact common_sub_591_i3 (mem_commonEnvelope childrenD_591_i3 b hb) +def required_591_i5 : Finset Cell := ⟨(([(1, 3), (2, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_591_i5 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_591_i5 : Fin 3 → Finset Cell := ![(placed21 3 (3, 6) required_8), (placed21 2 (5, 2) required_19), (placed21 4 (1, 6) required_271)] +def childrenD_591_i5 : Fin 3 → Finset Cell := ![(placed21 3 (3, 6) envelope_8), (placed21 2 (5, 2) envelope_19), (placed21 4 (1, 6) envelope_271)] +theorem common_sub_591_i5 : commonEnvelope childrenD_591_i5 ⊆ insert (4, 3) required_591_i5 := by decide +kernel +theorem child_required_sub_591_i5 : ∀ j, childrenC_591_i5 j ⊆ insert (4, 3) required_591_i5 := by decide +kernel +theorem child_envelope_sub_591_i5 : ∀ j, childrenD_591_i5 j ⊆ envelope_591_i5 := by decide +kernel +theorem pivot_mem_591_i5 : (4, 3) ∈ envelope_591_i5 := by decide +kernel +theorem children_work_591_i5 : ∀ j, Template HasSnaky 5 (childrenC_591_i5 j) (childrenD_591_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 3 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_19 2 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_271 4 (1, 6)).mono (by decide +kernel) +theorem row_works_591_i5 : Template HasSnaky 6 required_591_i5 envelope_591_i5 := by + refine compose HasSnaky 5 childrenC_591_i5 childrenD_591_i5 children_work_591_i5 (4, 3) + required_591_i5 envelope_591_i5 pivot_mem_591_i5 child_required_sub_591_i5 child_envelope_sub_591_i5 ?_ + intro b hb + exact common_sub_591_i5 (mem_commonEnvelope childrenD_591_i5 b hb) +def required_591_i2 : Finset Cell := ⟨(([(1, 3), (1, 5), (2, 3), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_591_i2 : Finset Cell := ⟨(([(1, 3), (1, 5), (2, 3), (2, 5), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_591_i2 : Fin 5 → Finset Cell := ![(placed21 0 (3, 2) required_13), (placed21 0 (1, 2) required_356), required_591_i3, (placed21 1 (2, 3) required_586), required_591_i5] +def childrenD_591_i2 : Fin 5 → Finset Cell := ![(placed21 0 (3, 2) envelope_13), (placed21 0 (1, 2) envelope_356), envelope_591_i3, (placed21 1 (2, 3) envelope_586), envelope_591_i5] +theorem common_sub_591_i2 : commonEnvelope childrenD_591_i2 ⊆ insert (4, 4) required_591_i2 := by decide +kernel +theorem child_required_sub_591_i2 : ∀ j, childrenC_591_i2 j ⊆ insert (4, 4) required_591_i2 := by decide +kernel +theorem child_envelope_sub_591_i2 : ∀ j, childrenD_591_i2 j ⊆ envelope_591_i2 := by decide +kernel +theorem pivot_mem_591_i2 : (4, 4) ∈ envelope_591_i2 := by decide +kernel +theorem children_work_591_i2 : ∀ j, Template HasSnaky 11 (childrenC_591_i2 j) (childrenD_591_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_356 0 (1, 2)).mono (by decide +kernel) + · exact row_works_591_i3.mono (by decide +kernel) + · exact (placed21_template row_works_586 1 (2, 3)).mono (by decide +kernel) + · exact row_works_591_i5.mono (by decide +kernel) +theorem row_works_591_i2 : Template HasSnaky 12 required_591_i2 envelope_591_i2 := by + refine compose HasSnaky 11 childrenC_591_i2 childrenD_591_i2 children_work_591_i2 (4, 4) + required_591_i2 envelope_591_i2 pivot_mem_591_i2 child_required_sub_591_i2 child_envelope_sub_591_i2 ?_ + intro b hb + exact common_sub_591_i2 (mem_commonEnvelope childrenD_591_i2 b hb) +def required_591 : Finset Cell := ⟨(([(1, 3), (1, 5), (1, 6), (2, 3), (2, 6), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_591 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 5), (1, 6), (1, 8), (2, 3), (2, 5), (2, 6), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_591 : Fin 5 → Finset Cell := ![(placed21 1 (0, 5) required_42), (placed21 0 (1, 2) required_430), required_591_i0, required_591_i1, required_591_i2] +def childrenD_591 : Fin 5 → Finset Cell := ![(placed21 1 (0, 5) envelope_42), (placed21 0 (1, 2) envelope_430), envelope_591_i0, envelope_591_i1, envelope_591_i2] +theorem common_sub_591 : commonEnvelope childrenD_591 ⊆ insert (4, 6) required_591 := by decide +kernel +theorem child_required_sub_591 : ∀ j, childrenC_591 j ⊆ insert (4, 6) required_591 := by decide +kernel +theorem child_envelope_sub_591 : ∀ j, childrenD_591 j ⊆ envelope_591 := by decide +kernel +theorem pivot_mem_591 : (4, 6) ∈ envelope_591 := by decide +kernel +theorem children_work_591 : ∀ j, Template HasSnaky 12 (childrenC_591 j) (childrenD_591 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_42 1 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_430 0 (1, 2)).mono (by decide +kernel) + · exact row_works_591_i0.mono (by decide +kernel) + · exact row_works_591_i1.mono (by decide +kernel) + · exact row_works_591_i2.mono (by decide +kernel) +theorem row_works_591 : Template HasSnaky 13 required_591 envelope_591 := by + refine compose HasSnaky 12 childrenC_591 childrenD_591 children_work_591 (4, 6) + required_591 envelope_591 pivot_mem_591 child_required_sub_591 child_envelope_sub_591 ?_ + intro b hb + exact common_sub_591 (mem_commonEnvelope childrenD_591 b hb) +def required_597_i0 : Finset Cell := ⟨(([(2, 5), (3, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_597_i0 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_597_i0 : Fin 3 → Finset Cell := ![(placed21 6 (6, 7) required_13), (placed21 0 (2, 2) required_109), (placed21 0 (2, 2) required_291)] +def childrenD_597_i0 : Fin 3 → Finset Cell := ![(placed21 6 (6, 7) envelope_13), (placed21 0 (2, 2) envelope_109), (placed21 0 (2, 2) envelope_291)] +theorem common_sub_597_i0 : commonEnvelope childrenD_597_i0 ⊆ insert (5, 4) required_597_i0 := by decide +kernel +theorem child_required_sub_597_i0 : ∀ j, childrenC_597_i0 j ⊆ insert (5, 4) required_597_i0 := by decide +kernel +theorem child_envelope_sub_597_i0 : ∀ j, childrenD_597_i0 j ⊆ envelope_597_i0 := by decide +kernel +theorem pivot_mem_597_i0 : (5, 4) ∈ envelope_597_i0 := by decide +kernel +theorem children_work_597_i0 : ∀ j, Template HasSnaky 4 (childrenC_597_i0 j) (childrenD_597_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 6 (6, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_109 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_291 0 (2, 2)).mono (by decide +kernel) +theorem row_works_597_i0 : Template HasSnaky 5 required_597_i0 envelope_597_i0 := by + refine compose HasSnaky 4 childrenC_597_i0 childrenD_597_i0 children_work_597_i0 (5, 4) + required_597_i0 envelope_597_i0 pivot_mem_597_i0 child_required_sub_597_i0 child_envelope_sub_597_i0 ?_ + intro b hb + exact common_sub_597_i0 (mem_commonEnvelope childrenD_597_i0 b hb) +def required_597_i3 : Finset Cell := ⟨(([(2, 2), (2, 3), (3, 2), (5, 2), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_597_i3 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 2), (4, 1), (4, 2), (5, 2), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_597_i3 : Fin 2 → Finset Cell := ![(placed21 7 (5, 5) required_5), (placed21 2 (5, 2) required_5)] +def childrenD_597_i3 : Fin 2 → Finset Cell := ![(placed21 7 (5, 5) envelope_5), (placed21 2 (5, 2) envelope_5)] +theorem common_sub_597_i3 : commonEnvelope childrenD_597_i3 ⊆ insert (4, 2) required_597_i3 := by decide +kernel +theorem child_required_sub_597_i3 : ∀ j, childrenC_597_i3 j ⊆ insert (4, 2) required_597_i3 := by decide +kernel +theorem child_envelope_sub_597_i3 : ∀ j, childrenD_597_i3 j ⊆ envelope_597_i3 := by decide +kernel +theorem pivot_mem_597_i3 : (4, 2) ∈ envelope_597_i3 := by decide +kernel +theorem children_work_597_i3 : ∀ j, Template HasSnaky 1 (childrenC_597_i3 j) (childrenD_597_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (5, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_5 2 (5, 2)).mono (by decide +kernel) +theorem row_works_597_i3 : Template HasSnaky 2 required_597_i3 envelope_597_i3 := by + refine compose HasSnaky 1 childrenC_597_i3 childrenD_597_i3 children_work_597_i3 (4, 2) + required_597_i3 envelope_597_i3 pivot_mem_597_i3 child_required_sub_597_i3 child_envelope_sub_597_i3 ?_ + intro b hb + exact common_sub_597_i3 (mem_commonEnvelope childrenD_597_i3 b hb) +def required_597_i2 : Finset Cell := ⟨(([(2, 2), (2, 3), (3, 2), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_597_i2 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 2), (4, 1), (4, 2), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_597_i2 : Fin 2 → Finset Cell := ![(placed21 4 (5, 6) required_7), required_597_i3] +def childrenD_597_i2 : Fin 2 → Finset Cell := ![(placed21 4 (5, 6) envelope_7), envelope_597_i3] +theorem common_sub_597_i2 : commonEnvelope childrenD_597_i2 ⊆ insert (5, 2) required_597_i2 := by decide +kernel +theorem child_required_sub_597_i2 : ∀ j, childrenC_597_i2 j ⊆ insert (5, 2) required_597_i2 := by decide +kernel +theorem child_envelope_sub_597_i2 : ∀ j, childrenD_597_i2 j ⊆ envelope_597_i2 := by decide +kernel +theorem pivot_mem_597_i2 : (5, 2) ∈ envelope_597_i2 := by decide +kernel +theorem children_work_597_i2 : ∀ j, Template HasSnaky 3 (childrenC_597_i2 j) (childrenD_597_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (5, 6)).mono (by decide +kernel) + · exact row_works_597_i3.mono (by decide +kernel) +theorem row_works_597_i2 : Template HasSnaky 4 required_597_i2 envelope_597_i2 := by + refine compose HasSnaky 3 childrenC_597_i2 childrenD_597_i2 children_work_597_i2 (5, 2) + required_597_i2 envelope_597_i2 pivot_mem_597_i2 child_required_sub_597_i2 child_envelope_sub_597_i2 ?_ + intro b hb + exact common_sub_597_i2 (mem_commonEnvelope childrenD_597_i2 b hb) +def required_597_i6 : Finset Cell := ⟨(([(2, 2), (3, 2), (4, 2), (5, 2), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_597_i6 : Finset Cell := ⟨(([(2, 2), (3, 2), (4, 2), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 1), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_597_i6 : Fin 2 → Finset Cell := ![(placed21 4 (2, 2) required_4), (placed21 3 (5, 5) required_4)] +def childrenD_597_i6 : Fin 2 → Finset Cell := ![(placed21 4 (2, 2) envelope_4), (placed21 3 (5, 5) envelope_4)] +theorem common_sub_597_i6 : commonEnvelope childrenD_597_i6 ⊆ insert (6, 1) required_597_i6 := by decide +kernel +theorem child_required_sub_597_i6 : ∀ j, childrenC_597_i6 j ⊆ insert (6, 1) required_597_i6 := by decide +kernel +theorem child_envelope_sub_597_i6 : ∀ j, childrenD_597_i6 j ⊆ envelope_597_i6 := by decide +kernel +theorem pivot_mem_597_i6 : (6, 1) ∈ envelope_597_i6 := by decide +kernel +theorem children_work_597_i6 : ∀ j, Template HasSnaky 1 (childrenC_597_i6 j) (childrenD_597_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_4 3 (5, 5)).mono (by decide +kernel) +theorem row_works_597_i6 : Template HasSnaky 2 required_597_i6 envelope_597_i6 := by + refine compose HasSnaky 1 childrenC_597_i6 childrenD_597_i6 children_work_597_i6 (6, 1) + required_597_i6 envelope_597_i6 pivot_mem_597_i6 child_required_sub_597_i6 child_envelope_sub_597_i6 ?_ + intro b hb + exact common_sub_597_i6 (mem_commonEnvelope childrenD_597_i6 b hb) +def required_597_i5 : Finset Cell := ⟨(([(2, 2), (2, 3), (3, 2), (4, 2), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_597_i5 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 2), (4, 2), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 1), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_597_i5 : Fin 2 → Finset Cell := ![(placed21 2 (5, 2) required_5), required_597_i6] +def childrenD_597_i5 : Fin 2 → Finset Cell := ![(placed21 2 (5, 2) envelope_5), envelope_597_i6] +theorem common_sub_597_i5 : commonEnvelope childrenD_597_i5 ⊆ insert (5, 2) required_597_i5 := by decide +kernel +theorem child_required_sub_597_i5 : ∀ j, childrenC_597_i5 j ⊆ insert (5, 2) required_597_i5 := by decide +kernel +theorem child_envelope_sub_597_i5 : ∀ j, childrenD_597_i5 j ⊆ envelope_597_i5 := by decide +kernel +theorem pivot_mem_597_i5 : (5, 2) ∈ envelope_597_i5 := by decide +kernel +theorem children_work_597_i5 : ∀ j, Template HasSnaky 2 (childrenC_597_i5 j) (childrenD_597_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (5, 2)).mono (by decide +kernel) + · exact row_works_597_i6.mono (by decide +kernel) +theorem row_works_597_i5 : Template HasSnaky 3 required_597_i5 envelope_597_i5 := by + refine compose HasSnaky 2 childrenC_597_i5 childrenD_597_i5 children_work_597_i5 (5, 2) + required_597_i5 envelope_597_i5 pivot_mem_597_i5 child_required_sub_597_i5 child_envelope_sub_597_i5 ?_ + intro b hb + exact common_sub_597_i5 (mem_commonEnvelope childrenD_597_i5 b hb) +def required_597_i4 : Finset Cell := ⟨(([(2, 2), (2, 3), (3, 2), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_597_i4 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 2), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_597_i4 : Fin 2 → Finset Cell := ![(placed21 6 (5, 6) required_140), required_597_i5] +def childrenD_597_i4 : Fin 2 → Finset Cell := ![(placed21 6 (5, 6) envelope_140), envelope_597_i5] +theorem common_sub_597_i4 : commonEnvelope childrenD_597_i4 ⊆ insert (4, 2) required_597_i4 := by decide +kernel +theorem child_required_sub_597_i4 : ∀ j, childrenC_597_i4 j ⊆ insert (4, 2) required_597_i4 := by decide +kernel +theorem child_envelope_sub_597_i4 : ∀ j, childrenD_597_i4 j ⊆ envelope_597_i4 := by decide +kernel +theorem pivot_mem_597_i4 : (4, 2) ∈ envelope_597_i4 := by decide +kernel +theorem children_work_597_i4 : ∀ j, Template HasSnaky 3 (childrenC_597_i4 j) (childrenD_597_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_140 6 (5, 6)).mono (by decide +kernel) + · exact row_works_597_i5.mono (by decide +kernel) +theorem row_works_597_i4 : Template HasSnaky 4 required_597_i4 envelope_597_i4 := by + refine compose HasSnaky 3 childrenC_597_i4 childrenD_597_i4 children_work_597_i4 (4, 2) + required_597_i4 envelope_597_i4 pivot_mem_597_i4 child_required_sub_597_i4 child_envelope_sub_597_i4 ?_ + intro b hb + exact common_sub_597_i4 (mem_commonEnvelope childrenD_597_i4 b hb) +def required_597_i1 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 5), (3, 2), (3, 5), (5, 3), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_597_i1 : Finset Cell := ⟨(([(1, 3), (1, 6), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 2), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 7), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_597_i1 : Fin 3 → Finset Cell := ![required_597_i2, required_597_i4, (placed21 1 (1, 2) required_596)] +def childrenD_597_i1 : Fin 3 → Finset Cell := ![envelope_597_i2, envelope_597_i4, (placed21 1 (1, 2) envelope_596)] +theorem common_sub_597_i1 : commonEnvelope childrenD_597_i1 ⊆ insert (5, 4) required_597_i1 := by decide +kernel +theorem child_required_sub_597_i1 : ∀ j, childrenC_597_i1 j ⊆ insert (5, 4) required_597_i1 := by decide +kernel +theorem child_envelope_sub_597_i1 : ∀ j, childrenD_597_i1 j ⊆ envelope_597_i1 := by decide +kernel +theorem pivot_mem_597_i1 : (5, 4) ∈ envelope_597_i1 := by decide +kernel +theorem children_work_597_i1 : ∀ j, Template HasSnaky 11 (childrenC_597_i1 j) (childrenD_597_i1 j) := by + intro j + fin_cases j + · exact row_works_597_i2.mono (by decide +kernel) + · exact row_works_597_i4.mono (by decide +kernel) + · exact (placed21_template row_works_596 1 (1, 2)).mono (by decide +kernel) +theorem row_works_597_i1 : Template HasSnaky 12 required_597_i1 envelope_597_i1 := by + refine compose HasSnaky 11 childrenC_597_i1 childrenD_597_i1 children_work_597_i1 (5, 4) + required_597_i1 envelope_597_i1 pivot_mem_597_i1 child_required_sub_597_i1 child_envelope_sub_597_i1 ?_ + intro b hb + exact common_sub_597_i1 (mem_commonEnvelope childrenD_597_i1 b hb) +def required_597 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 5), (3, 2), (3, 5), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_597 : Finset Cell := ⟨(([(0, 7), (1, 3), (1, 4), (1, 6), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 2), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 4), (7, 6), (7, 7), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_597 : Fin 5 → Finset Cell := ![(placed21 1 (1, 2) required_272), (placed21 3 (1, 6) required_290), (placed21 1 (0, 2) required_593), required_597_i0, required_597_i1] +def childrenD_597 : Fin 5 → Finset Cell := ![(placed21 1 (1, 2) envelope_272), (placed21 3 (1, 6) envelope_290), (placed21 1 (0, 2) envelope_593), envelope_597_i0, envelope_597_i1] +theorem common_sub_597 : commonEnvelope childrenD_597 ⊆ insert (5, 5) required_597 := by decide +kernel +theorem child_required_sub_597 : ∀ j, childrenC_597 j ⊆ insert (5, 5) required_597 := by decide +kernel +theorem child_envelope_sub_597 : ∀ j, childrenD_597 j ⊆ envelope_597 := by decide +kernel +theorem pivot_mem_597 : (5, 5) ∈ envelope_597 := by decide +kernel +theorem children_work_597 : ∀ j, Template HasSnaky 12 (childrenC_597 j) (childrenD_597 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_272 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_290 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_593 1 (0, 2)).mono (by decide +kernel) + · exact row_works_597_i0.mono (by decide +kernel) + · exact row_works_597_i1.mono (by decide +kernel) +theorem row_works_597 : Template HasSnaky 13 required_597 envelope_597 := by + refine compose HasSnaky 12 childrenC_597 childrenD_597 children_work_597 (5, 5) + required_597 envelope_597 pivot_mem_597 child_required_sub_597 child_envelope_sub_597 ?_ + intro b hb + exact common_sub_597 (mem_commonEnvelope childrenD_597 b hb) +def required_603_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_603_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (6, 4), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_603_i0 : Fin 4 → Finset Cell := ![(placed21 4 (1, 6) required_7), (placed21 3 (0, 5) required_8), (placed21 6 (2, 6) required_9), (placed21 4 (0, 6) required_427)] +def childrenD_603_i0 : Fin 4 → Finset Cell := ![(placed21 4 (1, 6) envelope_7), (placed21 3 (0, 5) envelope_8), (placed21 6 (2, 6) envelope_9), (placed21 4 (0, 6) envelope_427)] +theorem common_sub_603_i0 : commonEnvelope childrenD_603_i0 ⊆ insert (1, 2) required_603_i0 := by decide +kernel +theorem child_required_sub_603_i0 : ∀ j, childrenC_603_i0 j ⊆ insert (1, 2) required_603_i0 := by decide +kernel +theorem child_envelope_sub_603_i0 : ∀ j, childrenD_603_i0 j ⊆ envelope_603_i0 := by decide +kernel +theorem pivot_mem_603_i0 : (1, 2) ∈ envelope_603_i0 := by decide +kernel +theorem children_work_603_i0 : ∀ j, Template HasSnaky 11 (childrenC_603_i0 j) (childrenD_603_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_8 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_9 6 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_427 4 (0, 6)).mono (by decide +kernel) +theorem row_works_603_i0 : Template HasSnaky 12 required_603_i0 envelope_603_i0 := by + refine compose HasSnaky 11 childrenC_603_i0 childrenD_603_i0 children_work_603_i0 (1, 2) + required_603_i0 envelope_603_i0 pivot_mem_603_i0 child_required_sub_603_i0 child_envelope_sub_603_i0 ?_ + intro b hb + exact common_sub_603_i0 (mem_commonEnvelope childrenD_603_i0 b hb) +def required_603 : Finset Cell := ⟨(([(1, 3), (1, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_603 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (0, 8), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_603 : Fin 7 → Finset Cell := ![(placed21 2 (2, 1) required_13), (placed21 6 (2, 7) required_14), (placed21 4 (0, 7) required_31), (placed21 2 (2, 1) required_189), (placed21 4 (0, 7) required_367), (placed21 0 (0, 2) required_457), required_603_i0] +def childrenD_603 : Fin 7 → Finset Cell := ![(placed21 2 (2, 1) envelope_13), (placed21 6 (2, 7) envelope_14), (placed21 4 (0, 7) envelope_31), (placed21 2 (2, 1) envelope_189), (placed21 4 (0, 7) envelope_367), (placed21 0 (0, 2) envelope_457), envelope_603_i0] +theorem common_sub_603 : commonEnvelope childrenD_603 ⊆ insert (1, 5) required_603 := by decide +kernel +theorem child_required_sub_603 : ∀ j, childrenC_603 j ⊆ insert (1, 5) required_603 := by decide +kernel +theorem child_envelope_sub_603 : ∀ j, childrenD_603 j ⊆ envelope_603 := by decide +kernel +theorem pivot_mem_603 : (1, 5) ∈ envelope_603 := by decide +kernel +theorem children_work_603 : ∀ j, Template HasSnaky 12 (childrenC_603 j) (childrenD_603 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 2 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_14 6 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_31 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_189 2 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_367 4 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_457 0 (0, 2)).mono (by decide +kernel) + · exact row_works_603_i0.mono (by decide +kernel) +theorem row_works_603 : Template HasSnaky 13 required_603 envelope_603 := by + refine compose HasSnaky 12 childrenC_603 childrenD_603 children_work_603 (1, 5) + required_603 envelope_603 pivot_mem_603 child_required_sub_603 child_envelope_sub_603 ?_ + intro b hb + exact common_sub_603 (mem_commonEnvelope childrenD_603 b hb) +def required_634 : Finset Cell := ⟨(([(3, 4), (3, 5), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_634 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_634 : Fin 5 → Finset Cell := ![(placed21 0 (0, 1) required_438), (placed21 0 (0, 1) required_452), (placed21 4 (3, 8) required_587), (placed21 7 (6, 5) required_612), required_633] +def childrenD_634 : Fin 5 → Finset Cell := ![(placed21 0 (0, 1) envelope_438), (placed21 0 (0, 1) envelope_452), (placed21 4 (3, 8) envelope_587), (placed21 7 (6, 5) envelope_612), envelope_633] +theorem common_sub_634 : commonEnvelope childrenD_634 ⊆ insert (5, 5) required_634 := by decide +kernel +theorem child_required_sub_634 : ∀ j, childrenC_634 j ⊆ insert (5, 5) required_634 := by decide +kernel +theorem child_envelope_sub_634 : ∀ j, childrenD_634 j ⊆ envelope_634 := by decide +kernel +theorem pivot_mem_634 : (5, 5) ∈ envelope_634 := by decide +kernel +theorem children_work_634 : ∀ j, Template HasSnaky 12 (childrenC_634 j) (childrenD_634 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_438 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_452 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_587 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_612 7 (6, 5)).mono (by decide +kernel) + · exact row_works_633.mono (by decide +kernel) +theorem row_works_634 : Template HasSnaky 13 required_634 envelope_634 := by + refine compose HasSnaky 12 childrenC_634 childrenD_634 children_work_634 (5, 5) + required_634 envelope_634 pivot_mem_634 child_required_sub_634 child_envelope_sub_634 ?_ + intro b hb + exact common_sub_634 (mem_commonEnvelope childrenD_634 b hb) +def required_642 : Finset Cell := ⟨(([(1, 4), (1, 5), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_642 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_642 : Fin 7 → Finset Cell := ![(placed21 0 (0, 1) required_299), (placed21 0 (0, 1) required_349), (placed21 0 (0, 1) required_476), (placed21 0 (1, 1) required_587), (placed21 4 (1, 8) required_587), (placed21 3 (0, 5) required_612), (placed21 0 (0, 2) required_641)] +def childrenD_642 : Fin 7 → Finset Cell := ![(placed21 0 (0, 1) envelope_299), (placed21 0 (0, 1) envelope_349), (placed21 0 (0, 1) envelope_476), (placed21 0 (1, 1) envelope_587), (placed21 4 (1, 8) envelope_587), (placed21 3 (0, 5) envelope_612), (placed21 0 (0, 2) envelope_641)] +theorem common_sub_642 : commonEnvelope childrenD_642 ⊆ insert (3, 5) required_642 := by decide +kernel +theorem child_required_sub_642 : ∀ j, childrenC_642 j ⊆ insert (3, 5) required_642 := by decide +kernel +theorem child_envelope_sub_642 : ∀ j, childrenD_642 j ⊆ envelope_642 := by decide +kernel +theorem pivot_mem_642 : (3, 5) ∈ envelope_642 := by decide +kernel +theorem children_work_642 : ∀ j, Template HasSnaky 12 (childrenC_642 j) (childrenD_642 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_299 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_349 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_476 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_587 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_587 4 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_612 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_641 0 (0, 2)).mono (by decide +kernel) +theorem row_works_642 : Template HasSnaky 13 required_642 envelope_642 := by + refine compose HasSnaky 12 childrenC_642 childrenD_642 children_work_642 (3, 5) + required_642 envelope_642 pivot_mem_642 child_required_sub_642 child_envelope_sub_642 ?_ + intro b hb + exact common_sub_642 (mem_commonEnvelope childrenD_642 b hb) +def required_643 : Finset Cell := ⟨(([(1, 4), (1, 5), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_643 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_643 : Fin 7 → Finset Cell := ![(placed21 4 (0, 8) required_299), (placed21 4 (0, 8) required_349), (placed21 4 (0, 8) required_476), (placed21 0 (1, 1) required_587), (placed21 4 (1, 8) required_587), (placed21 1 (0, 4) required_612), (placed21 4 (0, 7) required_641)] +def childrenD_643 : Fin 7 → Finset Cell := ![(placed21 4 (0, 8) envelope_299), (placed21 4 (0, 8) envelope_349), (placed21 4 (0, 8) envelope_476), (placed21 0 (1, 1) envelope_587), (placed21 4 (1, 8) envelope_587), (placed21 1 (0, 4) envelope_612), (placed21 4 (0, 7) envelope_641)] +theorem common_sub_643 : commonEnvelope childrenD_643 ⊆ insert (3, 5) required_643 := by decide +kernel +theorem child_required_sub_643 : ∀ j, childrenC_643 j ⊆ insert (3, 5) required_643 := by decide +kernel +theorem child_envelope_sub_643 : ∀ j, childrenD_643 j ⊆ envelope_643 := by decide +kernel +theorem pivot_mem_643 : (3, 5) ∈ envelope_643 := by decide +kernel +theorem children_work_643 : ∀ j, Template HasSnaky 12 (childrenC_643 j) (childrenD_643 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_299 4 (0, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_349 4 (0, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_476 4 (0, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_587 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_587 4 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_612 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_641 4 (0, 7)).mono (by decide +kernel) +theorem row_works_643 : Template HasSnaky 13 required_643 envelope_643 := by + refine compose HasSnaky 12 childrenC_643 childrenD_643 children_work_643 (3, 5) + required_643 envelope_643 pivot_mem_643 child_required_sub_643 child_envelope_sub_643 ?_ + intro b hb + exact common_sub_643 (mem_commonEnvelope childrenD_643 b hb) +def required_647_i1 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_647_i1 : Finset Cell := ⟨(([(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (5, 5), (6, 5), (6, 6), (7, 5), (7, 6), (8, 5), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_647_i1 : Fin 3 → Finset Cell := ![(placed21 7 (7, 5) required_15), (placed21 5 (8, 4) required_65), (placed21 6 (6, 7) required_282)] +def childrenD_647_i1 : Fin 3 → Finset Cell := ![(placed21 7 (7, 5) envelope_15), (placed21 5 (8, 4) envelope_65), (placed21 6 (6, 7) envelope_282)] +theorem common_sub_647_i1 : commonEnvelope childrenD_647_i1 ⊆ insert (6, 5) required_647_i1 := by decide +kernel +theorem child_required_sub_647_i1 : ∀ j, childrenC_647_i1 j ⊆ insert (6, 5) required_647_i1 := by decide +kernel +theorem child_envelope_sub_647_i1 : ∀ j, childrenD_647_i1 j ⊆ envelope_647_i1 := by decide +kernel +theorem pivot_mem_647_i1 : (6, 5) ∈ envelope_647_i1 := by decide +kernel +theorem children_work_647_i1 : ∀ j, Template HasSnaky 5 (childrenC_647_i1 j) (childrenD_647_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 7 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_65 5 (8, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_282 6 (6, 7)).mono (by decide +kernel) +theorem row_works_647_i1 : Template HasSnaky 6 required_647_i1 envelope_647_i1 := by + refine compose HasSnaky 5 childrenC_647_i1 childrenD_647_i1 children_work_647_i1 (6, 5) + required_647_i1 envelope_647_i1 pivot_mem_647_i1 child_required_sub_647_i1 child_envelope_sub_647_i1 ?_ + intro b hb + exact common_sub_647_i1 (mem_commonEnvelope childrenD_647_i1 b hb) +def required_647_i0 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_647_i0 : Finset Cell := ⟨(([(1, 2), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (7, 2), (7, 3), (7, 5), (7, 6), (8, 3), (8, 5), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_647_i0 : Fin 4 → Finset Cell := ![(placed21 5 (8, 2) required_600), (placed21 4 (2, 8) required_600), (placed21 1 (1, 1) required_621), required_647_i1] +def childrenD_647_i0 : Fin 4 → Finset Cell := ![(placed21 5 (8, 2) envelope_600), (placed21 4 (2, 8) envelope_600), (placed21 1 (1, 1) envelope_621), envelope_647_i1] +theorem common_sub_647_i0 : commonEnvelope childrenD_647_i0 ⊆ insert (5, 5) required_647_i0 := by decide +kernel +theorem child_required_sub_647_i0 : ∀ j, childrenC_647_i0 j ⊆ insert (5, 5) required_647_i0 := by decide +kernel +theorem child_envelope_sub_647_i0 : ∀ j, childrenD_647_i0 j ⊆ envelope_647_i0 := by decide +kernel +theorem pivot_mem_647_i0 : (5, 5) ∈ envelope_647_i0 := by decide +kernel +theorem children_work_647_i0 : ∀ j, Template HasSnaky 7 (childrenC_647_i0 j) (childrenD_647_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_600 5 (8, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_600 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_621 1 (1, 1)).mono (by decide +kernel) + · exact row_works_647_i1.mono (by decide +kernel) +theorem row_works_647_i0 : Template HasSnaky 8 required_647_i0 envelope_647_i0 := by + refine compose HasSnaky 7 childrenC_647_i0 childrenD_647_i0 children_work_647_i0 (5, 5) + required_647_i0 envelope_647_i0 pivot_mem_647_i0 child_required_sub_647_i0 child_envelope_sub_647_i0 ?_ + intro b hb + exact common_sub_647_i0 (mem_commonEnvelope childrenD_647_i0 b hb) +def required_647 : Finset Cell := ⟨(([(4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_647 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 3), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_647 : Fin 9 → Finset Cell := ![(placed21 7 (8, 6) required_399), (placed21 3 (1, 5) required_408), (placed21 3 (1, 5) required_410), (placed21 5 (9, 1) required_480), (placed21 1 (0, 3) required_546), (placed21 3 (1, 6) required_587), (placed21 7 (9, 6) required_635), (placed21 1 (1, 1) required_646), required_647_i0] +def childrenD_647 : Fin 9 → Finset Cell := ![(placed21 7 (8, 6) envelope_399), (placed21 3 (1, 5) envelope_408), (placed21 3 (1, 5) envelope_410), (placed21 5 (9, 1) envelope_480), (placed21 1 (0, 3) envelope_546), (placed21 3 (1, 6) envelope_587), (placed21 7 (9, 6) envelope_635), (placed21 1 (1, 1) envelope_646), envelope_647_i0] +theorem common_sub_647 : commonEnvelope childrenD_647 ⊆ insert (5, 4) required_647 := by decide +kernel +theorem child_required_sub_647 : ∀ j, childrenC_647 j ⊆ insert (5, 4) required_647 := by decide +kernel +theorem child_envelope_sub_647 : ∀ j, childrenD_647 j ⊆ envelope_647 := by decide +kernel +theorem pivot_mem_647 : (5, 4) ∈ envelope_647 := by decide +kernel +theorem children_work_647 : ∀ j, Template HasSnaky 12 (childrenC_647 j) (childrenD_647 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_399 7 (8, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_408 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_410 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_480 5 (9, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_546 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_587 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_635 7 (9, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_646 1 (1, 1)).mono (by decide +kernel) + · exact row_works_647_i0.mono (by decide +kernel) +theorem row_works_647 : Template HasSnaky 13 required_647 envelope_647 := by + refine compose HasSnaky 12 childrenC_647 childrenD_647 children_work_647 (5, 4) + required_647 envelope_647 pivot_mem_647 child_required_sub_647 child_envelope_sub_647 ?_ + intro b hb + exact common_sub_647 (mem_commonEnvelope childrenD_647 b hb) +def height_591_i0 : ℕ := 6 +def childrenH_591_i0 : Fin 2 → ℕ := ![height_5, height_265] +theorem height_exact_591_i0 : height_591_i0 = 1 + Finset.univ.sup childrenH_591_i0 := by decide +kernel +theorem required_origin_591_i0 : ∀ x ∈ required_591_i0, + (∃ j, x ∈ childrenC_591_i0 j) ∨ ∀ j, x ∈ childrenD_591_i0 j := by decide +kernel +theorem required_exact_591_i0 : required_591_i0 = + ((Finset.univ.biUnion childrenC_591_i0) ∪ commonEnvelope childrenD_591_i0).erase (3, 6) := by + exact required_eq_combination childrenC_591_i0 childrenD_591_i0 (3, 6) required_591_i0 + (by decide +kernel) child_required_sub_591_i0 common_sub_591_i0 required_origin_591_i0 +theorem envelope_origin_591_i0 : ∀ x ∈ envelope_591_i0, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_591_i0 j := by decide +kernel +theorem envelope_exact_591_i0 : envelope_591_i0 = + insert (3, 6) (Finset.univ.biUnion childrenD_591_i0) := by + exact envelope_eq_combination childrenD_591_i0 (3, 6) envelope_591_i0 + pivot_mem_591_i0 child_envelope_sub_591_i0 envelope_origin_591_i0 +def checked_591_i0 : CheckedCard where + required := required_591_i0 + envelope := envelope_591_i0 + height := height_591_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_591_i0 +def height_591_i1 : ℕ := 7 +def childrenH_591_i1 : Fin 5 → ℕ := ![height_12, height_13, height_14, height_289, height_435] +theorem height_exact_591_i1 : height_591_i1 = 1 + Finset.univ.sup childrenH_591_i1 := by decide +kernel +theorem required_origin_591_i1 : ∀ x ∈ required_591_i1, + (∃ j, x ∈ childrenC_591_i1 j) ∨ ∀ j, x ∈ childrenD_591_i1 j := by decide +kernel +theorem required_exact_591_i1 : required_591_i1 = + ((Finset.univ.biUnion childrenC_591_i1) ∪ commonEnvelope childrenD_591_i1).erase (4, 4) := by + exact required_eq_combination childrenC_591_i1 childrenD_591_i1 (4, 4) required_591_i1 + (by decide +kernel) child_required_sub_591_i1 common_sub_591_i1 required_origin_591_i1 +theorem envelope_origin_591_i1 : ∀ x ∈ envelope_591_i1, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_591_i1 j := by decide +kernel +theorem envelope_exact_591_i1 : envelope_591_i1 = + insert (4, 4) (Finset.univ.biUnion childrenD_591_i1) := by + exact envelope_eq_combination childrenD_591_i1 (4, 4) envelope_591_i1 + pivot_mem_591_i1 child_envelope_sub_591_i1 envelope_origin_591_i1 +def checked_591_i1 : CheckedCard where + required := required_591_i1 + envelope := envelope_591_i1 + height := height_591_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_591_i1 +def height_591_i4 : ℕ := 5 +def childrenH_591_i4 : Fin 2 → ℕ := ![height_17, height_80] +theorem height_exact_591_i4 : height_591_i4 = 1 + Finset.univ.sup childrenH_591_i4 := by decide +kernel +theorem required_origin_591_i4 : ∀ x ∈ required_591_i4, + (∃ j, x ∈ childrenC_591_i4 j) ∨ ∀ j, x ∈ childrenD_591_i4 j := by decide +kernel +theorem required_exact_591_i4 : required_591_i4 = + ((Finset.univ.biUnion childrenC_591_i4) ∪ commonEnvelope childrenD_591_i4).erase (3, 5) := by + exact required_eq_combination childrenC_591_i4 childrenD_591_i4 (3, 5) required_591_i4 + (by decide +kernel) child_required_sub_591_i4 common_sub_591_i4 required_origin_591_i4 +theorem envelope_origin_591_i4 : ∀ x ∈ envelope_591_i4, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_591_i4 j := by decide +kernel +theorem envelope_exact_591_i4 : envelope_591_i4 = + insert (3, 5) (Finset.univ.biUnion childrenD_591_i4) := by + exact envelope_eq_combination childrenD_591_i4 (3, 5) envelope_591_i4 + pivot_mem_591_i4 child_envelope_sub_591_i4 envelope_origin_591_i4 +def checked_591_i4 : CheckedCard where + required := required_591_i4 + envelope := envelope_591_i4 + height := height_591_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_591_i4 +def height_591_i3 : ℕ := 6 +def childrenH_591_i3 : Fin 3 → ℕ := ![height_109, height_157, height_591_i4] +theorem height_exact_591_i3 : height_591_i3 = 1 + Finset.univ.sup childrenH_591_i3 := by decide +kernel +theorem required_origin_591_i3 : ∀ x ∈ required_591_i3, + (∃ j, x ∈ childrenC_591_i3 j) ∨ ∀ j, x ∈ childrenD_591_i3 j := by decide +kernel +theorem required_exact_591_i3 : required_591_i3 = + ((Finset.univ.biUnion childrenC_591_i3) ∪ commonEnvelope childrenD_591_i3).erase (4, 3) := by + exact required_eq_combination childrenC_591_i3 childrenD_591_i3 (4, 3) required_591_i3 + (by decide +kernel) child_required_sub_591_i3 common_sub_591_i3 required_origin_591_i3 +theorem envelope_origin_591_i3 : ∀ x ∈ envelope_591_i3, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_591_i3 j := by decide +kernel +theorem envelope_exact_591_i3 : envelope_591_i3 = + insert (4, 3) (Finset.univ.biUnion childrenD_591_i3) := by + exact envelope_eq_combination childrenD_591_i3 (4, 3) envelope_591_i3 + pivot_mem_591_i3 child_envelope_sub_591_i3 envelope_origin_591_i3 +def checked_591_i3 : CheckedCard where + required := required_591_i3 + envelope := envelope_591_i3 + height := height_591_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_591_i3 +def height_591_i5 : ℕ := 6 +def childrenH_591_i5 : Fin 3 → ℕ := ![height_8, height_19, height_271] +theorem height_exact_591_i5 : height_591_i5 = 1 + Finset.univ.sup childrenH_591_i5 := by decide +kernel +theorem required_origin_591_i5 : ∀ x ∈ required_591_i5, + (∃ j, x ∈ childrenC_591_i5 j) ∨ ∀ j, x ∈ childrenD_591_i5 j := by decide +kernel +theorem required_exact_591_i5 : required_591_i5 = + ((Finset.univ.biUnion childrenC_591_i5) ∪ commonEnvelope childrenD_591_i5).erase (4, 3) := by + exact required_eq_combination childrenC_591_i5 childrenD_591_i5 (4, 3) required_591_i5 + (by decide +kernel) child_required_sub_591_i5 common_sub_591_i5 required_origin_591_i5 +theorem envelope_origin_591_i5 : ∀ x ∈ envelope_591_i5, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_591_i5 j := by decide +kernel +theorem envelope_exact_591_i5 : envelope_591_i5 = + insert (4, 3) (Finset.univ.biUnion childrenD_591_i5) := by + exact envelope_eq_combination childrenD_591_i5 (4, 3) envelope_591_i5 + pivot_mem_591_i5 child_envelope_sub_591_i5 envelope_origin_591_i5 +def checked_591_i5 : CheckedCard where + required := required_591_i5 + envelope := envelope_591_i5 + height := height_591_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_591_i5 +def height_591_i2 : ℕ := 12 +def childrenH_591_i2 : Fin 5 → ℕ := ![height_13, height_356, height_591_i3, height_586, height_591_i5] +theorem height_exact_591_i2 : height_591_i2 = 1 + Finset.univ.sup childrenH_591_i2 := by decide +kernel +theorem required_origin_591_i2 : ∀ x ∈ required_591_i2, + (∃ j, x ∈ childrenC_591_i2 j) ∨ ∀ j, x ∈ childrenD_591_i2 j := by decide +kernel +theorem required_exact_591_i2 : required_591_i2 = + ((Finset.univ.biUnion childrenC_591_i2) ∪ commonEnvelope childrenD_591_i2).erase (4, 4) := by + exact required_eq_combination childrenC_591_i2 childrenD_591_i2 (4, 4) required_591_i2 + (by decide +kernel) child_required_sub_591_i2 common_sub_591_i2 required_origin_591_i2 +theorem envelope_origin_591_i2 : ∀ x ∈ envelope_591_i2, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_591_i2 j := by decide +kernel +theorem envelope_exact_591_i2 : envelope_591_i2 = + insert (4, 4) (Finset.univ.biUnion childrenD_591_i2) := by + exact envelope_eq_combination childrenD_591_i2 (4, 4) envelope_591_i2 + pivot_mem_591_i2 child_envelope_sub_591_i2 envelope_origin_591_i2 +def checked_591_i2 : CheckedCard where + required := required_591_i2 + envelope := envelope_591_i2 + height := height_591_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_591_i2 +def height_591 : ℕ := 13 +def childrenH_591 : Fin 5 → ℕ := ![height_42, height_430, height_591_i0, height_591_i1, height_591_i2] +theorem height_exact_591 : height_591 = 1 + Finset.univ.sup childrenH_591 := by decide +kernel +theorem required_origin_591 : ∀ x ∈ required_591, + (∃ j, x ∈ childrenC_591 j) ∨ ∀ j, x ∈ childrenD_591 j := by decide +kernel +theorem required_exact_591 : required_591 = + ((Finset.univ.biUnion childrenC_591) ∪ commonEnvelope childrenD_591).erase (4, 6) := by + exact required_eq_combination childrenC_591 childrenD_591 (4, 6) required_591 + (by decide +kernel) child_required_sub_591 common_sub_591 required_origin_591 +theorem envelope_origin_591 : ∀ x ∈ envelope_591, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_591 j := by decide +kernel +theorem envelope_exact_591 : envelope_591 = + insert (4, 6) (Finset.univ.biUnion childrenD_591) := by + exact envelope_eq_combination childrenD_591 (4, 6) envelope_591 + pivot_mem_591 child_envelope_sub_591 envelope_origin_591 +def checked_591 : CheckedCard where + required := required_591 + envelope := envelope_591 + height := height_591 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_591 +def height_597_i0 : ℕ := 5 +def childrenH_597_i0 : Fin 3 → ℕ := ![height_13, height_109, height_291] +theorem height_exact_597_i0 : height_597_i0 = 1 + Finset.univ.sup childrenH_597_i0 := by decide +kernel +theorem required_origin_597_i0 : ∀ x ∈ required_597_i0, + (∃ j, x ∈ childrenC_597_i0 j) ∨ ∀ j, x ∈ childrenD_597_i0 j := by decide +kernel +theorem required_exact_597_i0 : required_597_i0 = + ((Finset.univ.biUnion childrenC_597_i0) ∪ commonEnvelope childrenD_597_i0).erase (5, 4) := by + exact required_eq_combination childrenC_597_i0 childrenD_597_i0 (5, 4) required_597_i0 + (by decide +kernel) child_required_sub_597_i0 common_sub_597_i0 required_origin_597_i0 +theorem envelope_origin_597_i0 : ∀ x ∈ envelope_597_i0, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_597_i0 j := by decide +kernel +theorem envelope_exact_597_i0 : envelope_597_i0 = + insert (5, 4) (Finset.univ.biUnion childrenD_597_i0) := by + exact envelope_eq_combination childrenD_597_i0 (5, 4) envelope_597_i0 + pivot_mem_597_i0 child_envelope_sub_597_i0 envelope_origin_597_i0 +def checked_597_i0 : CheckedCard where + required := required_597_i0 + envelope := envelope_597_i0 + height := height_597_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_597_i0 +def height_597_i3 : ℕ := 2 +def childrenH_597_i3 : Fin 2 → ℕ := ![height_5, height_5] +theorem height_exact_597_i3 : height_597_i3 = 1 + Finset.univ.sup childrenH_597_i3 := by decide +kernel +theorem required_origin_597_i3 : ∀ x ∈ required_597_i3, + (∃ j, x ∈ childrenC_597_i3 j) ∨ ∀ j, x ∈ childrenD_597_i3 j := by decide +kernel +theorem required_exact_597_i3 : required_597_i3 = + ((Finset.univ.biUnion childrenC_597_i3) ∪ commonEnvelope childrenD_597_i3).erase (4, 2) := by + exact required_eq_combination childrenC_597_i3 childrenD_597_i3 (4, 2) required_597_i3 + (by decide +kernel) child_required_sub_597_i3 common_sub_597_i3 required_origin_597_i3 +theorem envelope_origin_597_i3 : ∀ x ∈ envelope_597_i3, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_597_i3 j := by decide +kernel +theorem envelope_exact_597_i3 : envelope_597_i3 = + insert (4, 2) (Finset.univ.biUnion childrenD_597_i3) := by + exact envelope_eq_combination childrenD_597_i3 (4, 2) envelope_597_i3 + pivot_mem_597_i3 child_envelope_sub_597_i3 envelope_origin_597_i3 +def checked_597_i3 : CheckedCard where + required := required_597_i3 + envelope := envelope_597_i3 + height := height_597_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_597_i3 +def height_597_i2 : ℕ := 4 +def childrenH_597_i2 : Fin 2 → ℕ := ![height_7, height_597_i3] +theorem height_exact_597_i2 : height_597_i2 = 1 + Finset.univ.sup childrenH_597_i2 := by decide +kernel +theorem required_origin_597_i2 : ∀ x ∈ required_597_i2, + (∃ j, x ∈ childrenC_597_i2 j) ∨ ∀ j, x ∈ childrenD_597_i2 j := by decide +kernel +theorem required_exact_597_i2 : required_597_i2 = + ((Finset.univ.biUnion childrenC_597_i2) ∪ commonEnvelope childrenD_597_i2).erase (5, 2) := by + exact required_eq_combination childrenC_597_i2 childrenD_597_i2 (5, 2) required_597_i2 + (by decide +kernel) child_required_sub_597_i2 common_sub_597_i2 required_origin_597_i2 +theorem envelope_origin_597_i2 : ∀ x ∈ envelope_597_i2, + x = (5, 2) ∨ ∃ j, x ∈ childrenD_597_i2 j := by decide +kernel +theorem envelope_exact_597_i2 : envelope_597_i2 = + insert (5, 2) (Finset.univ.biUnion childrenD_597_i2) := by + exact envelope_eq_combination childrenD_597_i2 (5, 2) envelope_597_i2 + pivot_mem_597_i2 child_envelope_sub_597_i2 envelope_origin_597_i2 +def checked_597_i2 : CheckedCard where + required := required_597_i2 + envelope := envelope_597_i2 + height := height_597_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_597_i2 +def height_597_i6 : ℕ := 2 +def childrenH_597_i6 : Fin 2 → ℕ := ![height_4, height_4] +theorem height_exact_597_i6 : height_597_i6 = 1 + Finset.univ.sup childrenH_597_i6 := by decide +kernel +theorem required_origin_597_i6 : ∀ x ∈ required_597_i6, + (∃ j, x ∈ childrenC_597_i6 j) ∨ ∀ j, x ∈ childrenD_597_i6 j := by decide +kernel +theorem required_exact_597_i6 : required_597_i6 = + ((Finset.univ.biUnion childrenC_597_i6) ∪ commonEnvelope childrenD_597_i6).erase (6, 1) := by + exact required_eq_combination childrenC_597_i6 childrenD_597_i6 (6, 1) required_597_i6 + (by decide +kernel) child_required_sub_597_i6 common_sub_597_i6 required_origin_597_i6 +theorem envelope_origin_597_i6 : ∀ x ∈ envelope_597_i6, + x = (6, 1) ∨ ∃ j, x ∈ childrenD_597_i6 j := by decide +kernel +theorem envelope_exact_597_i6 : envelope_597_i6 = + insert (6, 1) (Finset.univ.biUnion childrenD_597_i6) := by + exact envelope_eq_combination childrenD_597_i6 (6, 1) envelope_597_i6 + pivot_mem_597_i6 child_envelope_sub_597_i6 envelope_origin_597_i6 +def checked_597_i6 : CheckedCard where + required := required_597_i6 + envelope := envelope_597_i6 + height := height_597_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_597_i6 +def height_597_i5 : ℕ := 3 +def childrenH_597_i5 : Fin 2 → ℕ := ![height_5, height_597_i6] +theorem height_exact_597_i5 : height_597_i5 = 1 + Finset.univ.sup childrenH_597_i5 := by decide +kernel +theorem required_origin_597_i5 : ∀ x ∈ required_597_i5, + (∃ j, x ∈ childrenC_597_i5 j) ∨ ∀ j, x ∈ childrenD_597_i5 j := by decide +kernel +theorem required_exact_597_i5 : required_597_i5 = + ((Finset.univ.biUnion childrenC_597_i5) ∪ commonEnvelope childrenD_597_i5).erase (5, 2) := by + exact required_eq_combination childrenC_597_i5 childrenD_597_i5 (5, 2) required_597_i5 + (by decide +kernel) child_required_sub_597_i5 common_sub_597_i5 required_origin_597_i5 +theorem envelope_origin_597_i5 : ∀ x ∈ envelope_597_i5, + x = (5, 2) ∨ ∃ j, x ∈ childrenD_597_i5 j := by decide +kernel +theorem envelope_exact_597_i5 : envelope_597_i5 = + insert (5, 2) (Finset.univ.biUnion childrenD_597_i5) := by + exact envelope_eq_combination childrenD_597_i5 (5, 2) envelope_597_i5 + pivot_mem_597_i5 child_envelope_sub_597_i5 envelope_origin_597_i5 +def checked_597_i5 : CheckedCard where + required := required_597_i5 + envelope := envelope_597_i5 + height := height_597_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_597_i5 +def height_597_i4 : ℕ := 4 +def childrenH_597_i4 : Fin 2 → ℕ := ![height_140, height_597_i5] +theorem height_exact_597_i4 : height_597_i4 = 1 + Finset.univ.sup childrenH_597_i4 := by decide +kernel +theorem required_origin_597_i4 : ∀ x ∈ required_597_i4, + (∃ j, x ∈ childrenC_597_i4 j) ∨ ∀ j, x ∈ childrenD_597_i4 j := by decide +kernel +theorem required_exact_597_i4 : required_597_i4 = + ((Finset.univ.biUnion childrenC_597_i4) ∪ commonEnvelope childrenD_597_i4).erase (4, 2) := by + exact required_eq_combination childrenC_597_i4 childrenD_597_i4 (4, 2) required_597_i4 + (by decide +kernel) child_required_sub_597_i4 common_sub_597_i4 required_origin_597_i4 +theorem envelope_origin_597_i4 : ∀ x ∈ envelope_597_i4, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_597_i4 j := by decide +kernel +theorem envelope_exact_597_i4 : envelope_597_i4 = + insert (4, 2) (Finset.univ.biUnion childrenD_597_i4) := by + exact envelope_eq_combination childrenD_597_i4 (4, 2) envelope_597_i4 + pivot_mem_597_i4 child_envelope_sub_597_i4 envelope_origin_597_i4 +def checked_597_i4 : CheckedCard where + required := required_597_i4 + envelope := envelope_597_i4 + height := height_597_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_597_i4 +def height_597_i1 : ℕ := 12 +def childrenH_597_i1 : Fin 3 → ℕ := ![height_597_i2, height_597_i4, height_596] +theorem height_exact_597_i1 : height_597_i1 = 1 + Finset.univ.sup childrenH_597_i1 := by decide +kernel +theorem required_origin_597_i1 : ∀ x ∈ required_597_i1, + (∃ j, x ∈ childrenC_597_i1 j) ∨ ∀ j, x ∈ childrenD_597_i1 j := by decide +kernel +theorem required_exact_597_i1 : required_597_i1 = + ((Finset.univ.biUnion childrenC_597_i1) ∪ commonEnvelope childrenD_597_i1).erase (5, 4) := by + exact required_eq_combination childrenC_597_i1 childrenD_597_i1 (5, 4) required_597_i1 + (by decide +kernel) child_required_sub_597_i1 common_sub_597_i1 required_origin_597_i1 +theorem envelope_origin_597_i1 : ∀ x ∈ envelope_597_i1, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_597_i1 j := by decide +kernel +theorem envelope_exact_597_i1 : envelope_597_i1 = + insert (5, 4) (Finset.univ.biUnion childrenD_597_i1) := by + exact envelope_eq_combination childrenD_597_i1 (5, 4) envelope_597_i1 + pivot_mem_597_i1 child_envelope_sub_597_i1 envelope_origin_597_i1 +def checked_597_i1 : CheckedCard where + required := required_597_i1 + envelope := envelope_597_i1 + height := height_597_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_597_i1 +def height_597 : ℕ := 13 +def childrenH_597 : Fin 5 → ℕ := ![height_272, height_290, height_593, height_597_i0, height_597_i1] +theorem height_exact_597 : height_597 = 1 + Finset.univ.sup childrenH_597 := by decide +kernel +theorem required_origin_597 : ∀ x ∈ required_597, + (∃ j, x ∈ childrenC_597 j) ∨ ∀ j, x ∈ childrenD_597 j := by decide +kernel +theorem required_exact_597 : required_597 = + ((Finset.univ.biUnion childrenC_597) ∪ commonEnvelope childrenD_597).erase (5, 5) := by + exact required_eq_combination childrenC_597 childrenD_597 (5, 5) required_597 + (by decide +kernel) child_required_sub_597 common_sub_597 required_origin_597 +theorem envelope_origin_597 : ∀ x ∈ envelope_597, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_597 j := by decide +kernel +theorem envelope_exact_597 : envelope_597 = + insert (5, 5) (Finset.univ.biUnion childrenD_597) := by + exact envelope_eq_combination childrenD_597 (5, 5) envelope_597 + pivot_mem_597 child_envelope_sub_597 envelope_origin_597 +def checked_597 : CheckedCard where + required := required_597 + envelope := envelope_597 + height := height_597 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_597 +def height_603_i0 : ℕ := 12 +def childrenH_603_i0 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_427] +theorem height_exact_603_i0 : height_603_i0 = 1 + Finset.univ.sup childrenH_603_i0 := by decide +kernel +theorem required_origin_603_i0 : ∀ x ∈ required_603_i0, + (∃ j, x ∈ childrenC_603_i0 j) ∨ ∀ j, x ∈ childrenD_603_i0 j := by decide +kernel +theorem required_exact_603_i0 : required_603_i0 = + ((Finset.univ.biUnion childrenC_603_i0) ∪ commonEnvelope childrenD_603_i0).erase (1, 2) := by + exact required_eq_combination childrenC_603_i0 childrenD_603_i0 (1, 2) required_603_i0 + (by decide +kernel) child_required_sub_603_i0 common_sub_603_i0 required_origin_603_i0 +theorem envelope_origin_603_i0 : ∀ x ∈ envelope_603_i0, + x = (1, 2) ∨ ∃ j, x ∈ childrenD_603_i0 j := by decide +kernel +theorem envelope_exact_603_i0 : envelope_603_i0 = + insert (1, 2) (Finset.univ.biUnion childrenD_603_i0) := by + exact envelope_eq_combination childrenD_603_i0 (1, 2) envelope_603_i0 + pivot_mem_603_i0 child_envelope_sub_603_i0 envelope_origin_603_i0 +def checked_603_i0 : CheckedCard where + required := required_603_i0 + envelope := envelope_603_i0 + height := height_603_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_603_i0 +def height_603 : ℕ := 13 +def childrenH_603 : Fin 7 → ℕ := ![height_13, height_14, height_31, height_189, height_367, height_457, height_603_i0] +theorem height_exact_603 : height_603 = 1 + Finset.univ.sup childrenH_603 := by decide +kernel +theorem required_origin_603 : ∀ x ∈ required_603, + (∃ j, x ∈ childrenC_603 j) ∨ ∀ j, x ∈ childrenD_603 j := by decide +kernel +theorem required_exact_603 : required_603 = + ((Finset.univ.biUnion childrenC_603) ∪ commonEnvelope childrenD_603).erase (1, 5) := by + exact required_eq_combination childrenC_603 childrenD_603 (1, 5) required_603 + (by decide +kernel) child_required_sub_603 common_sub_603 required_origin_603 +theorem envelope_origin_603 : ∀ x ∈ envelope_603, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_603 j := by decide +kernel +theorem envelope_exact_603 : envelope_603 = + insert (1, 5) (Finset.univ.biUnion childrenD_603) := by + exact envelope_eq_combination childrenD_603 (1, 5) envelope_603 + pivot_mem_603 child_envelope_sub_603 envelope_origin_603 +def checked_603 : CheckedCard where + required := required_603 + envelope := envelope_603 + height := height_603 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_603 +def height_634 : ℕ := 13 +def childrenH_634 : Fin 5 → ℕ := ![height_438, height_452, height_587, height_612, height_633] +theorem height_exact_634 : height_634 = 1 + Finset.univ.sup childrenH_634 := by decide +kernel +theorem required_origin_634 : ∀ x ∈ required_634, + (∃ j, x ∈ childrenC_634 j) ∨ ∀ j, x ∈ childrenD_634 j := by decide +kernel +theorem required_exact_634 : required_634 = + ((Finset.univ.biUnion childrenC_634) ∪ commonEnvelope childrenD_634).erase (5, 5) := by + exact required_eq_combination childrenC_634 childrenD_634 (5, 5) required_634 + (by decide +kernel) child_required_sub_634 common_sub_634 required_origin_634 +theorem envelope_origin_634 : ∀ x ∈ envelope_634, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_634 j := by decide +kernel +theorem envelope_exact_634 : envelope_634 = + insert (5, 5) (Finset.univ.biUnion childrenD_634) := by + exact envelope_eq_combination childrenD_634 (5, 5) envelope_634 + pivot_mem_634 child_envelope_sub_634 envelope_origin_634 +def checked_634 : CheckedCard where + required := required_634 + envelope := envelope_634 + height := height_634 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_634 +def height_642 : ℕ := 13 +def childrenH_642 : Fin 7 → ℕ := ![height_299, height_349, height_476, height_587, height_587, height_612, height_641] +theorem height_exact_642 : height_642 = 1 + Finset.univ.sup childrenH_642 := by decide +kernel +theorem required_origin_642 : ∀ x ∈ required_642, + (∃ j, x ∈ childrenC_642 j) ∨ ∀ j, x ∈ childrenD_642 j := by decide +kernel +theorem required_exact_642 : required_642 = + ((Finset.univ.biUnion childrenC_642) ∪ commonEnvelope childrenD_642).erase (3, 5) := by + exact required_eq_combination childrenC_642 childrenD_642 (3, 5) required_642 + (by decide +kernel) child_required_sub_642 common_sub_642 required_origin_642 +theorem envelope_origin_642 : ∀ x ∈ envelope_642, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_642 j := by decide +kernel +theorem envelope_exact_642 : envelope_642 = + insert (3, 5) (Finset.univ.biUnion childrenD_642) := by + exact envelope_eq_combination childrenD_642 (3, 5) envelope_642 + pivot_mem_642 child_envelope_sub_642 envelope_origin_642 +def checked_642 : CheckedCard where + required := required_642 + envelope := envelope_642 + height := height_642 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_642 +def height_643 : ℕ := 13 +def childrenH_643 : Fin 7 → ℕ := ![height_299, height_349, height_476, height_587, height_587, height_612, height_641] +theorem height_exact_643 : height_643 = 1 + Finset.univ.sup childrenH_643 := by decide +kernel +theorem required_origin_643 : ∀ x ∈ required_643, + (∃ j, x ∈ childrenC_643 j) ∨ ∀ j, x ∈ childrenD_643 j := by decide +kernel +theorem required_exact_643 : required_643 = + ((Finset.univ.biUnion childrenC_643) ∪ commonEnvelope childrenD_643).erase (3, 5) := by + exact required_eq_combination childrenC_643 childrenD_643 (3, 5) required_643 + (by decide +kernel) child_required_sub_643 common_sub_643 required_origin_643 +theorem envelope_origin_643 : ∀ x ∈ envelope_643, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_643 j := by decide +kernel +theorem envelope_exact_643 : envelope_643 = + insert (3, 5) (Finset.univ.biUnion childrenD_643) := by + exact envelope_eq_combination childrenD_643 (3, 5) envelope_643 + pivot_mem_643 child_envelope_sub_643 envelope_origin_643 +def checked_643 : CheckedCard where + required := required_643 + envelope := envelope_643 + height := height_643 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_643 +def height_647_i1 : ℕ := 6 +def childrenH_647_i1 : Fin 3 → ℕ := ![height_15, height_65, height_282] +theorem height_exact_647_i1 : height_647_i1 = 1 + Finset.univ.sup childrenH_647_i1 := by decide +kernel +theorem required_origin_647_i1 : ∀ x ∈ required_647_i1, + (∃ j, x ∈ childrenC_647_i1 j) ∨ ∀ j, x ∈ childrenD_647_i1 j := by decide +kernel +theorem required_exact_647_i1 : required_647_i1 = + ((Finset.univ.biUnion childrenC_647_i1) ∪ commonEnvelope childrenD_647_i1).erase (6, 5) := by + exact required_eq_combination childrenC_647_i1 childrenD_647_i1 (6, 5) required_647_i1 + (by decide +kernel) child_required_sub_647_i1 common_sub_647_i1 required_origin_647_i1 +theorem envelope_origin_647_i1 : ∀ x ∈ envelope_647_i1, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_647_i1 j := by decide +kernel +theorem envelope_exact_647_i1 : envelope_647_i1 = + insert (6, 5) (Finset.univ.biUnion childrenD_647_i1) := by + exact envelope_eq_combination childrenD_647_i1 (6, 5) envelope_647_i1 + pivot_mem_647_i1 child_envelope_sub_647_i1 envelope_origin_647_i1 +def checked_647_i1 : CheckedCard where + required := required_647_i1 + envelope := envelope_647_i1 + height := height_647_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_647_i1 +def height_647_i0 : ℕ := 8 +def childrenH_647_i0 : Fin 4 → ℕ := ![height_600, height_600, height_621, height_647_i1] +theorem height_exact_647_i0 : height_647_i0 = 1 + Finset.univ.sup childrenH_647_i0 := by decide +kernel +theorem required_origin_647_i0 : ∀ x ∈ required_647_i0, + (∃ j, x ∈ childrenC_647_i0 j) ∨ ∀ j, x ∈ childrenD_647_i0 j := by decide +kernel +theorem required_exact_647_i0 : required_647_i0 = + ((Finset.univ.biUnion childrenC_647_i0) ∪ commonEnvelope childrenD_647_i0).erase (5, 5) := by + exact required_eq_combination childrenC_647_i0 childrenD_647_i0 (5, 5) required_647_i0 + (by decide +kernel) child_required_sub_647_i0 common_sub_647_i0 required_origin_647_i0 +theorem envelope_origin_647_i0 : ∀ x ∈ envelope_647_i0, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_647_i0 j := by decide +kernel +theorem envelope_exact_647_i0 : envelope_647_i0 = + insert (5, 5) (Finset.univ.biUnion childrenD_647_i0) := by + exact envelope_eq_combination childrenD_647_i0 (5, 5) envelope_647_i0 + pivot_mem_647_i0 child_envelope_sub_647_i0 envelope_origin_647_i0 +def checked_647_i0 : CheckedCard where + required := required_647_i0 + envelope := envelope_647_i0 + height := height_647_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_647_i0 +def height_647 : ℕ := 13 +def childrenH_647 : Fin 9 → ℕ := ![height_399, height_408, height_410, height_480, height_546, height_587, height_635, height_646, height_647_i0] +theorem height_exact_647 : height_647 = 1 + Finset.univ.sup childrenH_647 := by decide +kernel +theorem required_origin_647 : ∀ x ∈ required_647, + (∃ j, x ∈ childrenC_647 j) ∨ ∀ j, x ∈ childrenD_647 j := by decide +kernel +theorem required_exact_647 : required_647 = + ((Finset.univ.biUnion childrenC_647) ∪ commonEnvelope childrenD_647).erase (5, 4) := by + exact required_eq_combination childrenC_647 childrenD_647 (5, 4) required_647 + (by decide +kernel) child_required_sub_647 common_sub_647 required_origin_647 +theorem envelope_origin_647 : ∀ x ∈ envelope_647, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_647 j := by decide +kernel +theorem envelope_exact_647 : envelope_647 = + insert (5, 4) (Finset.univ.biUnion childrenD_647) := by + exact envelope_eq_combination childrenD_647 (5, 4) envelope_647 + pivot_mem_647 child_envelope_sub_647 envelope_origin_647 +def checked_647 : CheckedCard where + required := required_647 + envelope := envelope_647 + height := height_647 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_647 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part04.lean new file mode 100644 index 0000000..78e30dd --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part04.lean @@ -0,0 +1,713 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_650_i0 : Finset Cell := ⟨(([(3, 5), (4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_650_i0 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (7, 4), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_650_i0 : Fin 2 → Finset Cell := ![(placed21 3 (2, 5) required_52), (placed21 2 (6, 0) required_545)] +def childrenD_650_i0 : Fin 2 → Finset Cell := ![(placed21 3 (2, 5) envelope_52), (placed21 2 (6, 0) envelope_545)] +theorem common_sub_650_i0 : commonEnvelope childrenD_650_i0 ⊆ insert (5, 4) required_650_i0 := by decide +kernel +theorem child_required_sub_650_i0 : ∀ j, childrenC_650_i0 j ⊆ insert (5, 4) required_650_i0 := by decide +kernel +theorem child_envelope_sub_650_i0 : ∀ j, childrenD_650_i0 j ⊆ envelope_650_i0 := by decide +kernel +theorem pivot_mem_650_i0 : (5, 4) ∈ envelope_650_i0 := by decide +kernel +theorem children_work_650_i0 : ∀ j, Template HasSnaky 10 (childrenC_650_i0 j) (childrenD_650_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 3 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_545 2 (6, 0)).mono (by decide +kernel) +theorem row_works_650_i0 : Template HasSnaky 11 required_650_i0 envelope_650_i0 := by + refine compose HasSnaky 10 childrenC_650_i0 childrenD_650_i0 children_work_650_i0 (5, 4) + required_650_i0 envelope_650_i0 pivot_mem_650_i0 child_required_sub_650_i0 child_envelope_sub_650_i0 ?_ + intro b hb + exact common_sub_650_i0 (mem_commonEnvelope childrenD_650_i0 b hb) +def required_650 : Finset Cell := ⟨(([(3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_650 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (1, 4), (1, 6), (1, 7), (1, 8), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_650 : Fin 7 → Finset Cell := ![(placed21 1 (1, 4) required_13), (placed21 1 (1, 4) required_14), (placed21 4 (2, 8) required_257), (placed21 4 (2, 8) required_435), (placed21 0 (2, 2) required_507), (placed21 4 (1, 10) required_649), required_650_i0] +def childrenD_650 : Fin 7 → Finset Cell := ![(placed21 1 (1, 4) envelope_13), (placed21 1 (1, 4) envelope_14), (placed21 4 (2, 8) envelope_257), (placed21 4 (2, 8) envelope_435), (placed21 0 (2, 2) envelope_507), (placed21 4 (1, 10) envelope_649), envelope_650_i0] +theorem common_sub_650 : commonEnvelope childrenD_650 ⊆ insert (5, 5) required_650 := by decide +kernel +theorem child_required_sub_650 : ∀ j, childrenC_650 j ⊆ insert (5, 5) required_650 := by decide +kernel +theorem child_envelope_sub_650 : ∀ j, childrenD_650 j ⊆ envelope_650 := by decide +kernel +theorem pivot_mem_650 : (5, 5) ∈ envelope_650 := by decide +kernel +theorem children_work_650 : ∀ j, Template HasSnaky 12 (childrenC_650 j) (childrenD_650 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_14 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_257 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_435 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_507 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_649 4 (1, 10)).mono (by decide +kernel) + · exact row_works_650_i0.mono (by decide +kernel) +theorem row_works_650 : Template HasSnaky 13 required_650 envelope_650 := by + refine compose HasSnaky 12 childrenC_650 childrenD_650 children_work_650 (5, 5) + required_650 envelope_650 pivot_mem_650 child_required_sub_650 child_envelope_sub_650 ?_ + intro b hb + exact common_sub_650 (mem_commonEnvelope childrenD_650 b hb) +def required_657_i1 : Finset Cell := ⟨(([(2, 2), (2, 3), (4, 3), (4, 4), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_657_i1 : Finset Cell := ⟨(([(1, 1), (1, 2), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (5, 3), (5, 4), (6, 3), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_657_i1 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) required_54), (placed21 2 (5, 1) required_79)] +def childrenD_657_i1 : Fin 2 → Finset Cell := ![(placed21 3 (1, 4) envelope_54), (placed21 2 (5, 1) envelope_79)] +theorem common_sub_657_i1 : commonEnvelope childrenD_657_i1 ⊆ insert (2, 4) required_657_i1 := by decide +kernel +theorem child_required_sub_657_i1 : ∀ j, childrenC_657_i1 j ⊆ insert (2, 4) required_657_i1 := by decide +kernel +theorem child_envelope_sub_657_i1 : ∀ j, childrenD_657_i1 j ⊆ envelope_657_i1 := by decide +kernel +theorem pivot_mem_657_i1 : (2, 4) ∈ envelope_657_i1 := by decide +kernel +theorem children_work_657_i1 : ∀ j, Template HasSnaky 4 (childrenC_657_i1 j) (childrenD_657_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 3 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_79 2 (5, 1)).mono (by decide +kernel) +theorem row_works_657_i1 : Template HasSnaky 5 required_657_i1 envelope_657_i1 := by + refine compose HasSnaky 4 childrenC_657_i1 childrenD_657_i1 children_work_657_i1 (2, 4) + required_657_i1 envelope_657_i1 pivot_mem_657_i1 child_required_sub_657_i1 child_envelope_sub_657_i1 ?_ + intro b hb + exact common_sub_657_i1 (mem_commonEnvelope childrenD_657_i1 b hb) +def required_657_i2 : Finset Cell := ⟨(([(2, 2), (4, 3), (4, 4), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_657_i2 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 4), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (7, 3), (7, 4), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_657_i2 : Fin 3 → Finset Cell := ![(placed21 1 (1, 2) required_54), (placed21 2 (5, 1) required_71), (placed21 1 (2, 1) required_345)] +def childrenD_657_i2 : Fin 3 → Finset Cell := ![(placed21 1 (1, 2) envelope_54), (placed21 2 (5, 1) envelope_71), (placed21 1 (2, 1) envelope_345)] +theorem common_sub_657_i2 : commonEnvelope childrenD_657_i2 ⊆ insert (4, 2) required_657_i2 := by decide +kernel +theorem child_required_sub_657_i2 : ∀ j, childrenC_657_i2 j ⊆ insert (4, 2) required_657_i2 := by decide +kernel +theorem child_envelope_sub_657_i2 : ∀ j, childrenD_657_i2 j ⊆ envelope_657_i2 := by decide +kernel +theorem pivot_mem_657_i2 : (4, 2) ∈ envelope_657_i2 := by decide +kernel +theorem children_work_657_i2 : ∀ j, Template HasSnaky 8 (childrenC_657_i2 j) (childrenD_657_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_71 2 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_345 1 (2, 1)).mono (by decide +kernel) +theorem row_works_657_i2 : Template HasSnaky 9 required_657_i2 envelope_657_i2 := by + refine compose HasSnaky 8 childrenC_657_i2 childrenD_657_i2 children_work_657_i2 (4, 2) + required_657_i2 envelope_657_i2 pivot_mem_657_i2 child_required_sub_657_i2 child_envelope_sub_657_i2 ?_ + intro b hb + exact common_sub_657_i2 (mem_commonEnvelope childrenD_657_i2 b hb) +def required_657_i6 : Finset Cell := ⟨(([(3, 4), (4, 3), (4, 4), (5, 3), (5, 4), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_657_i6 : Finset Cell := ⟨(([(3, 4), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2), (7, 3), (7, 5), (8, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_657_i6 : Fin 2 → Finset Cell := ![(placed21 4 (3, 4) required_5), (placed21 4 (3, 5) required_445)] +def childrenD_657_i6 : Fin 2 → Finset Cell := ![(placed21 4 (3, 4) envelope_5), (placed21 4 (3, 5) envelope_445)] +theorem common_sub_657_i6 : commonEnvelope childrenD_657_i6 ⊆ insert (6, 3) required_657_i6 := by decide +kernel +theorem child_required_sub_657_i6 : ∀ j, childrenC_657_i6 j ⊆ insert (6, 3) required_657_i6 := by decide +kernel +theorem child_envelope_sub_657_i6 : ∀ j, childrenD_657_i6 j ⊆ envelope_657_i6 := by decide +kernel +theorem pivot_mem_657_i6 : (6, 3) ∈ envelope_657_i6 := by decide +kernel +theorem children_work_657_i6 : ∀ j, Template HasSnaky 5 (childrenC_657_i6 j) (childrenD_657_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_445 4 (3, 5)).mono (by decide +kernel) +theorem row_works_657_i6 : Template HasSnaky 6 required_657_i6 envelope_657_i6 := by + refine compose HasSnaky 5 childrenC_657_i6 childrenD_657_i6 children_work_657_i6 (6, 3) + required_657_i6 envelope_657_i6 pivot_mem_657_i6 child_required_sub_657_i6 child_envelope_sub_657_i6 ?_ + intro b hb + exact common_sub_657_i6 (mem_commonEnvelope childrenD_657_i6 b hb) +def required_657_i5 : Finset Cell := ⟨(([(3, 4), (4, 3), (4, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_657_i5 : Finset Cell := ⟨(([(3, 4), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (8, 2), (8, 3), (8, 4), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_657_i5 : Fin 3 → Finset Cell := ![(placed21 1 (3, 3) required_20), (placed21 3 (3, 4) required_29), required_657_i6] +def childrenD_657_i5 : Fin 3 → Finset Cell := ![(placed21 1 (3, 3) envelope_20), (placed21 3 (3, 4) envelope_29), envelope_657_i6] +theorem common_sub_657_i5 : commonEnvelope childrenD_657_i5 ⊆ insert (6, 4) required_657_i5 := by decide +kernel +theorem child_required_sub_657_i5 : ∀ j, childrenC_657_i5 j ⊆ insert (6, 4) required_657_i5 := by decide +kernel +theorem child_envelope_sub_657_i5 : ∀ j, childrenD_657_i5 j ⊆ envelope_657_i5 := by decide +kernel +theorem pivot_mem_657_i5 : (6, 4) ∈ envelope_657_i5 := by decide +kernel +theorem children_work_657_i5 : ∀ j, Template HasSnaky 6 (childrenC_657_i5 j) (childrenD_657_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_20 1 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_29 3 (3, 4)).mono (by decide +kernel) + · exact row_works_657_i6.mono (by decide +kernel) +theorem row_works_657_i5 : Template HasSnaky 7 required_657_i5 envelope_657_i5 := by + refine compose HasSnaky 6 childrenC_657_i5 childrenD_657_i5 children_work_657_i5 (6, 4) + required_657_i5 envelope_657_i5 pivot_mem_657_i5 child_required_sub_657_i5 child_envelope_sub_657_i5 ?_ + intro b hb + exact common_sub_657_i5 (mem_commonEnvelope childrenD_657_i5 b hb) +def required_657_i4 : Finset Cell := ⟨(([(4, 3), (4, 4), (5, 3), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_657_i4 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5), (4, 3), (4, 4), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (8, 2), (8, 3), (8, 4), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_657_i4 : Fin 3 → Finset Cell := ![(placed21 3 (2, 4) required_15), (placed21 1 (1, 3) required_65), required_657_i5] +def childrenD_657_i4 : Fin 3 → Finset Cell := ![(placed21 3 (2, 4) envelope_15), (placed21 1 (1, 3) envelope_65), envelope_657_i5] +theorem common_sub_657_i4 : commonEnvelope childrenD_657_i4 ⊆ insert (3, 4) required_657_i4 := by decide +kernel +theorem child_required_sub_657_i4 : ∀ j, childrenC_657_i4 j ⊆ insert (3, 4) required_657_i4 := by decide +kernel +theorem child_envelope_sub_657_i4 : ∀ j, childrenD_657_i4 j ⊆ envelope_657_i4 := by decide +kernel +theorem pivot_mem_657_i4 : (3, 4) ∈ envelope_657_i4 := by decide +kernel +theorem children_work_657_i4 : ∀ j, Template HasSnaky 7 (childrenC_657_i4 j) (childrenD_657_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 3 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_65 1 (1, 3)).mono (by decide +kernel) + · exact row_works_657_i5.mono (by decide +kernel) +theorem row_works_657_i4 : Template HasSnaky 8 required_657_i4 envelope_657_i4 := by + refine compose HasSnaky 7 childrenC_657_i4 childrenD_657_i4 children_work_657_i4 (3, 4) + required_657_i4 envelope_657_i4 pivot_mem_657_i4 child_required_sub_657_i4 child_envelope_sub_657_i4 ?_ + intro b hb + exact common_sub_657_i4 (mem_commonEnvelope childrenD_657_i4 b hb) +def required_657_i3 : Finset Cell := ⟨(([(4, 3), (4, 4), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_657_i3 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_657_i3 : Fin 5 → Finset Cell := ![(placed21 5 (8, 2) required_85), (placed21 4 (3, 7) required_85), (placed21 4 (4, 7) required_411), (placed21 5 (8, 2) required_537), required_657_i4] +def childrenD_657_i3 : Fin 5 → Finset Cell := ![(placed21 5 (8, 2) envelope_85), (placed21 4 (3, 7) envelope_85), (placed21 4 (4, 7) envelope_411), (placed21 5 (8, 2) envelope_537), envelope_657_i4] +theorem common_sub_657_i3 : commonEnvelope childrenD_657_i3 ⊆ insert (5, 4) required_657_i3 := by decide +kernel +theorem child_required_sub_657_i3 : ∀ j, childrenC_657_i3 j ⊆ insert (5, 4) required_657_i3 := by decide +kernel +theorem child_envelope_sub_657_i3 : ∀ j, childrenD_657_i3 j ⊆ envelope_657_i3 := by decide +kernel +theorem pivot_mem_657_i3 : (5, 4) ∈ envelope_657_i3 := by decide +kernel +theorem children_work_657_i3 : ∀ j, Template HasSnaky 10 (childrenC_657_i3 j) (childrenD_657_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_85 5 (8, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_85 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_411 4 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_537 5 (8, 2)).mono (by decide +kernel) + · exact row_works_657_i4.mono (by decide +kernel) +theorem row_works_657_i3 : Template HasSnaky 11 required_657_i3 envelope_657_i3 := by + refine compose HasSnaky 10 childrenC_657_i3 childrenD_657_i3 children_work_657_i3 (5, 4) + required_657_i3 envelope_657_i3 pivot_mem_657_i3 child_required_sub_657_i3 child_envelope_sub_657_i3 ?_ + intro b hb + exact common_sub_657_i3 (mem_commonEnvelope childrenD_657_i3 b hb) +def required_657_i0 : Finset Cell := ⟨(([(2, 2), (2, 3), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_657_i0 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 1), (1, 2), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 2), (9, 4), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_657_i0 : Fin 6 → Finset Cell := ![(placed21 1 (1, 1) required_510), (placed21 0 (1, 0) required_631), (placed21 1 (1, 0) required_653), required_657_i1, required_657_i2, required_657_i3] +def childrenD_657_i0 : Fin 6 → Finset Cell := ![(placed21 1 (1, 1) envelope_510), (placed21 0 (1, 0) envelope_631), (placed21 1 (1, 0) envelope_653), envelope_657_i1, envelope_657_i2, envelope_657_i3] +theorem common_sub_657_i0 : commonEnvelope childrenD_657_i0 ⊆ insert (4, 4) required_657_i0 := by decide +kernel +theorem child_required_sub_657_i0 : ∀ j, childrenC_657_i0 j ⊆ insert (4, 4) required_657_i0 := by decide +kernel +theorem child_envelope_sub_657_i0 : ∀ j, childrenD_657_i0 j ⊆ envelope_657_i0 := by decide +kernel +theorem pivot_mem_657_i0 : (4, 4) ∈ envelope_657_i0 := by decide +kernel +theorem children_work_657_i0 : ∀ j, Template HasSnaky 11 (childrenC_657_i0 j) (childrenD_657_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_510 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_631 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_653 1 (1, 0)).mono (by decide +kernel) + · exact row_works_657_i1.mono (by decide +kernel) + · exact row_works_657_i2.mono (by decide +kernel) + · exact row_works_657_i3.mono (by decide +kernel) +theorem row_works_657_i0 : Template HasSnaky 12 required_657_i0 envelope_657_i0 := by + refine compose HasSnaky 11 childrenC_657_i0 childrenD_657_i0 children_work_657_i0 (4, 4) + required_657_i0 envelope_657_i0 pivot_mem_657_i0 child_required_sub_657_i0 child_envelope_sub_657_i0 ?_ + intro b hb + exact common_sub_657_i0 (mem_commonEnvelope childrenD_657_i0 b hb) +def required_657 : Finset Cell := ⟨(([(2, 2), (2, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_657 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 1), (1, 2), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 2), (9, 4), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_657 : Fin 5 → Finset Cell := ![(placed21 1 (1, 2) required_50), (placed21 1 (1, 2) required_125), (placed21 0 (1, 1) required_478), (placed21 0 (1, 1) required_482), required_657_i0] +def childrenD_657 : Fin 5 → Finset Cell := ![(placed21 1 (1, 2) envelope_50), (placed21 1 (1, 2) envelope_125), (placed21 0 (1, 1) envelope_478), (placed21 0 (1, 1) envelope_482), envelope_657_i0] +theorem common_sub_657 : commonEnvelope childrenD_657 ⊆ insert (4, 3) required_657 := by decide +kernel +theorem child_required_sub_657 : ∀ j, childrenC_657 j ⊆ insert (4, 3) required_657 := by decide +kernel +theorem child_envelope_sub_657 : ∀ j, childrenD_657 j ⊆ envelope_657 := by decide +kernel +theorem pivot_mem_657 : (4, 3) ∈ envelope_657 := by decide +kernel +theorem children_work_657 : ∀ j, Template HasSnaky 12 (childrenC_657 j) (childrenD_657 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_50 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_125 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_478 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_482 0 (1, 1)).mono (by decide +kernel) + · exact row_works_657_i0.mono (by decide +kernel) +theorem row_works_657 : Template HasSnaky 13 required_657 envelope_657 := by + refine compose HasSnaky 12 childrenC_657 childrenD_657 children_work_657 (4, 3) + required_657 envelope_657 pivot_mem_657 child_required_sub_657 child_envelope_sub_657 ?_ + intro b hb + exact common_sub_657 (mem_commonEnvelope childrenD_657 b hb) +def required_665_i0 : Finset Cell := ⟨(([(3, 3), (3, 6), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_665_i0 : Finset Cell := ⟨(([(0, 7), (0, 9), (1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 8), (3, 9), (3, 10), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 3), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (5, 10), (6, 7), (6, 8), (6, 9), (7, 7), (7, 8), (7, 9), (8, 7), (8, 8), (8, 9), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_665_i0 : Fin 4 → Finset Cell := ![(placed21 6 (4, 7) required_70), (placed21 0 (3, 3) required_106), (placed21 0 (3, 3) required_269), (placed21 1 (0, 4) required_322)] +def childrenD_665_i0 : Fin 4 → Finset Cell := ![(placed21 6 (4, 7) envelope_70), (placed21 0 (3, 3) envelope_106), (placed21 0 (3, 3) envelope_269), (placed21 1 (0, 4) envelope_322)] +theorem common_sub_665_i0 : commonEnvelope childrenD_665_i0 ⊆ insert (4, 7) required_665_i0 := by decide +kernel +theorem child_required_sub_665_i0 : ∀ j, childrenC_665_i0 j ⊆ insert (4, 7) required_665_i0 := by decide +kernel +theorem child_envelope_sub_665_i0 : ∀ j, childrenD_665_i0 j ⊆ envelope_665_i0 := by decide +kernel +theorem pivot_mem_665_i0 : (4, 7) ∈ envelope_665_i0 := by decide +kernel +theorem children_work_665_i0 : ∀ j, Template HasSnaky 9 (childrenC_665_i0 j) (childrenD_665_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_70 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_106 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_269 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_322 1 (0, 4)).mono (by decide +kernel) +theorem row_works_665_i0 : Template HasSnaky 10 required_665_i0 envelope_665_i0 := by + refine compose HasSnaky 9 childrenC_665_i0 childrenD_665_i0 children_work_665_i0 (4, 7) + required_665_i0 envelope_665_i0 pivot_mem_665_i0 child_required_sub_665_i0 child_envelope_sub_665_i0 ?_ + intro b hb + exact common_sub_665_i0 (mem_commonEnvelope childrenD_665_i0 b hb) +def required_665_i1 : Finset Cell := ⟨(([(3, 3), (3, 6), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_665_i1 : Finset Cell := ⟨(([(0, 8), (0, 9), (1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 6), (6, 7), (6, 8), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_665_i1 : Fin 3 → Finset Cell := ![(placed21 6 (4, 7) required_70), (placed21 5 (7, 4) required_257), (placed21 5 (7, 4) required_435)] +def childrenD_665_i1 : Fin 3 → Finset Cell := ![(placed21 6 (4, 7) envelope_70), (placed21 5 (7, 4) envelope_257), (placed21 5 (7, 4) envelope_435)] +theorem common_sub_665_i1 : commonEnvelope childrenD_665_i1 ⊆ insert (4, 7) required_665_i1 := by decide +kernel +theorem child_required_sub_665_i1 : ∀ j, childrenC_665_i1 j ⊆ insert (4, 7) required_665_i1 := by decide +kernel +theorem child_envelope_sub_665_i1 : ∀ j, childrenD_665_i1 j ⊆ envelope_665_i1 := by decide +kernel +theorem pivot_mem_665_i1 : (4, 7) ∈ envelope_665_i1 := by decide +kernel +theorem children_work_665_i1 : ∀ j, Template HasSnaky 8 (childrenC_665_i1 j) (childrenD_665_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_70 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_257 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (7, 4)).mono (by decide +kernel) +theorem row_works_665_i1 : Template HasSnaky 9 required_665_i1 envelope_665_i1 := by + refine compose HasSnaky 8 childrenC_665_i1 childrenD_665_i1 children_work_665_i1 (4, 7) + required_665_i1 envelope_665_i1 pivot_mem_665_i1 child_required_sub_665_i1 child_envelope_sub_665_i1 ?_ + intro b hb + exact common_sub_665_i1 (mem_commonEnvelope childrenD_665_i1 b hb) +def required_665_i4 : Finset Cell := ⟨(([(2, 3), (3, 4), (3, 5), (3, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_665_i4 : Finset Cell := ⟨(([(2, 3), (2, 4), (2, 7), (2, 8), (2, 9), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 8), (4, 9), (4, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_665_i4 : Fin 2 → Finset Cell := ![(placed21 7 (3, 7) required_4), (placed21 5 (4, 4) required_93)] +def childrenD_665_i4 : Fin 2 → Finset Cell := ![(placed21 7 (3, 7) envelope_4), (placed21 5 (4, 4) envelope_93)] +theorem common_sub_665_i4 : commonEnvelope childrenD_665_i4 ⊆ insert (3, 7) required_665_i4 := by decide +kernel +theorem child_required_sub_665_i4 : ∀ j, childrenC_665_i4 j ⊆ insert (3, 7) required_665_i4 := by decide +kernel +theorem child_envelope_sub_665_i4 : ∀ j, childrenD_665_i4 j ⊆ envelope_665_i4 := by decide +kernel +theorem pivot_mem_665_i4 : (3, 7) ∈ envelope_665_i4 := by decide +kernel +theorem children_work_665_i4 : ∀ j, Template HasSnaky 4 (childrenC_665_i4 j) (childrenD_665_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 7 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_93 5 (4, 4)).mono (by decide +kernel) +theorem row_works_665_i4 : Template HasSnaky 5 required_665_i4 envelope_665_i4 := by + refine compose HasSnaky 4 childrenC_665_i4 childrenD_665_i4 children_work_665_i4 (3, 7) + required_665_i4 envelope_665_i4 pivot_mem_665_i4 child_required_sub_665_i4 child_envelope_sub_665_i4 ?_ + intro b hb + exact common_sub_665_i4 (mem_commonEnvelope childrenD_665_i4 b hb) +def required_665_i3 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 5), (3, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_665_i3 : Finset Cell := ⟨(([(2, 2), (2, 3), (2, 4), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 8), (4, 9), (4, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_665_i3 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) required_5), required_665_i4] +def childrenD_665_i3 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) envelope_5), envelope_665_i4] +theorem common_sub_665_i3 : commonEnvelope childrenD_665_i3 ⊆ insert (3, 4) required_665_i3 := by decide +kernel +theorem child_required_sub_665_i3 : ∀ j, childrenC_665_i3 j ⊆ insert (3, 4) required_665_i3 := by decide +kernel +theorem child_envelope_sub_665_i3 : ∀ j, childrenD_665_i3 j ⊆ envelope_665_i3 := by decide +kernel +theorem pivot_mem_665_i3 : (3, 4) ∈ envelope_665_i3 := by decide +kernel +theorem children_work_665_i3 : ∀ j, Template HasSnaky 5 (childrenC_665_i3 j) (childrenD_665_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (3, 6)).mono (by decide +kernel) + · exact row_works_665_i4.mono (by decide +kernel) +theorem row_works_665_i3 : Template HasSnaky 6 required_665_i3 envelope_665_i3 := by + refine compose HasSnaky 5 childrenC_665_i3 childrenD_665_i3 children_work_665_i3 (3, 4) + required_665_i3 envelope_665_i3 pivot_mem_665_i3 child_required_sub_665_i3 child_envelope_sub_665_i3 ?_ + intro b hb + exact common_sub_665_i3 (mem_commonEnvelope childrenD_665_i3 b hb) +def required_665_i2 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 6), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_665_i2 : Finset Cell := ⟨(([(0, 7), (0, 8), (0, 9), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 7), (8, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_665_i2 : Fin 3 → Finset Cell := ![(placed21 6 (4, 7) required_40), (placed21 1 (0, 4) required_517), required_665_i3] +def childrenD_665_i2 : Fin 3 → Finset Cell := ![(placed21 6 (4, 7) envelope_40), (placed21 1 (0, 4) envelope_517), envelope_665_i3] +theorem common_sub_665_i2 : commonEnvelope childrenD_665_i2 ⊆ insert (3, 5) required_665_i2 := by decide +kernel +theorem child_required_sub_665_i2 : ∀ j, childrenC_665_i2 j ⊆ insert (3, 5) required_665_i2 := by decide +kernel +theorem child_envelope_sub_665_i2 : ∀ j, childrenD_665_i2 j ⊆ envelope_665_i2 := by decide +kernel +theorem pivot_mem_665_i2 : (3, 5) ∈ envelope_665_i2 := by decide +kernel +theorem children_work_665_i2 : ∀ j, Template HasSnaky 11 (childrenC_665_i2 j) (childrenD_665_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_40 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_517 1 (0, 4)).mono (by decide +kernel) + · exact row_works_665_i3.mono (by decide +kernel) +theorem row_works_665_i2 : Template HasSnaky 12 required_665_i2 envelope_665_i2 := by + refine compose HasSnaky 11 childrenC_665_i2 childrenD_665_i2 children_work_665_i2 (3, 5) + required_665_i2 envelope_665_i2 pivot_mem_665_i2 child_required_sub_665_i2 child_envelope_sub_665_i2 ?_ + intro b hb + exact common_sub_665_i2 (mem_commonEnvelope childrenD_665_i2 b hb) +def required_665 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_665 : Finset Cell := ⟨(([(0, 7), (0, 8), (0, 9), (1, 0), (1, 1), (1, 2), (1, 4), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6), (8, 7), (8, 8), (8, 9), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_665 : Fin 5 → Finset Cell := ![(placed21 0 (3, 1) required_459), (placed21 3 (1, 7) required_588), required_665_i0, required_665_i1, required_665_i2] +def childrenD_665 : Fin 5 → Finset Cell := ![(placed21 0 (3, 1) envelope_459), (placed21 3 (1, 7) envelope_588), envelope_665_i0, envelope_665_i1, envelope_665_i2] +theorem common_sub_665 : commonEnvelope childrenD_665 ⊆ insert (4, 5) required_665 := by decide +kernel +theorem child_required_sub_665 : ∀ j, childrenC_665 j ⊆ insert (4, 5) required_665 := by decide +kernel +theorem child_envelope_sub_665 : ∀ j, childrenD_665 j ⊆ envelope_665 := by decide +kernel +theorem pivot_mem_665 : (4, 5) ∈ envelope_665 := by decide +kernel +theorem children_work_665 : ∀ j, Template HasSnaky 12 (childrenC_665 j) (childrenD_665 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_459 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_588 3 (1, 7)).mono (by decide +kernel) + · exact row_works_665_i0.mono (by decide +kernel) + · exact row_works_665_i1.mono (by decide +kernel) + · exact row_works_665_i2.mono (by decide +kernel) +theorem row_works_665 : Template HasSnaky 13 required_665 envelope_665 := by + refine compose HasSnaky 12 childrenC_665 childrenD_665 children_work_665 (4, 5) + required_665 envelope_665 pivot_mem_665 child_required_sub_665 child_envelope_sub_665 ?_ + intro b hb + exact common_sub_665 (mem_commonEnvelope childrenD_665 b hb) +def height_650_i0 : ℕ := 11 +def childrenH_650_i0 : Fin 2 → ℕ := ![height_52, height_545] +theorem height_exact_650_i0 : height_650_i0 = 1 + Finset.univ.sup childrenH_650_i0 := by decide +kernel +theorem required_origin_650_i0 : ∀ x ∈ required_650_i0, + (∃ j, x ∈ childrenC_650_i0 j) ∨ ∀ j, x ∈ childrenD_650_i0 j := by decide +kernel +theorem required_exact_650_i0 : required_650_i0 = + ((Finset.univ.biUnion childrenC_650_i0) ∪ commonEnvelope childrenD_650_i0).erase (5, 4) := by + exact required_eq_combination childrenC_650_i0 childrenD_650_i0 (5, 4) required_650_i0 + (by decide +kernel) child_required_sub_650_i0 common_sub_650_i0 required_origin_650_i0 +theorem envelope_origin_650_i0 : ∀ x ∈ envelope_650_i0, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_650_i0 j := by decide +kernel +theorem envelope_exact_650_i0 : envelope_650_i0 = + insert (5, 4) (Finset.univ.biUnion childrenD_650_i0) := by + exact envelope_eq_combination childrenD_650_i0 (5, 4) envelope_650_i0 + pivot_mem_650_i0 child_envelope_sub_650_i0 envelope_origin_650_i0 +def checked_650_i0 : CheckedCard where + required := required_650_i0 + envelope := envelope_650_i0 + height := height_650_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_650_i0 +def height_650 : ℕ := 13 +def childrenH_650 : Fin 7 → ℕ := ![height_13, height_14, height_257, height_435, height_507, height_649, height_650_i0] +theorem height_exact_650 : height_650 = 1 + Finset.univ.sup childrenH_650 := by decide +kernel +theorem required_origin_650 : ∀ x ∈ required_650, + (∃ j, x ∈ childrenC_650 j) ∨ ∀ j, x ∈ childrenD_650 j := by decide +kernel +theorem required_exact_650 : required_650 = + ((Finset.univ.biUnion childrenC_650) ∪ commonEnvelope childrenD_650).erase (5, 5) := by + exact required_eq_combination childrenC_650 childrenD_650 (5, 5) required_650 + (by decide +kernel) child_required_sub_650 common_sub_650 required_origin_650 +theorem envelope_origin_650 : ∀ x ∈ envelope_650, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_650 j := by decide +kernel +theorem envelope_exact_650 : envelope_650 = + insert (5, 5) (Finset.univ.biUnion childrenD_650) := by + exact envelope_eq_combination childrenD_650 (5, 5) envelope_650 + pivot_mem_650 child_envelope_sub_650 envelope_origin_650 +def checked_650 : CheckedCard where + required := required_650 + envelope := envelope_650 + height := height_650 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_650 +def height_657_i1 : ℕ := 5 +def childrenH_657_i1 : Fin 2 → ℕ := ![height_54, height_79] +theorem height_exact_657_i1 : height_657_i1 = 1 + Finset.univ.sup childrenH_657_i1 := by decide +kernel +theorem required_origin_657_i1 : ∀ x ∈ required_657_i1, + (∃ j, x ∈ childrenC_657_i1 j) ∨ ∀ j, x ∈ childrenD_657_i1 j := by decide +kernel +theorem required_exact_657_i1 : required_657_i1 = + ((Finset.univ.biUnion childrenC_657_i1) ∪ commonEnvelope childrenD_657_i1).erase (2, 4) := by + exact required_eq_combination childrenC_657_i1 childrenD_657_i1 (2, 4) required_657_i1 + (by decide +kernel) child_required_sub_657_i1 common_sub_657_i1 required_origin_657_i1 +theorem envelope_origin_657_i1 : ∀ x ∈ envelope_657_i1, + x = (2, 4) ∨ ∃ j, x ∈ childrenD_657_i1 j := by decide +kernel +theorem envelope_exact_657_i1 : envelope_657_i1 = + insert (2, 4) (Finset.univ.biUnion childrenD_657_i1) := by + exact envelope_eq_combination childrenD_657_i1 (2, 4) envelope_657_i1 + pivot_mem_657_i1 child_envelope_sub_657_i1 envelope_origin_657_i1 +def checked_657_i1 : CheckedCard where + required := required_657_i1 + envelope := envelope_657_i1 + height := height_657_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_657_i1 +def height_657_i2 : ℕ := 9 +def childrenH_657_i2 : Fin 3 → ℕ := ![height_54, height_71, height_345] +theorem height_exact_657_i2 : height_657_i2 = 1 + Finset.univ.sup childrenH_657_i2 := by decide +kernel +theorem required_origin_657_i2 : ∀ x ∈ required_657_i2, + (∃ j, x ∈ childrenC_657_i2 j) ∨ ∀ j, x ∈ childrenD_657_i2 j := by decide +kernel +theorem required_exact_657_i2 : required_657_i2 = + ((Finset.univ.biUnion childrenC_657_i2) ∪ commonEnvelope childrenD_657_i2).erase (4, 2) := by + exact required_eq_combination childrenC_657_i2 childrenD_657_i2 (4, 2) required_657_i2 + (by decide +kernel) child_required_sub_657_i2 common_sub_657_i2 required_origin_657_i2 +theorem envelope_origin_657_i2 : ∀ x ∈ envelope_657_i2, + x = (4, 2) ∨ ∃ j, x ∈ childrenD_657_i2 j := by decide +kernel +theorem envelope_exact_657_i2 : envelope_657_i2 = + insert (4, 2) (Finset.univ.biUnion childrenD_657_i2) := by + exact envelope_eq_combination childrenD_657_i2 (4, 2) envelope_657_i2 + pivot_mem_657_i2 child_envelope_sub_657_i2 envelope_origin_657_i2 +def checked_657_i2 : CheckedCard where + required := required_657_i2 + envelope := envelope_657_i2 + height := height_657_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_657_i2 +def height_657_i6 : ℕ := 6 +def childrenH_657_i6 : Fin 2 → ℕ := ![height_5, height_445] +theorem height_exact_657_i6 : height_657_i6 = 1 + Finset.univ.sup childrenH_657_i6 := by decide +kernel +theorem required_origin_657_i6 : ∀ x ∈ required_657_i6, + (∃ j, x ∈ childrenC_657_i6 j) ∨ ∀ j, x ∈ childrenD_657_i6 j := by decide +kernel +theorem required_exact_657_i6 : required_657_i6 = + ((Finset.univ.biUnion childrenC_657_i6) ∪ commonEnvelope childrenD_657_i6).erase (6, 3) := by + exact required_eq_combination childrenC_657_i6 childrenD_657_i6 (6, 3) required_657_i6 + (by decide +kernel) child_required_sub_657_i6 common_sub_657_i6 required_origin_657_i6 +theorem envelope_origin_657_i6 : ∀ x ∈ envelope_657_i6, + x = (6, 3) ∨ ∃ j, x ∈ childrenD_657_i6 j := by decide +kernel +theorem envelope_exact_657_i6 : envelope_657_i6 = + insert (6, 3) (Finset.univ.biUnion childrenD_657_i6) := by + exact envelope_eq_combination childrenD_657_i6 (6, 3) envelope_657_i6 + pivot_mem_657_i6 child_envelope_sub_657_i6 envelope_origin_657_i6 +def checked_657_i6 : CheckedCard where + required := required_657_i6 + envelope := envelope_657_i6 + height := height_657_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_657_i6 +def height_657_i5 : ℕ := 7 +def childrenH_657_i5 : Fin 3 → ℕ := ![height_20, height_29, height_657_i6] +theorem height_exact_657_i5 : height_657_i5 = 1 + Finset.univ.sup childrenH_657_i5 := by decide +kernel +theorem required_origin_657_i5 : ∀ x ∈ required_657_i5, + (∃ j, x ∈ childrenC_657_i5 j) ∨ ∀ j, x ∈ childrenD_657_i5 j := by decide +kernel +theorem required_exact_657_i5 : required_657_i5 = + ((Finset.univ.biUnion childrenC_657_i5) ∪ commonEnvelope childrenD_657_i5).erase (6, 4) := by + exact required_eq_combination childrenC_657_i5 childrenD_657_i5 (6, 4) required_657_i5 + (by decide +kernel) child_required_sub_657_i5 common_sub_657_i5 required_origin_657_i5 +theorem envelope_origin_657_i5 : ∀ x ∈ envelope_657_i5, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_657_i5 j := by decide +kernel +theorem envelope_exact_657_i5 : envelope_657_i5 = + insert (6, 4) (Finset.univ.biUnion childrenD_657_i5) := by + exact envelope_eq_combination childrenD_657_i5 (6, 4) envelope_657_i5 + pivot_mem_657_i5 child_envelope_sub_657_i5 envelope_origin_657_i5 +def checked_657_i5 : CheckedCard where + required := required_657_i5 + envelope := envelope_657_i5 + height := height_657_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_657_i5 +def height_657_i4 : ℕ := 8 +def childrenH_657_i4 : Fin 3 → ℕ := ![height_15, height_65, height_657_i5] +theorem height_exact_657_i4 : height_657_i4 = 1 + Finset.univ.sup childrenH_657_i4 := by decide +kernel +theorem required_origin_657_i4 : ∀ x ∈ required_657_i4, + (∃ j, x ∈ childrenC_657_i4 j) ∨ ∀ j, x ∈ childrenD_657_i4 j := by decide +kernel +theorem required_exact_657_i4 : required_657_i4 = + ((Finset.univ.biUnion childrenC_657_i4) ∪ commonEnvelope childrenD_657_i4).erase (3, 4) := by + exact required_eq_combination childrenC_657_i4 childrenD_657_i4 (3, 4) required_657_i4 + (by decide +kernel) child_required_sub_657_i4 common_sub_657_i4 required_origin_657_i4 +theorem envelope_origin_657_i4 : ∀ x ∈ envelope_657_i4, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_657_i4 j := by decide +kernel +theorem envelope_exact_657_i4 : envelope_657_i4 = + insert (3, 4) (Finset.univ.biUnion childrenD_657_i4) := by + exact envelope_eq_combination childrenD_657_i4 (3, 4) envelope_657_i4 + pivot_mem_657_i4 child_envelope_sub_657_i4 envelope_origin_657_i4 +def checked_657_i4 : CheckedCard where + required := required_657_i4 + envelope := envelope_657_i4 + height := height_657_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_657_i4 +def height_657_i3 : ℕ := 11 +def childrenH_657_i3 : Fin 5 → ℕ := ![height_85, height_85, height_411, height_537, height_657_i4] +theorem height_exact_657_i3 : height_657_i3 = 1 + Finset.univ.sup childrenH_657_i3 := by decide +kernel +theorem required_origin_657_i3 : ∀ x ∈ required_657_i3, + (∃ j, x ∈ childrenC_657_i3 j) ∨ ∀ j, x ∈ childrenD_657_i3 j := by decide +kernel +theorem required_exact_657_i3 : required_657_i3 = + ((Finset.univ.biUnion childrenC_657_i3) ∪ commonEnvelope childrenD_657_i3).erase (5, 4) := by + exact required_eq_combination childrenC_657_i3 childrenD_657_i3 (5, 4) required_657_i3 + (by decide +kernel) child_required_sub_657_i3 common_sub_657_i3 required_origin_657_i3 +theorem envelope_origin_657_i3 : ∀ x ∈ envelope_657_i3, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_657_i3 j := by decide +kernel +theorem envelope_exact_657_i3 : envelope_657_i3 = + insert (5, 4) (Finset.univ.biUnion childrenD_657_i3) := by + exact envelope_eq_combination childrenD_657_i3 (5, 4) envelope_657_i3 + pivot_mem_657_i3 child_envelope_sub_657_i3 envelope_origin_657_i3 +def checked_657_i3 : CheckedCard where + required := required_657_i3 + envelope := envelope_657_i3 + height := height_657_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_657_i3 +def height_657_i0 : ℕ := 12 +def childrenH_657_i0 : Fin 6 → ℕ := ![height_510, height_631, height_653, height_657_i1, height_657_i2, height_657_i3] +theorem height_exact_657_i0 : height_657_i0 = 1 + Finset.univ.sup childrenH_657_i0 := by decide +kernel +theorem required_origin_657_i0 : ∀ x ∈ required_657_i0, + (∃ j, x ∈ childrenC_657_i0 j) ∨ ∀ j, x ∈ childrenD_657_i0 j := by decide +kernel +theorem required_exact_657_i0 : required_657_i0 = + ((Finset.univ.biUnion childrenC_657_i0) ∪ commonEnvelope childrenD_657_i0).erase (4, 4) := by + exact required_eq_combination childrenC_657_i0 childrenD_657_i0 (4, 4) required_657_i0 + (by decide +kernel) child_required_sub_657_i0 common_sub_657_i0 required_origin_657_i0 +theorem envelope_origin_657_i0 : ∀ x ∈ envelope_657_i0, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_657_i0 j := by decide +kernel +theorem envelope_exact_657_i0 : envelope_657_i0 = + insert (4, 4) (Finset.univ.biUnion childrenD_657_i0) := by + exact envelope_eq_combination childrenD_657_i0 (4, 4) envelope_657_i0 + pivot_mem_657_i0 child_envelope_sub_657_i0 envelope_origin_657_i0 +def checked_657_i0 : CheckedCard where + required := required_657_i0 + envelope := envelope_657_i0 + height := height_657_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_657_i0 +def height_657 : ℕ := 13 +def childrenH_657 : Fin 5 → ℕ := ![height_50, height_125, height_478, height_482, height_657_i0] +theorem height_exact_657 : height_657 = 1 + Finset.univ.sup childrenH_657 := by decide +kernel +theorem required_origin_657 : ∀ x ∈ required_657, + (∃ j, x ∈ childrenC_657 j) ∨ ∀ j, x ∈ childrenD_657 j := by decide +kernel +theorem required_exact_657 : required_657 = + ((Finset.univ.biUnion childrenC_657) ∪ commonEnvelope childrenD_657).erase (4, 3) := by + exact required_eq_combination childrenC_657 childrenD_657 (4, 3) required_657 + (by decide +kernel) child_required_sub_657 common_sub_657 required_origin_657 +theorem envelope_origin_657 : ∀ x ∈ envelope_657, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_657 j := by decide +kernel +theorem envelope_exact_657 : envelope_657 = + insert (4, 3) (Finset.univ.biUnion childrenD_657) := by + exact envelope_eq_combination childrenD_657 (4, 3) envelope_657 + pivot_mem_657 child_envelope_sub_657 envelope_origin_657 +def checked_657 : CheckedCard where + required := required_657 + envelope := envelope_657 + height := height_657 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_657 +def height_665_i0 : ℕ := 10 +def childrenH_665_i0 : Fin 4 → ℕ := ![height_70, height_106, height_269, height_322] +theorem height_exact_665_i0 : height_665_i0 = 1 + Finset.univ.sup childrenH_665_i0 := by decide +kernel +theorem required_origin_665_i0 : ∀ x ∈ required_665_i0, + (∃ j, x ∈ childrenC_665_i0 j) ∨ ∀ j, x ∈ childrenD_665_i0 j := by decide +kernel +theorem required_exact_665_i0 : required_665_i0 = + ((Finset.univ.biUnion childrenC_665_i0) ∪ commonEnvelope childrenD_665_i0).erase (4, 7) := by + exact required_eq_combination childrenC_665_i0 childrenD_665_i0 (4, 7) required_665_i0 + (by decide +kernel) child_required_sub_665_i0 common_sub_665_i0 required_origin_665_i0 +theorem envelope_origin_665_i0 : ∀ x ∈ envelope_665_i0, + x = (4, 7) ∨ ∃ j, x ∈ childrenD_665_i0 j := by decide +kernel +theorem envelope_exact_665_i0 : envelope_665_i0 = + insert (4, 7) (Finset.univ.biUnion childrenD_665_i0) := by + exact envelope_eq_combination childrenD_665_i0 (4, 7) envelope_665_i0 + pivot_mem_665_i0 child_envelope_sub_665_i0 envelope_origin_665_i0 +def checked_665_i0 : CheckedCard where + required := required_665_i0 + envelope := envelope_665_i0 + height := height_665_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_665_i0 +def height_665_i1 : ℕ := 9 +def childrenH_665_i1 : Fin 3 → ℕ := ![height_70, height_257, height_435] +theorem height_exact_665_i1 : height_665_i1 = 1 + Finset.univ.sup childrenH_665_i1 := by decide +kernel +theorem required_origin_665_i1 : ∀ x ∈ required_665_i1, + (∃ j, x ∈ childrenC_665_i1 j) ∨ ∀ j, x ∈ childrenD_665_i1 j := by decide +kernel +theorem required_exact_665_i1 : required_665_i1 = + ((Finset.univ.biUnion childrenC_665_i1) ∪ commonEnvelope childrenD_665_i1).erase (4, 7) := by + exact required_eq_combination childrenC_665_i1 childrenD_665_i1 (4, 7) required_665_i1 + (by decide +kernel) child_required_sub_665_i1 common_sub_665_i1 required_origin_665_i1 +theorem envelope_origin_665_i1 : ∀ x ∈ envelope_665_i1, + x = (4, 7) ∨ ∃ j, x ∈ childrenD_665_i1 j := by decide +kernel +theorem envelope_exact_665_i1 : envelope_665_i1 = + insert (4, 7) (Finset.univ.biUnion childrenD_665_i1) := by + exact envelope_eq_combination childrenD_665_i1 (4, 7) envelope_665_i1 + pivot_mem_665_i1 child_envelope_sub_665_i1 envelope_origin_665_i1 +def checked_665_i1 : CheckedCard where + required := required_665_i1 + envelope := envelope_665_i1 + height := height_665_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_665_i1 +def height_665_i4 : ℕ := 5 +def childrenH_665_i4 : Fin 2 → ℕ := ![height_4, height_93] +theorem height_exact_665_i4 : height_665_i4 = 1 + Finset.univ.sup childrenH_665_i4 := by decide +kernel +theorem required_origin_665_i4 : ∀ x ∈ required_665_i4, + (∃ j, x ∈ childrenC_665_i4 j) ∨ ∀ j, x ∈ childrenD_665_i4 j := by decide +kernel +theorem required_exact_665_i4 : required_665_i4 = + ((Finset.univ.biUnion childrenC_665_i4) ∪ commonEnvelope childrenD_665_i4).erase (3, 7) := by + exact required_eq_combination childrenC_665_i4 childrenD_665_i4 (3, 7) required_665_i4 + (by decide +kernel) child_required_sub_665_i4 common_sub_665_i4 required_origin_665_i4 +theorem envelope_origin_665_i4 : ∀ x ∈ envelope_665_i4, + x = (3, 7) ∨ ∃ j, x ∈ childrenD_665_i4 j := by decide +kernel +theorem envelope_exact_665_i4 : envelope_665_i4 = + insert (3, 7) (Finset.univ.biUnion childrenD_665_i4) := by + exact envelope_eq_combination childrenD_665_i4 (3, 7) envelope_665_i4 + pivot_mem_665_i4 child_envelope_sub_665_i4 envelope_origin_665_i4 +def checked_665_i4 : CheckedCard where + required := required_665_i4 + envelope := envelope_665_i4 + height := height_665_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_665_i4 +def height_665_i3 : ℕ := 6 +def childrenH_665_i3 : Fin 2 → ℕ := ![height_5, height_665_i4] +theorem height_exact_665_i3 : height_665_i3 = 1 + Finset.univ.sup childrenH_665_i3 := by decide +kernel +theorem required_origin_665_i3 : ∀ x ∈ required_665_i3, + (∃ j, x ∈ childrenC_665_i3 j) ∨ ∀ j, x ∈ childrenD_665_i3 j := by decide +kernel +theorem required_exact_665_i3 : required_665_i3 = + ((Finset.univ.biUnion childrenC_665_i3) ∪ commonEnvelope childrenD_665_i3).erase (3, 4) := by + exact required_eq_combination childrenC_665_i3 childrenD_665_i3 (3, 4) required_665_i3 + (by decide +kernel) child_required_sub_665_i3 common_sub_665_i3 required_origin_665_i3 +theorem envelope_origin_665_i3 : ∀ x ∈ envelope_665_i3, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_665_i3 j := by decide +kernel +theorem envelope_exact_665_i3 : envelope_665_i3 = + insert (3, 4) (Finset.univ.biUnion childrenD_665_i3) := by + exact envelope_eq_combination childrenD_665_i3 (3, 4) envelope_665_i3 + pivot_mem_665_i3 child_envelope_sub_665_i3 envelope_origin_665_i3 +def checked_665_i3 : CheckedCard where + required := required_665_i3 + envelope := envelope_665_i3 + height := height_665_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_665_i3 +def height_665_i2 : ℕ := 12 +def childrenH_665_i2 : Fin 3 → ℕ := ![height_40, height_517, height_665_i3] +theorem height_exact_665_i2 : height_665_i2 = 1 + Finset.univ.sup childrenH_665_i2 := by decide +kernel +theorem required_origin_665_i2 : ∀ x ∈ required_665_i2, + (∃ j, x ∈ childrenC_665_i2 j) ∨ ∀ j, x ∈ childrenD_665_i2 j := by decide +kernel +theorem required_exact_665_i2 : required_665_i2 = + ((Finset.univ.biUnion childrenC_665_i2) ∪ commonEnvelope childrenD_665_i2).erase (3, 5) := by + exact required_eq_combination childrenC_665_i2 childrenD_665_i2 (3, 5) required_665_i2 + (by decide +kernel) child_required_sub_665_i2 common_sub_665_i2 required_origin_665_i2 +theorem envelope_origin_665_i2 : ∀ x ∈ envelope_665_i2, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_665_i2 j := by decide +kernel +theorem envelope_exact_665_i2 : envelope_665_i2 = + insert (3, 5) (Finset.univ.biUnion childrenD_665_i2) := by + exact envelope_eq_combination childrenD_665_i2 (3, 5) envelope_665_i2 + pivot_mem_665_i2 child_envelope_sub_665_i2 envelope_origin_665_i2 +def checked_665_i2 : CheckedCard where + required := required_665_i2 + envelope := envelope_665_i2 + height := height_665_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_665_i2 +def height_665 : ℕ := 13 +def childrenH_665 : Fin 5 → ℕ := ![height_459, height_588, height_665_i0, height_665_i1, height_665_i2] +theorem height_exact_665 : height_665 = 1 + Finset.univ.sup childrenH_665 := by decide +kernel +theorem required_origin_665 : ∀ x ∈ required_665, + (∃ j, x ∈ childrenC_665 j) ∨ ∀ j, x ∈ childrenD_665 j := by decide +kernel +theorem required_exact_665 : required_665 = + ((Finset.univ.biUnion childrenC_665) ∪ commonEnvelope childrenD_665).erase (4, 5) := by + exact required_eq_combination childrenC_665 childrenD_665 (4, 5) required_665 + (by decide +kernel) child_required_sub_665 common_sub_665 required_origin_665 +theorem envelope_origin_665 : ∀ x ∈ envelope_665, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_665 j := by decide +kernel +theorem envelope_exact_665 : envelope_665 = + insert (4, 5) (Finset.univ.biUnion childrenD_665) := by + exact envelope_eq_combination childrenD_665 (4, 5) envelope_665 + pivot_mem_665 child_envelope_sub_665 envelope_origin_665 +def checked_665 : CheckedCard where + required := required_665 + envelope := envelope_665 + height := height_665 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_665 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part05.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part05.lean new file mode 100644 index 0000000..f253ae1 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part05.lean @@ -0,0 +1,815 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_675_i0 : Finset Cell := ⟨(([(4, 5), (4, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i0 : Finset Cell := ⟨(([(3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 3), (8, 4), (8, 5), (8, 7), (8, 8), (8, 9), (8, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i0 : Fin 5 → Finset Cell := ![(placed21 2 (8, 3) required_12), (placed21 0 (4, 3) required_356), (placed21 0 (4, 3) required_364), (placed21 2 (8, 3) required_367), (placed21 6 (8, 9) required_671)] +def childrenD_675_i0 : Fin 5 → Finset Cell := ![(placed21 2 (8, 3) envelope_12), (placed21 0 (4, 3) envelope_356), (placed21 0 (4, 3) envelope_364), (placed21 2 (8, 3) envelope_367), (placed21 6 (8, 9) envelope_671)] +theorem common_sub_675_i0 : commonEnvelope childrenD_675_i0 ⊆ insert (7, 7) required_675_i0 := by decide +kernel +theorem child_required_sub_675_i0 : ∀ j, childrenC_675_i0 j ⊆ insert (7, 7) required_675_i0 := by decide +kernel +theorem child_envelope_sub_675_i0 : ∀ j, childrenD_675_i0 j ⊆ envelope_675_i0 := by decide +kernel +theorem pivot_mem_675_i0 : (7, 7) ∈ envelope_675_i0 := by decide +kernel +theorem children_work_675_i0 : ∀ j, Template HasSnaky 7 (childrenC_675_i0 j) (childrenD_675_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 2 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_356 0 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_364 0 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_367 2 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_671 6 (8, 9)).mono (by decide +kernel) +theorem row_works_675_i0 : Template HasSnaky 8 required_675_i0 envelope_675_i0 := by + refine compose HasSnaky 7 childrenC_675_i0 childrenD_675_i0 children_work_675_i0 (7, 7) + required_675_i0 envelope_675_i0 pivot_mem_675_i0 child_required_sub_675_i0 child_envelope_sub_675_i0 ?_ + intro b hb + exact common_sub_675_i0 (mem_commonEnvelope childrenD_675_i0 b hb) +def required_675_i1 : Finset Cell := ⟨(([(4, 5), (4, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i1 : Finset Cell := ⟨(([(3, 2), (3, 4), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 5), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 4), (9, 6), (9, 7), (9, 8), (10, 6), (10, 7), (10, 8), (11, 6), (11, 7), (11, 8), (12, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i1 : Fin 6 → Finset Cell := ![(placed21 0 (5, 2) required_188), (placed21 6 (9, 8) required_190), (placed21 2 (8, 2) required_441), (placed21 2 (8, 2) required_442), (placed21 6 (8, 7) required_514), (placed21 0 (4, 3) required_667)] +def childrenD_675_i1 : Fin 6 → Finset Cell := ![(placed21 0 (5, 2) envelope_188), (placed21 6 (9, 8) envelope_190), (placed21 2 (8, 2) envelope_441), (placed21 2 (8, 2) envelope_442), (placed21 6 (8, 7) envelope_514), (placed21 0 (4, 3) envelope_667)] +theorem common_sub_675_i1 : commonEnvelope childrenD_675_i1 ⊆ insert (7, 4) required_675_i1 := by decide +kernel +theorem child_required_sub_675_i1 : ∀ j, childrenC_675_i1 j ⊆ insert (7, 4) required_675_i1 := by decide +kernel +theorem child_envelope_sub_675_i1 : ∀ j, childrenD_675_i1 j ⊆ envelope_675_i1 := by decide +kernel +theorem pivot_mem_675_i1 : (7, 4) ∈ envelope_675_i1 := by decide +kernel +theorem children_work_675_i1 : ∀ j, Template HasSnaky 9 (childrenC_675_i1 j) (childrenD_675_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_188 0 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_190 6 (9, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_441 2 (8, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_442 2 (8, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_514 6 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_667 0 (4, 3)).mono (by decide +kernel) +theorem row_works_675_i1 : Template HasSnaky 10 required_675_i1 envelope_675_i1 := by + refine compose HasSnaky 9 childrenC_675_i1 childrenD_675_i1 children_work_675_i1 (7, 4) + required_675_i1 envelope_675_i1 pivot_mem_675_i1 child_required_sub_675_i1 child_envelope_sub_675_i1 ?_ + intro b hb + exact common_sub_675_i1 (mem_commonEnvelope childrenD_675_i1 b hb) +def required_675_i3 : Finset Cell := ⟨(([(7, 3), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i3 : Finset Cell := ⟨(([(5, 3), (6, 1), (6, 2), (6, 3), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 4), (10, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i3 : Fin 5 → Finset Cell := ![(placed21 3 (6, 6) required_8), (placed21 7 (8, 6) required_26), (placed21 1 (5, 2) required_133), (placed21 0 (6, 1) required_186), (placed21 4 (7, 8) required_187)] +def childrenD_675_i3 : Fin 5 → Finset Cell := ![(placed21 3 (6, 6) envelope_8), (placed21 7 (8, 6) envelope_26), (placed21 1 (5, 2) envelope_133), (placed21 0 (6, 1) envelope_186), (placed21 4 (7, 8) envelope_187)] +theorem common_sub_675_i3 : commonEnvelope childrenD_675_i3 ⊆ insert (7, 4) required_675_i3 := by decide +kernel +theorem child_required_sub_675_i3 : ∀ j, childrenC_675_i3 j ⊆ insert (7, 4) required_675_i3 := by decide +kernel +theorem child_envelope_sub_675_i3 : ∀ j, childrenD_675_i3 j ⊆ envelope_675_i3 := by decide +kernel +theorem pivot_mem_675_i3 : (7, 4) ∈ envelope_675_i3 := by decide +kernel +theorem children_work_675_i3 : ∀ j, Template HasSnaky 5 (childrenC_675_i3 j) (childrenD_675_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 3 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_26 7 (8, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_133 1 (5, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_186 0 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_187 4 (7, 8)).mono (by decide +kernel) +theorem row_works_675_i3 : Template HasSnaky 6 required_675_i3 envelope_675_i3 := by + refine compose HasSnaky 5 childrenC_675_i3 childrenD_675_i3 children_work_675_i3 (7, 4) + required_675_i3 envelope_675_i3 pivot_mem_675_i3 child_required_sub_675_i3 child_envelope_sub_675_i3 ?_ + intro b hb + exact common_sub_675_i3 (mem_commonEnvelope childrenD_675_i3 b hb) +def required_675_i5 : Finset Cell := ⟨(([(6, 6), (7, 3), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i5 : Finset Cell := ⟨(([(4, 3), (5, 3), (6, 2), (6, 3), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 2), (8, 3), (8, 4), (9, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i5 : Fin 2 → Finset Cell := ![(placed21 5 (7, 3) required_5), (placed21 5 (9, 2) required_179)] +def childrenD_675_i5 : Fin 2 → Finset Cell := ![(placed21 5 (7, 3) envelope_5), (placed21 5 (9, 2) envelope_179)] +theorem common_sub_675_i5 : commonEnvelope childrenD_675_i5 ⊆ insert (7, 4) required_675_i5 := by decide +kernel +theorem child_required_sub_675_i5 : ∀ j, childrenC_675_i5 j ⊆ insert (7, 4) required_675_i5 := by decide +kernel +theorem child_envelope_sub_675_i5 : ∀ j, childrenD_675_i5 j ⊆ envelope_675_i5 := by decide +kernel +theorem pivot_mem_675_i5 : (7, 4) ∈ envelope_675_i5 := by decide +kernel +theorem children_work_675_i5 : ∀ j, Template HasSnaky 5 (childrenC_675_i5 j) (childrenD_675_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_179 5 (9, 2)).mono (by decide +kernel) +theorem row_works_675_i5 : Template HasSnaky 6 required_675_i5 envelope_675_i5 := by + refine compose HasSnaky 5 childrenC_675_i5 childrenD_675_i5 children_work_675_i5 (7, 4) + required_675_i5 envelope_675_i5 pivot_mem_675_i5 child_required_sub_675_i5 child_envelope_sub_675_i5 ?_ + intro b hb + exact common_sub_675_i5 (mem_commonEnvelope childrenD_675_i5 b hb) +def required_675_i6 : Finset Cell := ⟨(([(4, 5), (4, 6), (6, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i6 : Finset Cell := ⟨(([(3, 4), (3, 6), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (6, 5), (6, 6), (7, 5), (7, 6), (8, 5), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i6 : Fin 3 → Finset Cell := ![(placed21 7 (8, 6) required_22), (placed21 5 (8, 5) required_34), (placed21 7 (8, 6) required_305)] +def childrenD_675_i6 : Fin 3 → Finset Cell := ![(placed21 7 (8, 6) envelope_22), (placed21 5 (8, 5) envelope_34), (placed21 7 (8, 6) envelope_305)] +theorem common_sub_675_i6 : commonEnvelope childrenD_675_i6 ⊆ insert (6, 5) required_675_i6 := by decide +kernel +theorem child_required_sub_675_i6 : ∀ j, childrenC_675_i6 j ⊆ insert (6, 5) required_675_i6 := by decide +kernel +theorem child_envelope_sub_675_i6 : ∀ j, childrenD_675_i6 j ⊆ envelope_675_i6 := by decide +kernel +theorem pivot_mem_675_i6 : (6, 5) ∈ envelope_675_i6 := by decide +kernel +theorem children_work_675_i6 : ∀ j, Template HasSnaky 4 (childrenC_675_i6 j) (childrenD_675_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 7 (8, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_34 5 (8, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_305 7 (8, 6)).mono (by decide +kernel) +theorem row_works_675_i6 : Template HasSnaky 5 required_675_i6 envelope_675_i6 := by + refine compose HasSnaky 4 childrenC_675_i6 childrenD_675_i6 children_work_675_i6 (6, 5) + required_675_i6 envelope_675_i6 pivot_mem_675_i6 child_required_sub_675_i6 child_envelope_sub_675_i6 ?_ + intro b hb + exact common_sub_675_i6 (mem_commonEnvelope childrenD_675_i6 b hb) +def required_675_i4 : Finset Cell := ⟨(([(4, 5), (4, 6), (7, 3), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i4 : Finset Cell := ⟨(([(3, 4), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i4 : Fin 2 → Finset Cell := ![required_675_i5, required_675_i6] +def childrenD_675_i4 : Fin 2 → Finset Cell := ![envelope_675_i5, envelope_675_i6] +theorem common_sub_675_i4 : commonEnvelope childrenD_675_i4 ⊆ insert (6, 6) required_675_i4 := by decide +kernel +theorem child_required_sub_675_i4 : ∀ j, childrenC_675_i4 j ⊆ insert (6, 6) required_675_i4 := by decide +kernel +theorem child_envelope_sub_675_i4 : ∀ j, childrenD_675_i4 j ⊆ envelope_675_i4 := by decide +kernel +theorem pivot_mem_675_i4 : (6, 6) ∈ envelope_675_i4 := by decide +kernel +theorem children_work_675_i4 : ∀ j, Template HasSnaky 6 (childrenC_675_i4 j) (childrenD_675_i4 j) := by + intro j + fin_cases j + · exact row_works_675_i5.mono (by decide +kernel) + · exact row_works_675_i6.mono (by decide +kernel) +theorem row_works_675_i4 : Template HasSnaky 7 required_675_i4 envelope_675_i4 := by + refine compose HasSnaky 6 childrenC_675_i4 childrenD_675_i4 children_work_675_i4 (6, 6) + required_675_i4 envelope_675_i4 pivot_mem_675_i4 child_required_sub_675_i4 child_envelope_sub_675_i4 ?_ + intro b hb + exact common_sub_675_i4 (mem_commonEnvelope childrenD_675_i4 b hb) +def required_675_i2 : Finset Cell := ⟨(([(4, 5), (4, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i2 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 2), (9, 3), (9, 4), (10, 2), (10, 3), (10, 4), (11, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i2 : Fin 5 → Finset Cell := ![(placed21 4 (6, 8) required_304), (placed21 6 (8, 7) required_672), required_675_i3, (placed21 3 (1, 7) required_674), required_675_i4] +def childrenD_675_i2 : Fin 5 → Finset Cell := ![(placed21 4 (6, 8) envelope_304), (placed21 6 (8, 7) envelope_672), envelope_675_i3, (placed21 3 (1, 7) envelope_674), envelope_675_i4] +theorem common_sub_675_i2 : commonEnvelope childrenD_675_i2 ⊆ insert (7, 3) required_675_i2 := by decide +kernel +theorem child_required_sub_675_i2 : ∀ j, childrenC_675_i2 j ⊆ insert (7, 3) required_675_i2 := by decide +kernel +theorem child_envelope_sub_675_i2 : ∀ j, childrenD_675_i2 j ⊆ envelope_675_i2 := by decide +kernel +theorem pivot_mem_675_i2 : (7, 3) ∈ envelope_675_i2 := by decide +kernel +theorem children_work_675_i2 : ∀ j, Template HasSnaky 10 (childrenC_675_i2 j) (childrenD_675_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_304 4 (6, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_672 6 (8, 7)).mono (by decide +kernel) + · exact row_works_675_i3.mono (by decide +kernel) + · exact (placed21_template row_works_674 3 (1, 7)).mono (by decide +kernel) + · exact row_works_675_i4.mono (by decide +kernel) +theorem row_works_675_i2 : Template HasSnaky 11 required_675_i2 envelope_675_i2 := by + refine compose HasSnaky 10 childrenC_675_i2 childrenD_675_i2 children_work_675_i2 (7, 3) + required_675_i2 envelope_675_i2 pivot_mem_675_i2 child_required_sub_675_i2 child_envelope_sub_675_i2 ?_ + intro b hb + exact common_sub_675_i2 (mem_commonEnvelope childrenD_675_i2 b hb) +def required_675_i7 : Finset Cell := ⟨(([(4, 5), (4, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i7 : Finset Cell := ⟨(([(3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 7), (9, 8), (10, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i7 : Fin 4 → Finset Cell := ![(placed21 0 (5, 3) required_190), (placed21 2 (9, 3) required_190), (placed21 0 (4, 3) required_363), (placed21 6 (8, 9) required_671)] +def childrenD_675_i7 : Fin 4 → Finset Cell := ![(placed21 0 (5, 3) envelope_190), (placed21 2 (9, 3) envelope_190), (placed21 0 (4, 3) envelope_363), (placed21 6 (8, 9) envelope_671)] +theorem common_sub_675_i7 : commonEnvelope childrenD_675_i7 ⊆ insert (7, 7) required_675_i7 := by decide +kernel +theorem child_required_sub_675_i7 : ∀ j, childrenC_675_i7 j ⊆ insert (7, 7) required_675_i7 := by decide +kernel +theorem child_envelope_sub_675_i7 : ∀ j, childrenD_675_i7 j ⊆ envelope_675_i7 := by decide +kernel +theorem pivot_mem_675_i7 : (7, 7) ∈ envelope_675_i7 := by decide +kernel +theorem children_work_675_i7 : ∀ j, Template HasSnaky 7 (childrenC_675_i7 j) (childrenD_675_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_190 0 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_190 2 (9, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_363 0 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_671 6 (8, 9)).mono (by decide +kernel) +theorem row_works_675_i7 : Template HasSnaky 8 required_675_i7 envelope_675_i7 := by + refine compose HasSnaky 7 childrenC_675_i7 childrenD_675_i7 children_work_675_i7 (7, 7) + required_675_i7 envelope_675_i7 pivot_mem_675_i7 child_required_sub_675_i7 child_envelope_sub_675_i7 ?_ + intro b hb + exact common_sub_675_i7 (mem_commonEnvelope childrenD_675_i7 b hb) +def required_675_i8 : Finset Cell := ⟨(([(4, 5), (4, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i8 : Finset Cell := ⟨(([(3, 6), (4, 5), (4, 6), (5, 5), (5, 6), (5, 8), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (11, 4), (11, 5), (11, 6), (11, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i8 : Fin 3 → Finset Cell := ![(placed21 5 (8, 5) required_34), (placed21 3 (3, 6) required_97), (placed21 4 (5, 10) required_535)] +def childrenD_675_i8 : Fin 3 → Finset Cell := ![(placed21 5 (8, 5) envelope_34), (placed21 3 (3, 6) envelope_97), (placed21 4 (5, 10) envelope_535)] +theorem common_sub_675_i8 : commonEnvelope childrenD_675_i8 ⊆ insert (6, 5) required_675_i8 := by decide +kernel +theorem child_required_sub_675_i8 : ∀ j, childrenC_675_i8 j ⊆ insert (6, 5) required_675_i8 := by decide +kernel +theorem child_envelope_sub_675_i8 : ∀ j, childrenD_675_i8 j ⊆ envelope_675_i8 := by decide +kernel +theorem pivot_mem_675_i8 : (6, 5) ∈ envelope_675_i8 := by decide +kernel +theorem children_work_675_i8 : ∀ j, Template HasSnaky 10 (childrenC_675_i8 j) (childrenD_675_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_34 5 (8, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_97 3 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_535 4 (5, 10)).mono (by decide +kernel) +theorem row_works_675_i8 : Template HasSnaky 11 required_675_i8 envelope_675_i8 := by + refine compose HasSnaky 10 childrenC_675_i8 childrenD_675_i8 children_work_675_i8 (6, 5) + required_675_i8 envelope_675_i8 pivot_mem_675_i8 child_required_sub_675_i8 child_envelope_sub_675_i8 ?_ + intro b hb + exact common_sub_675_i8 (mem_commonEnvelope childrenD_675_i8 b hb) +def required_675_i10 : Finset Cell := ⟨(([(4, 5), (7, 3), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i10 : Finset Cell := ⟨(([(3, 2), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5), (7, 6), (8, 2), (8, 3), (8, 4), (8, 6), (8, 7), (9, 2), (9, 3), (9, 4), (10, 2), (10, 3), (10, 4), (11, 2), (11, 3), (11, 4), (12, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i10 : Fin 2 → Finset Cell := ![(placed21 3 (3, 6) required_321), (placed21 5 (8, 3) required_354)] +def childrenD_675_i10 : Fin 2 → Finset Cell := ![(placed21 3 (3, 6) envelope_321), (placed21 5 (8, 3) envelope_354)] +theorem common_sub_675_i10 : commonEnvelope childrenD_675_i10 ⊆ insert (7, 4) required_675_i10 := by decide +kernel +theorem child_required_sub_675_i10 : ∀ j, childrenC_675_i10 j ⊆ insert (7, 4) required_675_i10 := by decide +kernel +theorem child_envelope_sub_675_i10 : ∀ j, childrenD_675_i10 j ⊆ envelope_675_i10 := by decide +kernel +theorem pivot_mem_675_i10 : (7, 4) ∈ envelope_675_i10 := by decide +kernel +theorem children_work_675_i10 : ∀ j, Template HasSnaky 8 (childrenC_675_i10 j) (childrenD_675_i10 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_321 3 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_354 5 (8, 3)).mono (by decide +kernel) +theorem row_works_675_i10 : Template HasSnaky 9 required_675_i10 envelope_675_i10 := by + refine compose HasSnaky 8 childrenC_675_i10 childrenD_675_i10 children_work_675_i10 (7, 4) + required_675_i10 envelope_675_i10 pivot_mem_675_i10 child_required_sub_675_i10 child_envelope_sub_675_i10 ?_ + intro b hb + exact common_sub_675_i10 (mem_commonEnvelope childrenD_675_i10 b hb) +def required_675_i9 : Finset Cell := ⟨(([(4, 5), (4, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675_i9 : Finset Cell := ⟨(([(1, 2), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (9, 2), (9, 3), (9, 4), (9, 5), (10, 2), (10, 3), (10, 4), (11, 2), (11, 3), (11, 4), (12, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675_i9 : Fin 6 → Finset Cell := ![(placed21 3 (3, 7) required_328), (placed21 3 (3, 7) required_330), (placed21 4 (4, 7) required_384), (placed21 6 (8, 7) required_672), (placed21 3 (1, 7) required_674), required_675_i10] +def childrenD_675_i9 : Fin 6 → Finset Cell := ![(placed21 3 (3, 7) envelope_328), (placed21 3 (3, 7) envelope_330), (placed21 4 (4, 7) envelope_384), (placed21 6 (8, 7) envelope_672), (placed21 3 (1, 7) envelope_674), envelope_675_i10] +theorem common_sub_675_i9 : commonEnvelope childrenD_675_i9 ⊆ insert (7, 3) required_675_i9 := by decide +kernel +theorem child_required_sub_675_i9 : ∀ j, childrenC_675_i9 j ⊆ insert (7, 3) required_675_i9 := by decide +kernel +theorem child_envelope_sub_675_i9 : ∀ j, childrenD_675_i9 j ⊆ envelope_675_i9 := by decide +kernel +theorem pivot_mem_675_i9 : (7, 3) ∈ envelope_675_i9 := by decide +kernel +theorem children_work_675_i9 : ∀ j, Template HasSnaky 10 (childrenC_675_i9 j) (childrenD_675_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_328 3 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_330 3 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_384 4 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_672 6 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_674 3 (1, 7)).mono (by decide +kernel) + · exact row_works_675_i10.mono (by decide +kernel) +theorem row_works_675_i9 : Template HasSnaky 11 required_675_i9 envelope_675_i9 := by + refine compose HasSnaky 10 childrenC_675_i9 childrenD_675_i9 children_work_675_i9 (7, 3) + required_675_i9 envelope_675_i9 pivot_mem_675_i9 child_required_sub_675_i9 child_envelope_sub_675_i9 ?_ + intro b hb + exact common_sub_675_i9 (mem_commonEnvelope childrenD_675_i9 b hb) +def required_675 : Finset Cell := ⟨(([(4, 5), (4, 6), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_675 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 2), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 9), (3, 2), (3, 3), (3, 4), (3, 6), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (12, 4), (12, 6), (12, 7), (12, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_675 : Fin 9 → Finset Cell := ![(placed21 0 (6, 1) required_459), (placed21 0 (2, 2) required_618), (placed21 2 (10, 2) required_629), required_675_i0, required_675_i1, required_675_i2, required_675_i7, required_675_i8, required_675_i9] +def childrenD_675 : Fin 9 → Finset Cell := ![(placed21 0 (6, 1) envelope_459), (placed21 0 (2, 2) envelope_618), (placed21 2 (10, 2) envelope_629), envelope_675_i0, envelope_675_i1, envelope_675_i2, envelope_675_i7, envelope_675_i8, envelope_675_i9] +theorem common_sub_675 : commonEnvelope childrenD_675 ⊆ insert (7, 6) required_675 := by decide +kernel +theorem child_required_sub_675 : ∀ j, childrenC_675 j ⊆ insert (7, 6) required_675 := by decide +kernel +theorem child_envelope_sub_675 : ∀ j, childrenD_675 j ⊆ envelope_675 := by decide +kernel +theorem pivot_mem_675 : (7, 6) ∈ envelope_675 := by decide +kernel +theorem children_work_675 : ∀ j, Template HasSnaky 12 (childrenC_675 j) (childrenD_675 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_459 0 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_618 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_629 2 (10, 2)).mono (by decide +kernel) + · exact row_works_675_i0.mono (by decide +kernel) + · exact row_works_675_i1.mono (by decide +kernel) + · exact row_works_675_i2.mono (by decide +kernel) + · exact row_works_675_i7.mono (by decide +kernel) + · exact row_works_675_i8.mono (by decide +kernel) + · exact row_works_675_i9.mono (by decide +kernel) +theorem row_works_675 : Template HasSnaky 13 required_675 envelope_675 := by + refine compose HasSnaky 12 childrenC_675 childrenD_675 children_work_675 (7, 6) + required_675 envelope_675 pivot_mem_675 child_required_sub_675 child_envelope_sub_675 ?_ + intro b hb + exact common_sub_675 (mem_commonEnvelope childrenD_675 b hb) +def required_690_i0 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_690_i0 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 2), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_690_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 2) required_39), (placed21 0 (2, 2) required_80), (placed21 1 (0, 2) required_463)] +def childrenD_690_i0 : Fin 3 → Finset Cell := ![(placed21 0 (2, 2) envelope_39), (placed21 0 (2, 2) envelope_80), (placed21 1 (0, 2) envelope_463)] +theorem common_sub_690_i0 : commonEnvelope childrenD_690_i0 ⊆ insert (3, 6) required_690_i0 := by decide +kernel +theorem child_required_sub_690_i0 : ∀ j, childrenC_690_i0 j ⊆ insert (3, 6) required_690_i0 := by decide +kernel +theorem child_envelope_sub_690_i0 : ∀ j, childrenD_690_i0 j ⊆ envelope_690_i0 := by decide +kernel +theorem pivot_mem_690_i0 : (3, 6) ∈ envelope_690_i0 := by decide +kernel +theorem children_work_690_i0 : ∀ j, Template HasSnaky 11 (childrenC_690_i0 j) (childrenD_690_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_39 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_80 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_463 1 (0, 2)).mono (by decide +kernel) +theorem row_works_690_i0 : Template HasSnaky 12 required_690_i0 envelope_690_i0 := by + refine compose HasSnaky 11 childrenC_690_i0 childrenD_690_i0 children_work_690_i0 (3, 6) + required_690_i0 envelope_690_i0 pivot_mem_690_i0 child_required_sub_690_i0 child_envelope_sub_690_i0 ?_ + intro b hb + exact common_sub_690_i0 (mem_commonEnvelope childrenD_690_i0 b hb) +def required_690 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_690 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 2), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 2), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_690 : Fin 3 → Finset Cell := ![(placed21 1 (2, 3) required_21), (placed21 6 (5, 6) required_56), required_690_i0] +def childrenD_690 : Fin 3 → Finset Cell := ![(placed21 1 (2, 3) envelope_21), (placed21 6 (5, 6) envelope_56), envelope_690_i0] +theorem common_sub_690 : commonEnvelope childrenD_690 ⊆ insert (3, 4) required_690 := by decide +kernel +theorem child_required_sub_690 : ∀ j, childrenC_690 j ⊆ insert (3, 4) required_690 := by decide +kernel +theorem child_envelope_sub_690 : ∀ j, childrenD_690 j ⊆ envelope_690 := by decide +kernel +theorem pivot_mem_690 : (3, 4) ∈ envelope_690 := by decide +kernel +theorem children_work_690 : ∀ j, Template HasSnaky 12 (childrenC_690 j) (childrenD_690 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_56 6 (5, 6)).mono (by decide +kernel) + · exact row_works_690_i0.mono (by decide +kernel) +theorem row_works_690 : Template HasSnaky 13 required_690 envelope_690 := by + refine compose HasSnaky 12 childrenC_690 childrenD_690 children_work_690 (3, 4) + required_690 envelope_690 pivot_mem_690 child_required_sub_690 child_envelope_sub_690 ?_ + intro b hb + exact common_sub_690 (mem_commonEnvelope childrenD_690 b hb) +def required_692_i1 : Finset Cell := ⟨(([(3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_692_i1 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (6, 1), (6, 2), (6, 3), (6, 4), (7, 1), (7, 2), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_692_i1 : Fin 7 → Finset Cell := ![(placed21 4 (2, 7) required_13), (placed21 4 (2, 7) required_14), (placed21 3 (0, 6) required_118), (placed21 2 (4, 1) required_192), (placed21 0 (2, 1) required_193), (placed21 0 (1, 0) required_396), (placed21 7 (6, 6) required_435)] +def childrenD_692_i1 : Fin 7 → Finset Cell := ![(placed21 4 (2, 7) envelope_13), (placed21 4 (2, 7) envelope_14), (placed21 3 (0, 6) envelope_118), (placed21 2 (4, 1) envelope_192), (placed21 0 (2, 1) envelope_193), (placed21 0 (1, 0) envelope_396), (placed21 7 (6, 6) envelope_435)] +theorem common_sub_692_i1 : commonEnvelope childrenD_692_i1 ⊆ insert (3, 3) required_692_i1 := by decide +kernel +theorem child_required_sub_692_i1 : ∀ j, childrenC_692_i1 j ⊆ insert (3, 3) required_692_i1 := by decide +kernel +theorem child_envelope_sub_692_i1 : ∀ j, childrenD_692_i1 j ⊆ envelope_692_i1 := by decide +kernel +theorem pivot_mem_692_i1 : (3, 3) ∈ envelope_692_i1 := by decide +kernel +theorem children_work_692_i1 : ∀ j, Template HasSnaky 9 (childrenC_692_i1 j) (childrenD_692_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_14 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_118 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_192 2 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_193 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_396 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_435 7 (6, 6)).mono (by decide +kernel) +theorem row_works_692_i1 : Template HasSnaky 10 required_692_i1 envelope_692_i1 := by + refine compose HasSnaky 9 childrenC_692_i1 childrenD_692_i1 children_work_692_i1 (3, 3) + required_692_i1 envelope_692_i1 pivot_mem_692_i1 child_required_sub_692_i1 child_envelope_sub_692_i1 ?_ + intro b hb + exact common_sub_692_i1 (mem_commonEnvelope childrenD_692_i1 b hb) +def required_692_i2 : Finset Cell := ⟨(([(0, 5), (1, 5), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_692_i2 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 5), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (8, 3), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_692_i2 : Fin 2 → Finset Cell := ![(placed21 4 (0, 5) required_2), (placed21 4 (1, 7) required_509)] +def childrenD_692_i2 : Fin 2 → Finset Cell := ![(placed21 4 (0, 5) envelope_2), (placed21 4 (1, 7) envelope_509)] +theorem common_sub_692_i2 : commonEnvelope childrenD_692_i2 ⊆ insert (4, 4) required_692_i2 := by decide +kernel +theorem child_required_sub_692_i2 : ∀ j, childrenC_692_i2 j ⊆ insert (4, 4) required_692_i2 := by decide +kernel +theorem child_envelope_sub_692_i2 : ∀ j, childrenD_692_i2 j ⊆ envelope_692_i2 := by decide +kernel +theorem pivot_mem_692_i2 : (4, 4) ∈ envelope_692_i2 := by decide +kernel +theorem children_work_692_i2 : ∀ j, Template HasSnaky 10 (childrenC_692_i2 j) (childrenD_692_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_509 4 (1, 7)).mono (by decide +kernel) +theorem row_works_692_i2 : Template HasSnaky 11 required_692_i2 envelope_692_i2 := by + refine compose HasSnaky 10 childrenC_692_i2 childrenD_692_i2 children_work_692_i2 (4, 4) + required_692_i2 envelope_692_i2 pivot_mem_692_i2 child_required_sub_692_i2 child_envelope_sub_692_i2 ?_ + intro b hb + exact common_sub_692_i2 (mem_commonEnvelope childrenD_692_i2 b hb) +def required_692_i0 : Finset Cell := ⟨(([(0, 5), (1, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_692_i0 : Finset Cell := ⟨(([(0, 3), (0, 5), (0, 7), (1, 2), (1, 3), (1, 5), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 8), (8, 3), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_692_i0 : Fin 8 → Finset Cell := ![(placed21 0 (0, 2) required_110), (placed21 0 (0, 2) required_119), (placed21 4 (1, 8) required_399), (placed21 0 (0, 1) required_430), (placed21 0 (0, 3) required_461), (placed21 4 (1, 8) required_475), required_692_i1, required_692_i2] +def childrenD_692_i0 : Fin 8 → Finset Cell := ![(placed21 0 (0, 2) envelope_110), (placed21 0 (0, 2) envelope_119), (placed21 4 (1, 8) envelope_399), (placed21 0 (0, 1) envelope_430), (placed21 0 (0, 3) envelope_461), (placed21 4 (1, 8) envelope_475), envelope_692_i1, envelope_692_i2] +theorem common_sub_692_i0 : commonEnvelope childrenD_692_i0 ⊆ insert (3, 4) required_692_i0 := by decide +kernel +theorem child_required_sub_692_i0 : ∀ j, childrenC_692_i0 j ⊆ insert (3, 4) required_692_i0 := by decide +kernel +theorem child_envelope_sub_692_i0 : ∀ j, childrenD_692_i0 j ⊆ envelope_692_i0 := by decide +kernel +theorem pivot_mem_692_i0 : (3, 4) ∈ envelope_692_i0 := by decide +kernel +theorem children_work_692_i0 : ∀ j, Template HasSnaky 11 (childrenC_692_i0 j) (childrenD_692_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_110 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_119 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_399 4 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_430 0 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_461 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_475 4 (1, 8)).mono (by decide +kernel) + · exact row_works_692_i1.mono (by decide +kernel) + · exact row_works_692_i2.mono (by decide +kernel) +theorem row_works_692_i0 : Template HasSnaky 12 required_692_i0 envelope_692_i0 := by + refine compose HasSnaky 11 childrenC_692_i0 childrenD_692_i0 children_work_692_i0 (3, 4) + required_692_i0 envelope_692_i0 pivot_mem_692_i0 child_required_sub_692_i0 child_envelope_sub_692_i0 ?_ + intro b hb + exact common_sub_692_i0 (mem_commonEnvelope childrenD_692_i0 b hb) +def required_692 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_692 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 5), (0, 7), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 8), (8, 3), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_692 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) required_5), required_692_i0] +def childrenD_692 : Fin 2 → Finset Cell := ![(placed21 1 (0, 2) envelope_5), envelope_692_i0] +theorem common_sub_692 : commonEnvelope childrenD_692 ⊆ insert (1, 5) required_692 := by decide +kernel +theorem child_required_sub_692 : ∀ j, childrenC_692 j ⊆ insert (1, 5) required_692 := by decide +kernel +theorem child_envelope_sub_692 : ∀ j, childrenD_692 j ⊆ envelope_692 := by decide +kernel +theorem pivot_mem_692 : (1, 5) ∈ envelope_692 := by decide +kernel +theorem children_work_692 : ∀ j, Template HasSnaky 12 (childrenC_692 j) (childrenD_692 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (0, 2)).mono (by decide +kernel) + · exact row_works_692_i0.mono (by decide +kernel) +theorem row_works_692 : Template HasSnaky 13 required_692 envelope_692 := by + refine compose HasSnaky 12 childrenC_692 childrenD_692 children_work_692 (1, 5) + required_692 envelope_692 pivot_mem_692 child_required_sub_692 child_envelope_sub_692 ?_ + intro b hb + exact common_sub_692 (mem_commonEnvelope childrenD_692 b hb) +def height_675_i0 : ℕ := 8 +def childrenH_675_i0 : Fin 5 → ℕ := ![height_12, height_356, height_364, height_367, height_671] +theorem height_exact_675_i0 : height_675_i0 = 1 + Finset.univ.sup childrenH_675_i0 := by decide +kernel +theorem required_origin_675_i0 : ∀ x ∈ required_675_i0, + (∃ j, x ∈ childrenC_675_i0 j) ∨ ∀ j, x ∈ childrenD_675_i0 j := by decide +kernel +theorem required_exact_675_i0 : required_675_i0 = + ((Finset.univ.biUnion childrenC_675_i0) ∪ commonEnvelope childrenD_675_i0).erase (7, 7) := by + exact required_eq_combination childrenC_675_i0 childrenD_675_i0 (7, 7) required_675_i0 + (by decide +kernel) child_required_sub_675_i0 common_sub_675_i0 required_origin_675_i0 +theorem envelope_origin_675_i0 : ∀ x ∈ envelope_675_i0, + x = (7, 7) ∨ ∃ j, x ∈ childrenD_675_i0 j := by decide +kernel +theorem envelope_exact_675_i0 : envelope_675_i0 = + insert (7, 7) (Finset.univ.biUnion childrenD_675_i0) := by + exact envelope_eq_combination childrenD_675_i0 (7, 7) envelope_675_i0 + pivot_mem_675_i0 child_envelope_sub_675_i0 envelope_origin_675_i0 +def checked_675_i0 : CheckedCard where + required := required_675_i0 + envelope := envelope_675_i0 + height := height_675_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i0 +def height_675_i1 : ℕ := 10 +def childrenH_675_i1 : Fin 6 → ℕ := ![height_188, height_190, height_441, height_442, height_514, height_667] +theorem height_exact_675_i1 : height_675_i1 = 1 + Finset.univ.sup childrenH_675_i1 := by decide +kernel +theorem required_origin_675_i1 : ∀ x ∈ required_675_i1, + (∃ j, x ∈ childrenC_675_i1 j) ∨ ∀ j, x ∈ childrenD_675_i1 j := by decide +kernel +theorem required_exact_675_i1 : required_675_i1 = + ((Finset.univ.biUnion childrenC_675_i1) ∪ commonEnvelope childrenD_675_i1).erase (7, 4) := by + exact required_eq_combination childrenC_675_i1 childrenD_675_i1 (7, 4) required_675_i1 + (by decide +kernel) child_required_sub_675_i1 common_sub_675_i1 required_origin_675_i1 +theorem envelope_origin_675_i1 : ∀ x ∈ envelope_675_i1, + x = (7, 4) ∨ ∃ j, x ∈ childrenD_675_i1 j := by decide +kernel +theorem envelope_exact_675_i1 : envelope_675_i1 = + insert (7, 4) (Finset.univ.biUnion childrenD_675_i1) := by + exact envelope_eq_combination childrenD_675_i1 (7, 4) envelope_675_i1 + pivot_mem_675_i1 child_envelope_sub_675_i1 envelope_origin_675_i1 +def checked_675_i1 : CheckedCard where + required := required_675_i1 + envelope := envelope_675_i1 + height := height_675_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i1 +def height_675_i3 : ℕ := 6 +def childrenH_675_i3 : Fin 5 → ℕ := ![height_8, height_26, height_133, height_186, height_187] +theorem height_exact_675_i3 : height_675_i3 = 1 + Finset.univ.sup childrenH_675_i3 := by decide +kernel +theorem required_origin_675_i3 : ∀ x ∈ required_675_i3, + (∃ j, x ∈ childrenC_675_i3 j) ∨ ∀ j, x ∈ childrenD_675_i3 j := by decide +kernel +theorem required_exact_675_i3 : required_675_i3 = + ((Finset.univ.biUnion childrenC_675_i3) ∪ commonEnvelope childrenD_675_i3).erase (7, 4) := by + exact required_eq_combination childrenC_675_i3 childrenD_675_i3 (7, 4) required_675_i3 + (by decide +kernel) child_required_sub_675_i3 common_sub_675_i3 required_origin_675_i3 +theorem envelope_origin_675_i3 : ∀ x ∈ envelope_675_i3, + x = (7, 4) ∨ ∃ j, x ∈ childrenD_675_i3 j := by decide +kernel +theorem envelope_exact_675_i3 : envelope_675_i3 = + insert (7, 4) (Finset.univ.biUnion childrenD_675_i3) := by + exact envelope_eq_combination childrenD_675_i3 (7, 4) envelope_675_i3 + pivot_mem_675_i3 child_envelope_sub_675_i3 envelope_origin_675_i3 +def checked_675_i3 : CheckedCard where + required := required_675_i3 + envelope := envelope_675_i3 + height := height_675_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i3 +def height_675_i5 : ℕ := 6 +def childrenH_675_i5 : Fin 2 → ℕ := ![height_5, height_179] +theorem height_exact_675_i5 : height_675_i5 = 1 + Finset.univ.sup childrenH_675_i5 := by decide +kernel +theorem required_origin_675_i5 : ∀ x ∈ required_675_i5, + (∃ j, x ∈ childrenC_675_i5 j) ∨ ∀ j, x ∈ childrenD_675_i5 j := by decide +kernel +theorem required_exact_675_i5 : required_675_i5 = + ((Finset.univ.biUnion childrenC_675_i5) ∪ commonEnvelope childrenD_675_i5).erase (7, 4) := by + exact required_eq_combination childrenC_675_i5 childrenD_675_i5 (7, 4) required_675_i5 + (by decide +kernel) child_required_sub_675_i5 common_sub_675_i5 required_origin_675_i5 +theorem envelope_origin_675_i5 : ∀ x ∈ envelope_675_i5, + x = (7, 4) ∨ ∃ j, x ∈ childrenD_675_i5 j := by decide +kernel +theorem envelope_exact_675_i5 : envelope_675_i5 = + insert (7, 4) (Finset.univ.biUnion childrenD_675_i5) := by + exact envelope_eq_combination childrenD_675_i5 (7, 4) envelope_675_i5 + pivot_mem_675_i5 child_envelope_sub_675_i5 envelope_origin_675_i5 +def checked_675_i5 : CheckedCard where + required := required_675_i5 + envelope := envelope_675_i5 + height := height_675_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i5 +def height_675_i6 : ℕ := 5 +def childrenH_675_i6 : Fin 3 → ℕ := ![height_22, height_34, height_305] +theorem height_exact_675_i6 : height_675_i6 = 1 + Finset.univ.sup childrenH_675_i6 := by decide +kernel +theorem required_origin_675_i6 : ∀ x ∈ required_675_i6, + (∃ j, x ∈ childrenC_675_i6 j) ∨ ∀ j, x ∈ childrenD_675_i6 j := by decide +kernel +theorem required_exact_675_i6 : required_675_i6 = + ((Finset.univ.biUnion childrenC_675_i6) ∪ commonEnvelope childrenD_675_i6).erase (6, 5) := by + exact required_eq_combination childrenC_675_i6 childrenD_675_i6 (6, 5) required_675_i6 + (by decide +kernel) child_required_sub_675_i6 common_sub_675_i6 required_origin_675_i6 +theorem envelope_origin_675_i6 : ∀ x ∈ envelope_675_i6, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_675_i6 j := by decide +kernel +theorem envelope_exact_675_i6 : envelope_675_i6 = + insert (6, 5) (Finset.univ.biUnion childrenD_675_i6) := by + exact envelope_eq_combination childrenD_675_i6 (6, 5) envelope_675_i6 + pivot_mem_675_i6 child_envelope_sub_675_i6 envelope_origin_675_i6 +def checked_675_i6 : CheckedCard where + required := required_675_i6 + envelope := envelope_675_i6 + height := height_675_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i6 +def height_675_i4 : ℕ := 7 +def childrenH_675_i4 : Fin 2 → ℕ := ![height_675_i5, height_675_i6] +theorem height_exact_675_i4 : height_675_i4 = 1 + Finset.univ.sup childrenH_675_i4 := by decide +kernel +theorem required_origin_675_i4 : ∀ x ∈ required_675_i4, + (∃ j, x ∈ childrenC_675_i4 j) ∨ ∀ j, x ∈ childrenD_675_i4 j := by decide +kernel +theorem required_exact_675_i4 : required_675_i4 = + ((Finset.univ.biUnion childrenC_675_i4) ∪ commonEnvelope childrenD_675_i4).erase (6, 6) := by + exact required_eq_combination childrenC_675_i4 childrenD_675_i4 (6, 6) required_675_i4 + (by decide +kernel) child_required_sub_675_i4 common_sub_675_i4 required_origin_675_i4 +theorem envelope_origin_675_i4 : ∀ x ∈ envelope_675_i4, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_675_i4 j := by decide +kernel +theorem envelope_exact_675_i4 : envelope_675_i4 = + insert (6, 6) (Finset.univ.biUnion childrenD_675_i4) := by + exact envelope_eq_combination childrenD_675_i4 (6, 6) envelope_675_i4 + pivot_mem_675_i4 child_envelope_sub_675_i4 envelope_origin_675_i4 +def checked_675_i4 : CheckedCard where + required := required_675_i4 + envelope := envelope_675_i4 + height := height_675_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i4 +def height_675_i2 : ℕ := 11 +def childrenH_675_i2 : Fin 5 → ℕ := ![height_304, height_672, height_675_i3, height_674, height_675_i4] +theorem height_exact_675_i2 : height_675_i2 = 1 + Finset.univ.sup childrenH_675_i2 := by decide +kernel +theorem required_origin_675_i2 : ∀ x ∈ required_675_i2, + (∃ j, x ∈ childrenC_675_i2 j) ∨ ∀ j, x ∈ childrenD_675_i2 j := by decide +kernel +theorem required_exact_675_i2 : required_675_i2 = + ((Finset.univ.biUnion childrenC_675_i2) ∪ commonEnvelope childrenD_675_i2).erase (7, 3) := by + exact required_eq_combination childrenC_675_i2 childrenD_675_i2 (7, 3) required_675_i2 + (by decide +kernel) child_required_sub_675_i2 common_sub_675_i2 required_origin_675_i2 +theorem envelope_origin_675_i2 : ∀ x ∈ envelope_675_i2, + x = (7, 3) ∨ ∃ j, x ∈ childrenD_675_i2 j := by decide +kernel +theorem envelope_exact_675_i2 : envelope_675_i2 = + insert (7, 3) (Finset.univ.biUnion childrenD_675_i2) := by + exact envelope_eq_combination childrenD_675_i2 (7, 3) envelope_675_i2 + pivot_mem_675_i2 child_envelope_sub_675_i2 envelope_origin_675_i2 +def checked_675_i2 : CheckedCard where + required := required_675_i2 + envelope := envelope_675_i2 + height := height_675_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i2 +def height_675_i7 : ℕ := 8 +def childrenH_675_i7 : Fin 4 → ℕ := ![height_190, height_190, height_363, height_671] +theorem height_exact_675_i7 : height_675_i7 = 1 + Finset.univ.sup childrenH_675_i7 := by decide +kernel +theorem required_origin_675_i7 : ∀ x ∈ required_675_i7, + (∃ j, x ∈ childrenC_675_i7 j) ∨ ∀ j, x ∈ childrenD_675_i7 j := by decide +kernel +theorem required_exact_675_i7 : required_675_i7 = + ((Finset.univ.biUnion childrenC_675_i7) ∪ commonEnvelope childrenD_675_i7).erase (7, 7) := by + exact required_eq_combination childrenC_675_i7 childrenD_675_i7 (7, 7) required_675_i7 + (by decide +kernel) child_required_sub_675_i7 common_sub_675_i7 required_origin_675_i7 +theorem envelope_origin_675_i7 : ∀ x ∈ envelope_675_i7, + x = (7, 7) ∨ ∃ j, x ∈ childrenD_675_i7 j := by decide +kernel +theorem envelope_exact_675_i7 : envelope_675_i7 = + insert (7, 7) (Finset.univ.biUnion childrenD_675_i7) := by + exact envelope_eq_combination childrenD_675_i7 (7, 7) envelope_675_i7 + pivot_mem_675_i7 child_envelope_sub_675_i7 envelope_origin_675_i7 +def checked_675_i7 : CheckedCard where + required := required_675_i7 + envelope := envelope_675_i7 + height := height_675_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i7 +def height_675_i8 : ℕ := 11 +def childrenH_675_i8 : Fin 3 → ℕ := ![height_34, height_97, height_535] +theorem height_exact_675_i8 : height_675_i8 = 1 + Finset.univ.sup childrenH_675_i8 := by decide +kernel +theorem required_origin_675_i8 : ∀ x ∈ required_675_i8, + (∃ j, x ∈ childrenC_675_i8 j) ∨ ∀ j, x ∈ childrenD_675_i8 j := by decide +kernel +theorem required_exact_675_i8 : required_675_i8 = + ((Finset.univ.biUnion childrenC_675_i8) ∪ commonEnvelope childrenD_675_i8).erase (6, 5) := by + exact required_eq_combination childrenC_675_i8 childrenD_675_i8 (6, 5) required_675_i8 + (by decide +kernel) child_required_sub_675_i8 common_sub_675_i8 required_origin_675_i8 +theorem envelope_origin_675_i8 : ∀ x ∈ envelope_675_i8, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_675_i8 j := by decide +kernel +theorem envelope_exact_675_i8 : envelope_675_i8 = + insert (6, 5) (Finset.univ.biUnion childrenD_675_i8) := by + exact envelope_eq_combination childrenD_675_i8 (6, 5) envelope_675_i8 + pivot_mem_675_i8 child_envelope_sub_675_i8 envelope_origin_675_i8 +def checked_675_i8 : CheckedCard where + required := required_675_i8 + envelope := envelope_675_i8 + height := height_675_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i8 +def height_675_i10 : ℕ := 9 +def childrenH_675_i10 : Fin 2 → ℕ := ![height_321, height_354] +theorem height_exact_675_i10 : height_675_i10 = 1 + Finset.univ.sup childrenH_675_i10 := by decide +kernel +theorem required_origin_675_i10 : ∀ x ∈ required_675_i10, + (∃ j, x ∈ childrenC_675_i10 j) ∨ ∀ j, x ∈ childrenD_675_i10 j := by decide +kernel +theorem required_exact_675_i10 : required_675_i10 = + ((Finset.univ.biUnion childrenC_675_i10) ∪ commonEnvelope childrenD_675_i10).erase (7, 4) := by + exact required_eq_combination childrenC_675_i10 childrenD_675_i10 (7, 4) required_675_i10 + (by decide +kernel) child_required_sub_675_i10 common_sub_675_i10 required_origin_675_i10 +theorem envelope_origin_675_i10 : ∀ x ∈ envelope_675_i10, + x = (7, 4) ∨ ∃ j, x ∈ childrenD_675_i10 j := by decide +kernel +theorem envelope_exact_675_i10 : envelope_675_i10 = + insert (7, 4) (Finset.univ.biUnion childrenD_675_i10) := by + exact envelope_eq_combination childrenD_675_i10 (7, 4) envelope_675_i10 + pivot_mem_675_i10 child_envelope_sub_675_i10 envelope_origin_675_i10 +def checked_675_i10 : CheckedCard where + required := required_675_i10 + envelope := envelope_675_i10 + height := height_675_i10 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i10 +def height_675_i9 : ℕ := 11 +def childrenH_675_i9 : Fin 6 → ℕ := ![height_328, height_330, height_384, height_672, height_674, height_675_i10] +theorem height_exact_675_i9 : height_675_i9 = 1 + Finset.univ.sup childrenH_675_i9 := by decide +kernel +theorem required_origin_675_i9 : ∀ x ∈ required_675_i9, + (∃ j, x ∈ childrenC_675_i9 j) ∨ ∀ j, x ∈ childrenD_675_i9 j := by decide +kernel +theorem required_exact_675_i9 : required_675_i9 = + ((Finset.univ.biUnion childrenC_675_i9) ∪ commonEnvelope childrenD_675_i9).erase (7, 3) := by + exact required_eq_combination childrenC_675_i9 childrenD_675_i9 (7, 3) required_675_i9 + (by decide +kernel) child_required_sub_675_i9 common_sub_675_i9 required_origin_675_i9 +theorem envelope_origin_675_i9 : ∀ x ∈ envelope_675_i9, + x = (7, 3) ∨ ∃ j, x ∈ childrenD_675_i9 j := by decide +kernel +theorem envelope_exact_675_i9 : envelope_675_i9 = + insert (7, 3) (Finset.univ.biUnion childrenD_675_i9) := by + exact envelope_eq_combination childrenD_675_i9 (7, 3) envelope_675_i9 + pivot_mem_675_i9 child_envelope_sub_675_i9 envelope_origin_675_i9 +def checked_675_i9 : CheckedCard where + required := required_675_i9 + envelope := envelope_675_i9 + height := height_675_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675_i9 +def height_675 : ℕ := 13 +def childrenH_675 : Fin 9 → ℕ := ![height_459, height_618, height_629, height_675_i0, height_675_i1, height_675_i2, height_675_i7, height_675_i8, height_675_i9] +theorem height_exact_675 : height_675 = 1 + Finset.univ.sup childrenH_675 := by decide +kernel +theorem required_origin_675 : ∀ x ∈ required_675, + (∃ j, x ∈ childrenC_675 j) ∨ ∀ j, x ∈ childrenD_675 j := by decide +kernel +theorem required_exact_675 : required_675 = + ((Finset.univ.biUnion childrenC_675) ∪ commonEnvelope childrenD_675).erase (7, 6) := by + exact required_eq_combination childrenC_675 childrenD_675 (7, 6) required_675 + (by decide +kernel) child_required_sub_675 common_sub_675 required_origin_675 +theorem envelope_origin_675 : ∀ x ∈ envelope_675, + x = (7, 6) ∨ ∃ j, x ∈ childrenD_675 j := by decide +kernel +theorem envelope_exact_675 : envelope_675 = + insert (7, 6) (Finset.univ.biUnion childrenD_675) := by + exact envelope_eq_combination childrenD_675 (7, 6) envelope_675 + pivot_mem_675 child_envelope_sub_675 envelope_origin_675 +def checked_675 : CheckedCard where + required := required_675 + envelope := envelope_675 + height := height_675 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_675 +def height_690_i0 : ℕ := 12 +def childrenH_690_i0 : Fin 3 → ℕ := ![height_39, height_80, height_463] +theorem height_exact_690_i0 : height_690_i0 = 1 + Finset.univ.sup childrenH_690_i0 := by decide +kernel +theorem required_origin_690_i0 : ∀ x ∈ required_690_i0, + (∃ j, x ∈ childrenC_690_i0 j) ∨ ∀ j, x ∈ childrenD_690_i0 j := by decide +kernel +theorem required_exact_690_i0 : required_690_i0 = + ((Finset.univ.biUnion childrenC_690_i0) ∪ commonEnvelope childrenD_690_i0).erase (3, 6) := by + exact required_eq_combination childrenC_690_i0 childrenD_690_i0 (3, 6) required_690_i0 + (by decide +kernel) child_required_sub_690_i0 common_sub_690_i0 required_origin_690_i0 +theorem envelope_origin_690_i0 : ∀ x ∈ envelope_690_i0, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_690_i0 j := by decide +kernel +theorem envelope_exact_690_i0 : envelope_690_i0 = + insert (3, 6) (Finset.univ.biUnion childrenD_690_i0) := by + exact envelope_eq_combination childrenD_690_i0 (3, 6) envelope_690_i0 + pivot_mem_690_i0 child_envelope_sub_690_i0 envelope_origin_690_i0 +def checked_690_i0 : CheckedCard where + required := required_690_i0 + envelope := envelope_690_i0 + height := height_690_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_690_i0 +def height_690 : ℕ := 13 +def childrenH_690 : Fin 3 → ℕ := ![height_21, height_56, height_690_i0] +theorem height_exact_690 : height_690 = 1 + Finset.univ.sup childrenH_690 := by decide +kernel +theorem required_origin_690 : ∀ x ∈ required_690, + (∃ j, x ∈ childrenC_690 j) ∨ ∀ j, x ∈ childrenD_690 j := by decide +kernel +theorem required_exact_690 : required_690 = + ((Finset.univ.biUnion childrenC_690) ∪ commonEnvelope childrenD_690).erase (3, 4) := by + exact required_eq_combination childrenC_690 childrenD_690 (3, 4) required_690 + (by decide +kernel) child_required_sub_690 common_sub_690 required_origin_690 +theorem envelope_origin_690 : ∀ x ∈ envelope_690, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_690 j := by decide +kernel +theorem envelope_exact_690 : envelope_690 = + insert (3, 4) (Finset.univ.biUnion childrenD_690) := by + exact envelope_eq_combination childrenD_690 (3, 4) envelope_690 + pivot_mem_690 child_envelope_sub_690 envelope_origin_690 +def checked_690 : CheckedCard where + required := required_690 + envelope := envelope_690 + height := height_690 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_690 +def height_692_i1 : ℕ := 10 +def childrenH_692_i1 : Fin 7 → ℕ := ![height_13, height_14, height_118, height_192, height_193, height_396, height_435] +theorem height_exact_692_i1 : height_692_i1 = 1 + Finset.univ.sup childrenH_692_i1 := by decide +kernel +theorem required_origin_692_i1 : ∀ x ∈ required_692_i1, + (∃ j, x ∈ childrenC_692_i1 j) ∨ ∀ j, x ∈ childrenD_692_i1 j := by decide +kernel +theorem required_exact_692_i1 : required_692_i1 = + ((Finset.univ.biUnion childrenC_692_i1) ∪ commonEnvelope childrenD_692_i1).erase (3, 3) := by + exact required_eq_combination childrenC_692_i1 childrenD_692_i1 (3, 3) required_692_i1 + (by decide +kernel) child_required_sub_692_i1 common_sub_692_i1 required_origin_692_i1 +theorem envelope_origin_692_i1 : ∀ x ∈ envelope_692_i1, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_692_i1 j := by decide +kernel +theorem envelope_exact_692_i1 : envelope_692_i1 = + insert (3, 3) (Finset.univ.biUnion childrenD_692_i1) := by + exact envelope_eq_combination childrenD_692_i1 (3, 3) envelope_692_i1 + pivot_mem_692_i1 child_envelope_sub_692_i1 envelope_origin_692_i1 +def checked_692_i1 : CheckedCard where + required := required_692_i1 + envelope := envelope_692_i1 + height := height_692_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_692_i1 +def height_692_i2 : ℕ := 11 +def childrenH_692_i2 : Fin 2 → ℕ := ![height_2, height_509] +theorem height_exact_692_i2 : height_692_i2 = 1 + Finset.univ.sup childrenH_692_i2 := by decide +kernel +theorem required_origin_692_i2 : ∀ x ∈ required_692_i2, + (∃ j, x ∈ childrenC_692_i2 j) ∨ ∀ j, x ∈ childrenD_692_i2 j := by decide +kernel +theorem required_exact_692_i2 : required_692_i2 = + ((Finset.univ.biUnion childrenC_692_i2) ∪ commonEnvelope childrenD_692_i2).erase (4, 4) := by + exact required_eq_combination childrenC_692_i2 childrenD_692_i2 (4, 4) required_692_i2 + (by decide +kernel) child_required_sub_692_i2 common_sub_692_i2 required_origin_692_i2 +theorem envelope_origin_692_i2 : ∀ x ∈ envelope_692_i2, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_692_i2 j := by decide +kernel +theorem envelope_exact_692_i2 : envelope_692_i2 = + insert (4, 4) (Finset.univ.biUnion childrenD_692_i2) := by + exact envelope_eq_combination childrenD_692_i2 (4, 4) envelope_692_i2 + pivot_mem_692_i2 child_envelope_sub_692_i2 envelope_origin_692_i2 +def checked_692_i2 : CheckedCard where + required := required_692_i2 + envelope := envelope_692_i2 + height := height_692_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_692_i2 +def height_692_i0 : ℕ := 12 +def childrenH_692_i0 : Fin 8 → ℕ := ![height_110, height_119, height_399, height_430, height_461, height_475, height_692_i1, height_692_i2] +theorem height_exact_692_i0 : height_692_i0 = 1 + Finset.univ.sup childrenH_692_i0 := by decide +kernel +theorem required_origin_692_i0 : ∀ x ∈ required_692_i0, + (∃ j, x ∈ childrenC_692_i0 j) ∨ ∀ j, x ∈ childrenD_692_i0 j := by decide +kernel +theorem required_exact_692_i0 : required_692_i0 = + ((Finset.univ.biUnion childrenC_692_i0) ∪ commonEnvelope childrenD_692_i0).erase (3, 4) := by + exact required_eq_combination childrenC_692_i0 childrenD_692_i0 (3, 4) required_692_i0 + (by decide +kernel) child_required_sub_692_i0 common_sub_692_i0 required_origin_692_i0 +theorem envelope_origin_692_i0 : ∀ x ∈ envelope_692_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_692_i0 j := by decide +kernel +theorem envelope_exact_692_i0 : envelope_692_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_692_i0) := by + exact envelope_eq_combination childrenD_692_i0 (3, 4) envelope_692_i0 + pivot_mem_692_i0 child_envelope_sub_692_i0 envelope_origin_692_i0 +def checked_692_i0 : CheckedCard where + required := required_692_i0 + envelope := envelope_692_i0 + height := height_692_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_692_i0 +def height_692 : ℕ := 13 +def childrenH_692 : Fin 2 → ℕ := ![height_5, height_692_i0] +theorem height_exact_692 : height_692 = 1 + Finset.univ.sup childrenH_692 := by decide +kernel +theorem required_origin_692 : ∀ x ∈ required_692, + (∃ j, x ∈ childrenC_692 j) ∨ ∀ j, x ∈ childrenD_692 j := by decide +kernel +theorem required_exact_692 : required_692 = + ((Finset.univ.biUnion childrenC_692) ∪ commonEnvelope childrenD_692).erase (1, 5) := by + exact required_eq_combination childrenC_692 childrenD_692 (1, 5) required_692 + (by decide +kernel) child_required_sub_692 common_sub_692 required_origin_692 +theorem envelope_origin_692 : ∀ x ∈ envelope_692, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_692 j := by decide +kernel +theorem envelope_exact_692 : envelope_692 = + insert (1, 5) (Finset.univ.biUnion childrenD_692) := by + exact envelope_eq_combination childrenD_692 (1, 5) envelope_692 + pivot_mem_692 child_envelope_sub_692 envelope_origin_692 +def checked_692 : CheckedCard where + required := required_692 + envelope := envelope_692 + height := height_692 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_692 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part06.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part06.lean new file mode 100644 index 0000000..c39ac7f --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part06.lean @@ -0,0 +1,800 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part08 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_695_i6 : Finset Cell := ⟨(([(1, 4), (1, 5), (1, 7), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_695_i6 : Finset Cell := ⟨(([(0, 7), (0, 8), (0, 9), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_695_i6 : Fin 3 → Finset Cell := ![(placed21 0 (1, 3) required_11), (placed21 2 (2, 2) required_75), (placed21 4 (1, 7) required_103)] +def childrenD_695_i6 : Fin 3 → Finset Cell := ![(placed21 0 (1, 3) envelope_11), (placed21 2 (2, 2) envelope_75), (placed21 4 (1, 7) envelope_103)] +theorem common_sub_695_i6 : commonEnvelope childrenD_695_i6 ⊆ insert (1, 6) required_695_i6 := by decide +kernel +theorem child_required_sub_695_i6 : ∀ j, childrenC_695_i6 j ⊆ insert (1, 6) required_695_i6 := by decide +kernel +theorem child_envelope_sub_695_i6 : ∀ j, childrenD_695_i6 j ⊆ envelope_695_i6 := by decide +kernel +theorem pivot_mem_695_i6 : (1, 6) ∈ envelope_695_i6 := by decide +kernel +theorem children_work_695_i6 : ∀ j, Template HasSnaky 4 (childrenC_695_i6 j) (childrenD_695_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 0 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_75 2 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_103 4 (1, 7)).mono (by decide +kernel) +theorem row_works_695_i6 : Template HasSnaky 5 required_695_i6 envelope_695_i6 := by + refine compose HasSnaky 4 childrenC_695_i6 childrenD_695_i6 children_work_695_i6 (1, 6) + required_695_i6 envelope_695_i6 pivot_mem_695_i6 child_required_sub_695_i6 child_envelope_sub_695_i6 ?_ + intro b hb + exact common_sub_695_i6 (mem_commonEnvelope childrenD_695_i6 b hb) +def required_695_i7 : Finset Cell := ⟨(([(1, 4), (1, 5), (1, 7), (2, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_695_i7 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 3), (0, 7), (0, 8), (0, 9), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 8), (2, 9), (2, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_695_i7 : Fin 3 → Finset Cell := ![(placed21 0 (1, 3) required_11), (placed21 2 (2, 4) required_17), (placed21 7 (2, 7) required_90)] +def childrenD_695_i7 : Fin 3 → Finset Cell := ![(placed21 0 (1, 3) envelope_11), (placed21 2 (2, 4) envelope_17), (placed21 7 (2, 7) envelope_90)] +theorem common_sub_695_i7 : commonEnvelope childrenD_695_i7 ⊆ insert (1, 6) required_695_i7 := by decide +kernel +theorem child_required_sub_695_i7 : ∀ j, childrenC_695_i7 j ⊆ insert (1, 6) required_695_i7 := by decide +kernel +theorem child_envelope_sub_695_i7 : ∀ j, childrenD_695_i7 j ⊆ envelope_695_i7 := by decide +kernel +theorem pivot_mem_695_i7 : (1, 6) ∈ envelope_695_i7 := by decide +kernel +theorem children_work_695_i7 : ∀ j, Template HasSnaky 4 (childrenC_695_i7 j) (childrenD_695_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 0 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_17 2 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_90 7 (2, 7)).mono (by decide +kernel) +theorem row_works_695_i7 : Template HasSnaky 5 required_695_i7 envelope_695_i7 := by + refine compose HasSnaky 4 childrenC_695_i7 childrenD_695_i7 children_work_695_i7 (1, 6) + required_695_i7 envelope_695_i7 pivot_mem_695_i7 child_required_sub_695_i7 child_envelope_sub_695_i7 ?_ + intro b hb + exact common_sub_695_i7 (mem_commonEnvelope childrenD_695_i7 b hb) +def required_695_i5 : Finset Cell := ⟨(([(1, 4), (1, 5), (2, 5), (3, 8), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_695_i5 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_695_i5 : Fin 4 → Finset Cell := ![(placed21 6 (2, 8) required_308), (placed21 5 (5, 5) required_348), required_695_i6, required_695_i7] +def childrenD_695_i5 : Fin 4 → Finset Cell := ![(placed21 6 (2, 8) envelope_308), (placed21 5 (5, 5) envelope_348), envelope_695_i6, envelope_695_i7] +theorem common_sub_695_i5 : commonEnvelope childrenD_695_i5 ⊆ insert (1, 7) required_695_i5 := by decide +kernel +theorem child_required_sub_695_i5 : ∀ j, childrenC_695_i5 j ⊆ insert (1, 7) required_695_i5 := by decide +kernel +theorem child_envelope_sub_695_i5 : ∀ j, childrenD_695_i5 j ⊆ envelope_695_i5 := by decide +kernel +theorem pivot_mem_695_i5 : (1, 7) ∈ envelope_695_i5 := by decide +kernel +theorem children_work_695_i5 : ∀ j, Template HasSnaky 6 (childrenC_695_i5 j) (childrenD_695_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_308 6 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_348 5 (5, 5)).mono (by decide +kernel) + · exact row_works_695_i6.mono (by decide +kernel) + · exact row_works_695_i7.mono (by decide +kernel) +theorem row_works_695_i5 : Template HasSnaky 7 required_695_i5 envelope_695_i5 := by + refine compose HasSnaky 6 childrenC_695_i5 childrenD_695_i5 children_work_695_i5 (1, 7) + required_695_i5 envelope_695_i5 pivot_mem_695_i5 child_required_sub_695_i5 child_envelope_sub_695_i5 ?_ + intro b hb + exact common_sub_695_i5 (mem_commonEnvelope childrenD_695_i5 b hb) +def required_695_i4 : Finset Cell := ⟨(([(1, 5), (2, 5), (3, 5), (3, 8), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_695_i4 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 5), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_695_i4 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) required_5), required_695_i5] +def childrenD_695_i4 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) envelope_5), envelope_695_i5] +theorem common_sub_695_i4 : commonEnvelope childrenD_695_i4 ⊆ insert (1, 4) required_695_i4 := by decide +kernel +theorem child_required_sub_695_i4 : ∀ j, childrenC_695_i4 j ⊆ insert (1, 4) required_695_i4 := by decide +kernel +theorem child_envelope_sub_695_i4 : ∀ j, childrenD_695_i4 j ⊆ envelope_695_i4 := by decide +kernel +theorem pivot_mem_695_i4 : (1, 4) ∈ envelope_695_i4 := by decide +kernel +theorem children_work_695_i4 : ∀ j, Template HasSnaky 7 (childrenC_695_i4 j) (childrenD_695_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 5)).mono (by decide +kernel) + · exact row_works_695_i5.mono (by decide +kernel) +theorem row_works_695_i4 : Template HasSnaky 8 required_695_i4 envelope_695_i4 := by + refine compose HasSnaky 7 childrenC_695_i4 childrenD_695_i4 children_work_695_i4 (1, 4) + required_695_i4 envelope_695_i4 pivot_mem_695_i4 child_required_sub_695_i4 child_envelope_sub_695_i4 ?_ + intro b hb + exact common_sub_695_i4 (mem_commonEnvelope childrenD_695_i4 b hb) +def required_695_i3 : Finset Cell := ⟨(([(1, 5), (2, 5), (3, 5), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_695_i3 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 5), (3, 7), (3, 8), (3, 9), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_695_i3 : Fin 2 → Finset Cell := ![(placed21 0 (1, 4) required_96), required_695_i4] +def childrenD_695_i3 : Fin 2 → Finset Cell := ![(placed21 0 (1, 4) envelope_96), envelope_695_i4] +theorem common_sub_695_i3 : commonEnvelope childrenD_695_i3 ⊆ insert (3, 8) required_695_i3 := by decide +kernel +theorem child_required_sub_695_i3 : ∀ j, childrenC_695_i3 j ⊆ insert (3, 8) required_695_i3 := by decide +kernel +theorem child_envelope_sub_695_i3 : ∀ j, childrenD_695_i3 j ⊆ envelope_695_i3 := by decide +kernel +theorem pivot_mem_695_i3 : (3, 8) ∈ envelope_695_i3 := by decide +kernel +theorem children_work_695_i3 : ∀ j, Template HasSnaky 8 (childrenC_695_i3 j) (childrenD_695_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_96 0 (1, 4)).mono (by decide +kernel) + · exact row_works_695_i4.mono (by decide +kernel) +theorem row_works_695_i3 : Template HasSnaky 9 required_695_i3 envelope_695_i3 := by + refine compose HasSnaky 8 childrenC_695_i3 childrenD_695_i3 children_work_695_i3 (3, 8) + required_695_i3 envelope_695_i3 pivot_mem_695_i3 child_required_sub_695_i3 child_envelope_sub_695_i3 ?_ + intro b hb + exact common_sub_695_i3 (mem_commonEnvelope childrenD_695_i3 b hb) +def required_695_i2 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 5), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_695_i2 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 5), (3, 7), (3, 8), (3, 9), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 6), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_695_i2 : Fin 2 → Finset Cell := ![(placed21 0 (1, 5) required_5), required_695_i3] +def childrenD_695_i2 : Fin 2 → Finset Cell := ![(placed21 0 (1, 5) envelope_5), envelope_695_i3] +theorem common_sub_695_i2 : commonEnvelope childrenD_695_i2 ⊆ insert (1, 5) required_695_i2 := by decide +kernel +theorem child_required_sub_695_i2 : ∀ j, childrenC_695_i2 j ⊆ insert (1, 5) required_695_i2 := by decide +kernel +theorem child_envelope_sub_695_i2 : ∀ j, childrenD_695_i2 j ⊆ envelope_695_i2 := by decide +kernel +theorem pivot_mem_695_i2 : (1, 5) ∈ envelope_695_i2 := by decide +kernel +theorem children_work_695_i2 : ∀ j, Template HasSnaky 9 (childrenC_695_i2 j) (childrenD_695_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 0 (1, 5)).mono (by decide +kernel) + · exact row_works_695_i3.mono (by decide +kernel) +theorem row_works_695_i2 : Template HasSnaky 10 required_695_i2 envelope_695_i2 := by + refine compose HasSnaky 9 childrenC_695_i2 childrenD_695_i2 children_work_695_i2 (1, 5) + required_695_i2 envelope_695_i2 pivot_mem_695_i2 child_required_sub_695_i2 child_envelope_sub_695_i2 ?_ + intro b hb + exact common_sub_695_i2 (mem_commonEnvelope childrenD_695_i2 b hb) +def required_695_i1 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_695_i1 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 5), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 6), (6, 7), (6, 8), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_695_i1 : Fin 6 → Finset Cell := ![(placed21 2 (5, 3) required_67), (placed21 6 (5, 9) required_175), (placed21 1 (1, 4) required_228), (placed21 5 (7, 4) required_435), (placed21 1 (0, 5) required_688), required_695_i2] +def childrenD_695_i1 : Fin 6 → Finset Cell := ![(placed21 2 (5, 3) envelope_67), (placed21 6 (5, 9) envelope_175), (placed21 1 (1, 4) envelope_228), (placed21 5 (7, 4) envelope_435), (placed21 1 (0, 5) envelope_688), envelope_695_i2] +theorem common_sub_695_i1 : commonEnvelope childrenD_695_i1 ⊆ insert (4, 7) required_695_i1 := by decide +kernel +theorem child_required_sub_695_i1 : ∀ j, childrenC_695_i1 j ⊆ insert (4, 7) required_695_i1 := by decide +kernel +theorem child_envelope_sub_695_i1 : ∀ j, childrenD_695_i1 j ⊆ envelope_695_i1 := by decide +kernel +theorem pivot_mem_695_i1 : (4, 7) ∈ envelope_695_i1 := by decide +kernel +theorem children_work_695_i1 : ∀ j, Template HasSnaky 10 (childrenC_695_i1 j) (childrenD_695_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_67 2 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_175 6 (5, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_228 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_688 1 (0, 5)).mono (by decide +kernel) + · exact row_works_695_i2.mono (by decide +kernel) +theorem row_works_695_i1 : Template HasSnaky 11 required_695_i1 envelope_695_i1 := by + refine compose HasSnaky 10 childrenC_695_i1 childrenD_695_i1 children_work_695_i1 (4, 7) + required_695_i1 envelope_695_i1 pivot_mem_695_i1 child_required_sub_695_i1 child_envelope_sub_695_i1 ?_ + intro b hb + exact common_sub_695_i1 (mem_commonEnvelope childrenD_695_i1 b hb) +def required_695_i0 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_695_i0 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 6), (6, 7), (6, 8), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_695_i0 : Fin 4 → Finset Cell := ![(placed21 1 (1, 5) required_44), (placed21 2 (5, 1) required_324), (placed21 0 (0, 2) required_686), required_695_i1] +def childrenD_695_i0 : Fin 4 → Finset Cell := ![(placed21 1 (1, 5) envelope_44), (placed21 2 (5, 1) envelope_324), (placed21 0 (0, 2) envelope_686), envelope_695_i1] +theorem common_sub_695_i0 : commonEnvelope childrenD_695_i0 ⊆ insert (4, 6) required_695_i0 := by decide +kernel +theorem child_required_sub_695_i0 : ∀ j, childrenC_695_i0 j ⊆ insert (4, 6) required_695_i0 := by decide +kernel +theorem child_envelope_sub_695_i0 : ∀ j, childrenD_695_i0 j ⊆ envelope_695_i0 := by decide +kernel +theorem pivot_mem_695_i0 : (4, 6) ∈ envelope_695_i0 := by decide +kernel +theorem children_work_695_i0 : ∀ j, Template HasSnaky 11 (childrenC_695_i0 j) (childrenD_695_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 1 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_324 2 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_686 0 (0, 2)).mono (by decide +kernel) + · exact row_works_695_i1.mono (by decide +kernel) +theorem row_works_695_i0 : Template HasSnaky 12 required_695_i0 envelope_695_i0 := by + refine compose HasSnaky 11 childrenC_695_i0 childrenD_695_i0 children_work_695_i0 (4, 6) + required_695_i0 envelope_695_i0 pivot_mem_695_i0 child_required_sub_695_i0 child_envelope_sub_695_i0 ?_ + intro b hb + exact common_sub_695_i0 (mem_commonEnvelope childrenD_695_i0 b hb) +def required_695 : Finset Cell := ⟨(([(2, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_695 : Finset Cell := ⟨(([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 7), (0, 8), (0, 9), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_695 : Fin 5 → Finset Cell := ![(placed21 1 (0, 4) required_12), (placed21 4 (1, 8) required_118), (placed21 1 (0, 3) required_135), (placed21 3 (0, 7) required_182), required_695_i0] +def childrenD_695 : Fin 5 → Finset Cell := ![(placed21 1 (0, 4) envelope_12), (placed21 4 (1, 8) envelope_118), (placed21 1 (0, 3) envelope_135), (placed21 3 (0, 7) envelope_182), envelope_695_i0] +theorem common_sub_695 : commonEnvelope childrenD_695 ⊆ insert (4, 5) required_695 := by decide +kernel +theorem child_required_sub_695 : ∀ j, childrenC_695 j ⊆ insert (4, 5) required_695 := by decide +kernel +theorem child_envelope_sub_695 : ∀ j, childrenD_695 j ⊆ envelope_695 := by decide +kernel +theorem pivot_mem_695 : (4, 5) ∈ envelope_695 := by decide +kernel +theorem children_work_695 : ∀ j, Template HasSnaky 12 (childrenC_695 j) (childrenD_695 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_118 4 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_135 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_182 3 (0, 7)).mono (by decide +kernel) + · exact row_works_695_i0.mono (by decide +kernel) +theorem row_works_695 : Template HasSnaky 13 required_695 envelope_695 := by + refine compose HasSnaky 12 childrenC_695 childrenD_695 children_work_695 (4, 5) + required_695 envelope_695 pivot_mem_695 child_required_sub_695 child_envelope_sub_695 ?_ + intro b hb + exact common_sub_695 (mem_commonEnvelope childrenD_695 b hb) +def required_696_i1 : Finset Cell := ⟨(([(4, 4), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_696_i1 : Finset Cell := ⟨(([(4, 3), (4, 4), (4, 8), (4, 9), (4, 10), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_696_i1 : Fin 2 → Finset Cell := ![(placed21 7 (5, 7) required_5), (placed21 5 (6, 4) required_197)] +def childrenD_696_i1 : Fin 2 → Finset Cell := ![(placed21 7 (5, 7) envelope_5), (placed21 5 (6, 4) envelope_197)] +theorem common_sub_696_i1 : commonEnvelope childrenD_696_i1 ⊆ insert (5, 7) required_696_i1 := by decide +kernel +theorem child_required_sub_696_i1 : ∀ j, childrenC_696_i1 j ⊆ insert (5, 7) required_696_i1 := by decide +kernel +theorem child_envelope_sub_696_i1 : ∀ j, childrenD_696_i1 j ⊆ envelope_696_i1 := by decide +kernel +theorem pivot_mem_696_i1 : (5, 7) ∈ envelope_696_i1 := by decide +kernel +theorem children_work_696_i1 : ∀ j, Template HasSnaky 5 (childrenC_696_i1 j) (childrenD_696_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 7 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_197 5 (6, 4)).mono (by decide +kernel) +theorem row_works_696_i1 : Template HasSnaky 6 required_696_i1 envelope_696_i1 := by + refine compose HasSnaky 5 childrenC_696_i1 childrenD_696_i1 children_work_696_i1 (5, 7) + required_696_i1 envelope_696_i1 pivot_mem_696_i1 child_required_sub_696_i1 child_envelope_sub_696_i1 ?_ + intro b hb + exact common_sub_696_i1 (mem_commonEnvelope childrenD_696_i1 b hb) +def required_696_i0 : Finset Cell := ⟨(([(5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_696_i0 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 7), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 8), (4, 9), (4, 10), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 3), (7, 4), (7, 5), (8, 3), (8, 4), (8, 5), (9, 3), (9, 4), (9, 5), (10, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_696_i0 : Fin 4 → Finset Cell := ![(placed21 3 (1, 7) required_317), required_696_i1, (placed21 7 (8, 7) required_436), (placed21 6 (8, 9) required_685)] +def childrenD_696_i0 : Fin 4 → Finset Cell := ![(placed21 3 (1, 7) envelope_317), envelope_696_i1, (placed21 7 (8, 7) envelope_436), (placed21 6 (8, 9) envelope_685)] +theorem common_sub_696_i0 : commonEnvelope childrenD_696_i0 ⊆ insert (4, 4) required_696_i0 := by decide +kernel +theorem child_required_sub_696_i0 : ∀ j, childrenC_696_i0 j ⊆ insert (4, 4) required_696_i0 := by decide +kernel +theorem child_envelope_sub_696_i0 : ∀ j, childrenD_696_i0 j ⊆ envelope_696_i0 := by decide +kernel +theorem pivot_mem_696_i0 : (4, 4) ∈ envelope_696_i0 := by decide +kernel +theorem children_work_696_i0 : ∀ j, Template HasSnaky 11 (childrenC_696_i0 j) (childrenD_696_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_317 3 (1, 7)).mono (by decide +kernel) + · exact row_works_696_i1.mono (by decide +kernel) + · exact (placed21_template row_works_436 7 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_685 6 (8, 9)).mono (by decide +kernel) +theorem row_works_696_i0 : Template HasSnaky 12 required_696_i0 envelope_696_i0 := by + refine compose HasSnaky 11 childrenC_696_i0 childrenD_696_i0 children_work_696_i0 (4, 4) + required_696_i0 envelope_696_i0 pivot_mem_696_i0 child_required_sub_696_i0 child_envelope_sub_696_i0 ?_ + intro b hb + exact common_sub_696_i0 (mem_commonEnvelope childrenD_696_i0 b hb) +def required_696 : Finset Cell := ⟨(([(5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_696 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 7), (1, 9), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6), (4, 8), (4, 9), (4, 10), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (10, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_696 : Fin 6 → Finset Cell := ![(placed21 6 (6, 8) required_12), (placed21 7 (9, 7) required_322), (placed21 2 (6, 1) required_369), (placed21 7 (8, 7) required_435), (placed21 0 (2, 1) required_622), required_696_i0] +def childrenD_696 : Fin 6 → Finset Cell := ![(placed21 6 (6, 8) envelope_12), (placed21 7 (9, 7) envelope_322), (placed21 2 (6, 1) envelope_369), (placed21 7 (8, 7) envelope_435), (placed21 0 (2, 1) envelope_622), envelope_696_i0] +theorem common_sub_696 : commonEnvelope childrenD_696 ⊆ insert (5, 4) required_696 := by decide +kernel +theorem child_required_sub_696 : ∀ j, childrenC_696 j ⊆ insert (5, 4) required_696 := by decide +kernel +theorem child_envelope_sub_696 : ∀ j, childrenD_696 j ⊆ envelope_696 := by decide +kernel +theorem pivot_mem_696 : (5, 4) ∈ envelope_696 := by decide +kernel +theorem children_work_696 : ∀ j, Template HasSnaky 12 (childrenC_696 j) (childrenD_696 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 6 (6, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_322 7 (9, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_369 2 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_435 7 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_622 0 (2, 1)).mono (by decide +kernel) + · exact row_works_696_i0.mono (by decide +kernel) +theorem row_works_696 : Template HasSnaky 13 required_696 envelope_696 := by + refine compose HasSnaky 12 childrenC_696 childrenD_696 children_work_696 (5, 4) + required_696 envelope_696 pivot_mem_696 child_required_sub_696 child_envelope_sub_696 ?_ + intro b hb + exact common_sub_696 (mem_commonEnvelope childrenD_696 b hb) +def required_709_i2 : Finset Cell := ⟨(([(5, 4), (5, 5), (5, 6), (5, 7), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_709_i2 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_709_i2 : Fin 3 → Finset Cell := ![(placed21 1 (2, 5) required_53), (placed21 3 (2, 7) required_56), (placed21 0 (4, 3) required_392)] +def childrenD_709_i2 : Fin 3 → Finset Cell := ![(placed21 1 (2, 5) envelope_53), (placed21 3 (2, 7) envelope_56), (placed21 0 (4, 3) envelope_392)] +theorem common_sub_709_i2 : commonEnvelope childrenD_709_i2 ⊆ insert (4, 5) required_709_i2 := by decide +kernel +theorem child_required_sub_709_i2 : ∀ j, childrenC_709_i2 j ⊆ insert (4, 5) required_709_i2 := by decide +kernel +theorem child_envelope_sub_709_i2 : ∀ j, childrenD_709_i2 j ⊆ envelope_709_i2 := by decide +kernel +theorem pivot_mem_709_i2 : (4, 5) ∈ envelope_709_i2 := by decide +kernel +theorem children_work_709_i2 : ∀ j, Template HasSnaky 6 (childrenC_709_i2 j) (childrenD_709_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 1 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_56 3 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_392 0 (4, 3)).mono (by decide +kernel) +theorem row_works_709_i2 : Template HasSnaky 7 required_709_i2 envelope_709_i2 := by + refine compose HasSnaky 6 childrenC_709_i2 childrenD_709_i2 children_work_709_i2 (4, 5) + required_709_i2 envelope_709_i2 pivot_mem_709_i2 child_required_sub_709_i2 child_envelope_sub_709_i2 ?_ + intro b hb + exact common_sub_709_i2 (mem_commonEnvelope childrenD_709_i2 b hb) +def required_709_i1 : Finset Cell := ⟨(([(5, 5), (5, 6), (5, 7), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_709_i1 : Finset Cell := ⟨(([(2, 5), (3, 5), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 4), (7, 5), (7, 6), (8, 4), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_709_i1 : Fin 3 → Finset Cell := ![(placed21 4 (5, 8) required_11), (placed21 7 (8, 7) required_253), required_709_i2] +def childrenD_709_i1 : Fin 3 → Finset Cell := ![(placed21 4 (5, 8) envelope_11), (placed21 7 (8, 7) envelope_253), envelope_709_i2] +theorem common_sub_709_i1 : commonEnvelope childrenD_709_i1 ⊆ insert (5, 4) required_709_i1 := by decide +kernel +theorem child_required_sub_709_i1 : ∀ j, childrenC_709_i1 j ⊆ insert (5, 4) required_709_i1 := by decide +kernel +theorem child_envelope_sub_709_i1 : ∀ j, childrenD_709_i1 j ⊆ envelope_709_i1 := by decide +kernel +theorem pivot_mem_709_i1 : (5, 4) ∈ envelope_709_i1 := by decide +kernel +theorem children_work_709_i1 : ∀ j, Template HasSnaky 7 (childrenC_709_i1 j) (childrenD_709_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 4 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_253 7 (8, 7)).mono (by decide +kernel) + · exact row_works_709_i2.mono (by decide +kernel) +theorem row_works_709_i1 : Template HasSnaky 8 required_709_i1 envelope_709_i1 := by + refine compose HasSnaky 7 childrenC_709_i1 childrenD_709_i1 children_work_709_i1 (5, 4) + required_709_i1 envelope_709_i1 pivot_mem_709_i1 child_required_sub_709_i1 child_envelope_sub_709_i1 ?_ + intro b hb + exact common_sub_709_i1 (mem_commonEnvelope childrenD_709_i1 b hb) +def required_709_i4 : Finset Cell := ⟨(([(5, 4), (5, 5), (5, 6), (5, 7), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_709_i4 : Finset Cell := ⟨(([(4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_709_i4 : Fin 2 → Finset Cell := ![(placed21 4 (5, 7) required_6), (placed21 6 (6, 6) required_89)] +def childrenD_709_i4 : Fin 2 → Finset Cell := ![(placed21 4 (5, 7) envelope_6), (placed21 6 (6, 6) envelope_89)] +theorem common_sub_709_i4 : commonEnvelope childrenD_709_i4 ⊆ insert (5, 3) required_709_i4 := by decide +kernel +theorem child_required_sub_709_i4 : ∀ j, childrenC_709_i4 j ⊆ insert (5, 3) required_709_i4 := by decide +kernel +theorem child_envelope_sub_709_i4 : ∀ j, childrenD_709_i4 j ⊆ envelope_709_i4 := by decide +kernel +theorem pivot_mem_709_i4 : (5, 3) ∈ envelope_709_i4 := by decide +kernel +theorem children_work_709_i4 : ∀ j, Template HasSnaky 4 (childrenC_709_i4 j) (childrenD_709_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 4 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_89 6 (6, 6)).mono (by decide +kernel) +theorem row_works_709_i4 : Template HasSnaky 5 required_709_i4 envelope_709_i4 := by + refine compose HasSnaky 4 childrenC_709_i4 childrenD_709_i4 children_work_709_i4 (5, 3) + required_709_i4 envelope_709_i4 pivot_mem_709_i4 child_required_sub_709_i4 child_envelope_sub_709_i4 ?_ + intro b hb + exact common_sub_709_i4 (mem_commonEnvelope childrenD_709_i4 b hb) +def required_709_i3 : Finset Cell := ⟨(([(5, 5), (5, 6), (5, 7), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_709_i3 : Finset Cell := ⟨(([(4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 4), (7, 7), (7, 8), (8, 4), (8, 7), (9, 4), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_709_i3 : Fin 3 → Finset Cell := ![(placed21 4 (5, 8) required_11), (placed21 4 (4, 8) required_521), required_709_i4] +def childrenD_709_i3 : Fin 3 → Finset Cell := ![(placed21 4 (5, 8) envelope_11), (placed21 4 (4, 8) envelope_521), envelope_709_i4] +theorem common_sub_709_i3 : commonEnvelope childrenD_709_i3 ⊆ insert (5, 4) required_709_i3 := by decide +kernel +theorem child_required_sub_709_i3 : ∀ j, childrenC_709_i3 j ⊆ insert (5, 4) required_709_i3 := by decide +kernel +theorem child_envelope_sub_709_i3 : ∀ j, childrenD_709_i3 j ⊆ envelope_709_i3 := by decide +kernel +theorem pivot_mem_709_i3 : (5, 4) ∈ envelope_709_i3 := by decide +kernel +theorem children_work_709_i3 : ∀ j, Template HasSnaky 6 (childrenC_709_i3 j) (childrenD_709_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 4 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_521 4 (4, 8)).mono (by decide +kernel) + · exact row_works_709_i4.mono (by decide +kernel) +theorem row_works_709_i3 : Template HasSnaky 7 required_709_i3 envelope_709_i3 := by + refine compose HasSnaky 6 childrenC_709_i3 childrenD_709_i3 children_work_709_i3 (5, 4) + required_709_i3 envelope_709_i3 pivot_mem_709_i3 child_required_sub_709_i3 child_envelope_sub_709_i3 ?_ + intro b hb + exact common_sub_709_i3 (mem_commonEnvelope childrenD_709_i3 b hb) +def required_709_i0 : Finset Cell := ⟨(([(5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_709_i0 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (11, 7), (11, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_709_i0 : Fin 7 → Finset Cell := ![(placed21 5 (9, 3) required_524), (placed21 7 (9, 9) required_536), (placed21 7 (10, 7) required_545), (placed21 5 (10, 3) required_655), (placed21 4 (1, 11) required_664), required_709_i1, required_709_i3] +def childrenD_709_i0 : Fin 7 → Finset Cell := ![(placed21 5 (9, 3) envelope_524), (placed21 7 (9, 9) envelope_536), (placed21 7 (10, 7) envelope_545), (placed21 5 (10, 3) envelope_655), (placed21 4 (1, 11) envelope_664), envelope_709_i1, envelope_709_i3] +theorem common_sub_709_i0 : commonEnvelope childrenD_709_i0 ⊆ insert (6, 6) required_709_i0 := by decide +kernel +theorem child_required_sub_709_i0 : ∀ j, childrenC_709_i0 j ⊆ insert (6, 6) required_709_i0 := by decide +kernel +theorem child_envelope_sub_709_i0 : ∀ j, childrenD_709_i0 j ⊆ envelope_709_i0 := by decide +kernel +theorem pivot_mem_709_i0 : (6, 6) ∈ envelope_709_i0 := by decide +kernel +theorem children_work_709_i0 : ∀ j, Template HasSnaky 11 (childrenC_709_i0 j) (childrenD_709_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_524 5 (9, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_536 7 (9, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_545 7 (10, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_655 5 (10, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_664 4 (1, 11)).mono (by decide +kernel) + · exact row_works_709_i1.mono (by decide +kernel) + · exact row_works_709_i3.mono (by decide +kernel) +theorem row_works_709_i0 : Template HasSnaky 12 required_709_i0 envelope_709_i0 := by + refine compose HasSnaky 11 childrenC_709_i0 childrenD_709_i0 children_work_709_i0 (6, 6) + required_709_i0 envelope_709_i0 pivot_mem_709_i0 child_required_sub_709_i0 child_envelope_sub_709_i0 ?_ + intro b hb + exact common_sub_709_i0 (mem_commonEnvelope childrenD_709_i0 b hb) +def required_709 : Finset Cell := ⟨(([(5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_709 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (11, 7), (11, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_709 : Fin 4 → Finset Cell := ![(placed21 2 (6, 3) required_14), (placed21 5 (8, 4) required_116), (placed21 5 (7, 4) required_181), required_709_i0] +def childrenD_709 : Fin 4 → Finset Cell := ![(placed21 2 (6, 3) envelope_14), (placed21 5 (8, 4) envelope_116), (placed21 5 (7, 4) envelope_181), envelope_709_i0] +theorem common_sub_709 : commonEnvelope childrenD_709 ⊆ insert (5, 7) required_709 := by decide +kernel +theorem child_required_sub_709 : ∀ j, childrenC_709 j ⊆ insert (5, 7) required_709 := by decide +kernel +theorem child_envelope_sub_709 : ∀ j, childrenD_709 j ⊆ envelope_709 := by decide +kernel +theorem pivot_mem_709 : (5, 7) ∈ envelope_709 := by decide +kernel +theorem children_work_709 : ∀ j, Template HasSnaky 12 (childrenC_709 j) (childrenD_709 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_116 5 (8, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_181 5 (7, 4)).mono (by decide +kernel) + · exact row_works_709_i0.mono (by decide +kernel) +theorem row_works_709 : Template HasSnaky 13 required_709 envelope_709 := by + refine compose HasSnaky 12 childrenC_709 childrenD_709 children_work_709 (5, 7) + required_709 envelope_709 pivot_mem_709 child_required_sub_709 child_envelope_sub_709 ?_ + intro b hb + exact common_sub_709 (mem_commonEnvelope childrenD_709 b hb) +def height_695_i6 : ℕ := 5 +def childrenH_695_i6 : Fin 3 → ℕ := ![height_11, height_75, height_103] +theorem height_exact_695_i6 : height_695_i6 = 1 + Finset.univ.sup childrenH_695_i6 := by decide +kernel +theorem required_origin_695_i6 : ∀ x ∈ required_695_i6, + (∃ j, x ∈ childrenC_695_i6 j) ∨ ∀ j, x ∈ childrenD_695_i6 j := by decide +kernel +theorem required_exact_695_i6 : required_695_i6 = + ((Finset.univ.biUnion childrenC_695_i6) ∪ commonEnvelope childrenD_695_i6).erase (1, 6) := by + exact required_eq_combination childrenC_695_i6 childrenD_695_i6 (1, 6) required_695_i6 + (by decide +kernel) child_required_sub_695_i6 common_sub_695_i6 required_origin_695_i6 +theorem envelope_origin_695_i6 : ∀ x ∈ envelope_695_i6, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_695_i6 j := by decide +kernel +theorem envelope_exact_695_i6 : envelope_695_i6 = + insert (1, 6) (Finset.univ.biUnion childrenD_695_i6) := by + exact envelope_eq_combination childrenD_695_i6 (1, 6) envelope_695_i6 + pivot_mem_695_i6 child_envelope_sub_695_i6 envelope_origin_695_i6 +def checked_695_i6 : CheckedCard where + required := required_695_i6 + envelope := envelope_695_i6 + height := height_695_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_695_i6 +def height_695_i7 : ℕ := 5 +def childrenH_695_i7 : Fin 3 → ℕ := ![height_11, height_17, height_90] +theorem height_exact_695_i7 : height_695_i7 = 1 + Finset.univ.sup childrenH_695_i7 := by decide +kernel +theorem required_origin_695_i7 : ∀ x ∈ required_695_i7, + (∃ j, x ∈ childrenC_695_i7 j) ∨ ∀ j, x ∈ childrenD_695_i7 j := by decide +kernel +theorem required_exact_695_i7 : required_695_i7 = + ((Finset.univ.biUnion childrenC_695_i7) ∪ commonEnvelope childrenD_695_i7).erase (1, 6) := by + exact required_eq_combination childrenC_695_i7 childrenD_695_i7 (1, 6) required_695_i7 + (by decide +kernel) child_required_sub_695_i7 common_sub_695_i7 required_origin_695_i7 +theorem envelope_origin_695_i7 : ∀ x ∈ envelope_695_i7, + x = (1, 6) ∨ ∃ j, x ∈ childrenD_695_i7 j := by decide +kernel +theorem envelope_exact_695_i7 : envelope_695_i7 = + insert (1, 6) (Finset.univ.biUnion childrenD_695_i7) := by + exact envelope_eq_combination childrenD_695_i7 (1, 6) envelope_695_i7 + pivot_mem_695_i7 child_envelope_sub_695_i7 envelope_origin_695_i7 +def checked_695_i7 : CheckedCard where + required := required_695_i7 + envelope := envelope_695_i7 + height := height_695_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_695_i7 +def height_695_i5 : ℕ := 7 +def childrenH_695_i5 : Fin 4 → ℕ := ![height_308, height_348, height_695_i6, height_695_i7] +theorem height_exact_695_i5 : height_695_i5 = 1 + Finset.univ.sup childrenH_695_i5 := by decide +kernel +theorem required_origin_695_i5 : ∀ x ∈ required_695_i5, + (∃ j, x ∈ childrenC_695_i5 j) ∨ ∀ j, x ∈ childrenD_695_i5 j := by decide +kernel +theorem required_exact_695_i5 : required_695_i5 = + ((Finset.univ.biUnion childrenC_695_i5) ∪ commonEnvelope childrenD_695_i5).erase (1, 7) := by + exact required_eq_combination childrenC_695_i5 childrenD_695_i5 (1, 7) required_695_i5 + (by decide +kernel) child_required_sub_695_i5 common_sub_695_i5 required_origin_695_i5 +theorem envelope_origin_695_i5 : ∀ x ∈ envelope_695_i5, + x = (1, 7) ∨ ∃ j, x ∈ childrenD_695_i5 j := by decide +kernel +theorem envelope_exact_695_i5 : envelope_695_i5 = + insert (1, 7) (Finset.univ.biUnion childrenD_695_i5) := by + exact envelope_eq_combination childrenD_695_i5 (1, 7) envelope_695_i5 + pivot_mem_695_i5 child_envelope_sub_695_i5 envelope_origin_695_i5 +def checked_695_i5 : CheckedCard where + required := required_695_i5 + envelope := envelope_695_i5 + height := height_695_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_695_i5 +def height_695_i4 : ℕ := 8 +def childrenH_695_i4 : Fin 2 → ℕ := ![height_5, height_695_i5] +theorem height_exact_695_i4 : height_695_i4 = 1 + Finset.univ.sup childrenH_695_i4 := by decide +kernel +theorem required_origin_695_i4 : ∀ x ∈ required_695_i4, + (∃ j, x ∈ childrenC_695_i4 j) ∨ ∀ j, x ∈ childrenD_695_i4 j := by decide +kernel +theorem required_exact_695_i4 : required_695_i4 = + ((Finset.univ.biUnion childrenC_695_i4) ∪ commonEnvelope childrenD_695_i4).erase (1, 4) := by + exact required_eq_combination childrenC_695_i4 childrenD_695_i4 (1, 4) required_695_i4 + (by decide +kernel) child_required_sub_695_i4 common_sub_695_i4 required_origin_695_i4 +theorem envelope_origin_695_i4 : ∀ x ∈ envelope_695_i4, + x = (1, 4) ∨ ∃ j, x ∈ childrenD_695_i4 j := by decide +kernel +theorem envelope_exact_695_i4 : envelope_695_i4 = + insert (1, 4) (Finset.univ.biUnion childrenD_695_i4) := by + exact envelope_eq_combination childrenD_695_i4 (1, 4) envelope_695_i4 + pivot_mem_695_i4 child_envelope_sub_695_i4 envelope_origin_695_i4 +def checked_695_i4 : CheckedCard where + required := required_695_i4 + envelope := envelope_695_i4 + height := height_695_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_695_i4 +def height_695_i3 : ℕ := 9 +def childrenH_695_i3 : Fin 2 → ℕ := ![height_96, height_695_i4] +theorem height_exact_695_i3 : height_695_i3 = 1 + Finset.univ.sup childrenH_695_i3 := by decide +kernel +theorem required_origin_695_i3 : ∀ x ∈ required_695_i3, + (∃ j, x ∈ childrenC_695_i3 j) ∨ ∀ j, x ∈ childrenD_695_i3 j := by decide +kernel +theorem required_exact_695_i3 : required_695_i3 = + ((Finset.univ.biUnion childrenC_695_i3) ∪ commonEnvelope childrenD_695_i3).erase (3, 8) := by + exact required_eq_combination childrenC_695_i3 childrenD_695_i3 (3, 8) required_695_i3 + (by decide +kernel) child_required_sub_695_i3 common_sub_695_i3 required_origin_695_i3 +theorem envelope_origin_695_i3 : ∀ x ∈ envelope_695_i3, + x = (3, 8) ∨ ∃ j, x ∈ childrenD_695_i3 j := by decide +kernel +theorem envelope_exact_695_i3 : envelope_695_i3 = + insert (3, 8) (Finset.univ.biUnion childrenD_695_i3) := by + exact envelope_eq_combination childrenD_695_i3 (3, 8) envelope_695_i3 + pivot_mem_695_i3 child_envelope_sub_695_i3 envelope_origin_695_i3 +def checked_695_i3 : CheckedCard where + required := required_695_i3 + envelope := envelope_695_i3 + height := height_695_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_695_i3 +def height_695_i2 : ℕ := 10 +def childrenH_695_i2 : Fin 2 → ℕ := ![height_5, height_695_i3] +theorem height_exact_695_i2 : height_695_i2 = 1 + Finset.univ.sup childrenH_695_i2 := by decide +kernel +theorem required_origin_695_i2 : ∀ x ∈ required_695_i2, + (∃ j, x ∈ childrenC_695_i2 j) ∨ ∀ j, x ∈ childrenD_695_i2 j := by decide +kernel +theorem required_exact_695_i2 : required_695_i2 = + ((Finset.univ.biUnion childrenC_695_i2) ∪ commonEnvelope childrenD_695_i2).erase (1, 5) := by + exact required_eq_combination childrenC_695_i2 childrenD_695_i2 (1, 5) required_695_i2 + (by decide +kernel) child_required_sub_695_i2 common_sub_695_i2 required_origin_695_i2 +theorem envelope_origin_695_i2 : ∀ x ∈ envelope_695_i2, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_695_i2 j := by decide +kernel +theorem envelope_exact_695_i2 : envelope_695_i2 = + insert (1, 5) (Finset.univ.biUnion childrenD_695_i2) := by + exact envelope_eq_combination childrenD_695_i2 (1, 5) envelope_695_i2 + pivot_mem_695_i2 child_envelope_sub_695_i2 envelope_origin_695_i2 +def checked_695_i2 : CheckedCard where + required := required_695_i2 + envelope := envelope_695_i2 + height := height_695_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_695_i2 +def height_695_i1 : ℕ := 11 +def childrenH_695_i1 : Fin 6 → ℕ := ![height_67, height_175, height_228, height_435, height_688, height_695_i2] +theorem height_exact_695_i1 : height_695_i1 = 1 + Finset.univ.sup childrenH_695_i1 := by decide +kernel +theorem required_origin_695_i1 : ∀ x ∈ required_695_i1, + (∃ j, x ∈ childrenC_695_i1 j) ∨ ∀ j, x ∈ childrenD_695_i1 j := by decide +kernel +theorem required_exact_695_i1 : required_695_i1 = + ((Finset.univ.biUnion childrenC_695_i1) ∪ commonEnvelope childrenD_695_i1).erase (4, 7) := by + exact required_eq_combination childrenC_695_i1 childrenD_695_i1 (4, 7) required_695_i1 + (by decide +kernel) child_required_sub_695_i1 common_sub_695_i1 required_origin_695_i1 +theorem envelope_origin_695_i1 : ∀ x ∈ envelope_695_i1, + x = (4, 7) ∨ ∃ j, x ∈ childrenD_695_i1 j := by decide +kernel +theorem envelope_exact_695_i1 : envelope_695_i1 = + insert (4, 7) (Finset.univ.biUnion childrenD_695_i1) := by + exact envelope_eq_combination childrenD_695_i1 (4, 7) envelope_695_i1 + pivot_mem_695_i1 child_envelope_sub_695_i1 envelope_origin_695_i1 +def checked_695_i1 : CheckedCard where + required := required_695_i1 + envelope := envelope_695_i1 + height := height_695_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_695_i1 +def height_695_i0 : ℕ := 12 +def childrenH_695_i0 : Fin 4 → ℕ := ![height_44, height_324, height_686, height_695_i1] +theorem height_exact_695_i0 : height_695_i0 = 1 + Finset.univ.sup childrenH_695_i0 := by decide +kernel +theorem required_origin_695_i0 : ∀ x ∈ required_695_i0, + (∃ j, x ∈ childrenC_695_i0 j) ∨ ∀ j, x ∈ childrenD_695_i0 j := by decide +kernel +theorem required_exact_695_i0 : required_695_i0 = + ((Finset.univ.biUnion childrenC_695_i0) ∪ commonEnvelope childrenD_695_i0).erase (4, 6) := by + exact required_eq_combination childrenC_695_i0 childrenD_695_i0 (4, 6) required_695_i0 + (by decide +kernel) child_required_sub_695_i0 common_sub_695_i0 required_origin_695_i0 +theorem envelope_origin_695_i0 : ∀ x ∈ envelope_695_i0, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_695_i0 j := by decide +kernel +theorem envelope_exact_695_i0 : envelope_695_i0 = + insert (4, 6) (Finset.univ.biUnion childrenD_695_i0) := by + exact envelope_eq_combination childrenD_695_i0 (4, 6) envelope_695_i0 + pivot_mem_695_i0 child_envelope_sub_695_i0 envelope_origin_695_i0 +def checked_695_i0 : CheckedCard where + required := required_695_i0 + envelope := envelope_695_i0 + height := height_695_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_695_i0 +def height_695 : ℕ := 13 +def childrenH_695 : Fin 5 → ℕ := ![height_12, height_118, height_135, height_182, height_695_i0] +theorem height_exact_695 : height_695 = 1 + Finset.univ.sup childrenH_695 := by decide +kernel +theorem required_origin_695 : ∀ x ∈ required_695, + (∃ j, x ∈ childrenC_695 j) ∨ ∀ j, x ∈ childrenD_695 j := by decide +kernel +theorem required_exact_695 : required_695 = + ((Finset.univ.biUnion childrenC_695) ∪ commonEnvelope childrenD_695).erase (4, 5) := by + exact required_eq_combination childrenC_695 childrenD_695 (4, 5) required_695 + (by decide +kernel) child_required_sub_695 common_sub_695 required_origin_695 +theorem envelope_origin_695 : ∀ x ∈ envelope_695, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_695 j := by decide +kernel +theorem envelope_exact_695 : envelope_695 = + insert (4, 5) (Finset.univ.biUnion childrenD_695) := by + exact envelope_eq_combination childrenD_695 (4, 5) envelope_695 + pivot_mem_695 child_envelope_sub_695 envelope_origin_695 +def checked_695 : CheckedCard where + required := required_695 + envelope := envelope_695 + height := height_695 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_695 +def height_696_i1 : ℕ := 6 +def childrenH_696_i1 : Fin 2 → ℕ := ![height_5, height_197] +theorem height_exact_696_i1 : height_696_i1 = 1 + Finset.univ.sup childrenH_696_i1 := by decide +kernel +theorem required_origin_696_i1 : ∀ x ∈ required_696_i1, + (∃ j, x ∈ childrenC_696_i1 j) ∨ ∀ j, x ∈ childrenD_696_i1 j := by decide +kernel +theorem required_exact_696_i1 : required_696_i1 = + ((Finset.univ.biUnion childrenC_696_i1) ∪ commonEnvelope childrenD_696_i1).erase (5, 7) := by + exact required_eq_combination childrenC_696_i1 childrenD_696_i1 (5, 7) required_696_i1 + (by decide +kernel) child_required_sub_696_i1 common_sub_696_i1 required_origin_696_i1 +theorem envelope_origin_696_i1 : ∀ x ∈ envelope_696_i1, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_696_i1 j := by decide +kernel +theorem envelope_exact_696_i1 : envelope_696_i1 = + insert (5, 7) (Finset.univ.biUnion childrenD_696_i1) := by + exact envelope_eq_combination childrenD_696_i1 (5, 7) envelope_696_i1 + pivot_mem_696_i1 child_envelope_sub_696_i1 envelope_origin_696_i1 +def checked_696_i1 : CheckedCard where + required := required_696_i1 + envelope := envelope_696_i1 + height := height_696_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_696_i1 +def height_696_i0 : ℕ := 12 +def childrenH_696_i0 : Fin 4 → ℕ := ![height_317, height_696_i1, height_436, height_685] +theorem height_exact_696_i0 : height_696_i0 = 1 + Finset.univ.sup childrenH_696_i0 := by decide +kernel +theorem required_origin_696_i0 : ∀ x ∈ required_696_i0, + (∃ j, x ∈ childrenC_696_i0 j) ∨ ∀ j, x ∈ childrenD_696_i0 j := by decide +kernel +theorem required_exact_696_i0 : required_696_i0 = + ((Finset.univ.biUnion childrenC_696_i0) ∪ commonEnvelope childrenD_696_i0).erase (4, 4) := by + exact required_eq_combination childrenC_696_i0 childrenD_696_i0 (4, 4) required_696_i0 + (by decide +kernel) child_required_sub_696_i0 common_sub_696_i0 required_origin_696_i0 +theorem envelope_origin_696_i0 : ∀ x ∈ envelope_696_i0, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_696_i0 j := by decide +kernel +theorem envelope_exact_696_i0 : envelope_696_i0 = + insert (4, 4) (Finset.univ.biUnion childrenD_696_i0) := by + exact envelope_eq_combination childrenD_696_i0 (4, 4) envelope_696_i0 + pivot_mem_696_i0 child_envelope_sub_696_i0 envelope_origin_696_i0 +def checked_696_i0 : CheckedCard where + required := required_696_i0 + envelope := envelope_696_i0 + height := height_696_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_696_i0 +def height_696 : ℕ := 13 +def childrenH_696 : Fin 6 → ℕ := ![height_12, height_322, height_369, height_435, height_622, height_696_i0] +theorem height_exact_696 : height_696 = 1 + Finset.univ.sup childrenH_696 := by decide +kernel +theorem required_origin_696 : ∀ x ∈ required_696, + (∃ j, x ∈ childrenC_696 j) ∨ ∀ j, x ∈ childrenD_696 j := by decide +kernel +theorem required_exact_696 : required_696 = + ((Finset.univ.biUnion childrenC_696) ∪ commonEnvelope childrenD_696).erase (5, 4) := by + exact required_eq_combination childrenC_696 childrenD_696 (5, 4) required_696 + (by decide +kernel) child_required_sub_696 common_sub_696 required_origin_696 +theorem envelope_origin_696 : ∀ x ∈ envelope_696, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_696 j := by decide +kernel +theorem envelope_exact_696 : envelope_696 = + insert (5, 4) (Finset.univ.biUnion childrenD_696) := by + exact envelope_eq_combination childrenD_696 (5, 4) envelope_696 + pivot_mem_696 child_envelope_sub_696 envelope_origin_696 +def checked_696 : CheckedCard where + required := required_696 + envelope := envelope_696 + height := height_696 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_696 +def height_709_i2 : ℕ := 7 +def childrenH_709_i2 : Fin 3 → ℕ := ![height_53, height_56, height_392] +theorem height_exact_709_i2 : height_709_i2 = 1 + Finset.univ.sup childrenH_709_i2 := by decide +kernel +theorem required_origin_709_i2 : ∀ x ∈ required_709_i2, + (∃ j, x ∈ childrenC_709_i2 j) ∨ ∀ j, x ∈ childrenD_709_i2 j := by decide +kernel +theorem required_exact_709_i2 : required_709_i2 = + ((Finset.univ.biUnion childrenC_709_i2) ∪ commonEnvelope childrenD_709_i2).erase (4, 5) := by + exact required_eq_combination childrenC_709_i2 childrenD_709_i2 (4, 5) required_709_i2 + (by decide +kernel) child_required_sub_709_i2 common_sub_709_i2 required_origin_709_i2 +theorem envelope_origin_709_i2 : ∀ x ∈ envelope_709_i2, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_709_i2 j := by decide +kernel +theorem envelope_exact_709_i2 : envelope_709_i2 = + insert (4, 5) (Finset.univ.biUnion childrenD_709_i2) := by + exact envelope_eq_combination childrenD_709_i2 (4, 5) envelope_709_i2 + pivot_mem_709_i2 child_envelope_sub_709_i2 envelope_origin_709_i2 +def checked_709_i2 : CheckedCard where + required := required_709_i2 + envelope := envelope_709_i2 + height := height_709_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_709_i2 +def height_709_i1 : ℕ := 8 +def childrenH_709_i1 : Fin 3 → ℕ := ![height_11, height_253, height_709_i2] +theorem height_exact_709_i1 : height_709_i1 = 1 + Finset.univ.sup childrenH_709_i1 := by decide +kernel +theorem required_origin_709_i1 : ∀ x ∈ required_709_i1, + (∃ j, x ∈ childrenC_709_i1 j) ∨ ∀ j, x ∈ childrenD_709_i1 j := by decide +kernel +theorem required_exact_709_i1 : required_709_i1 = + ((Finset.univ.biUnion childrenC_709_i1) ∪ commonEnvelope childrenD_709_i1).erase (5, 4) := by + exact required_eq_combination childrenC_709_i1 childrenD_709_i1 (5, 4) required_709_i1 + (by decide +kernel) child_required_sub_709_i1 common_sub_709_i1 required_origin_709_i1 +theorem envelope_origin_709_i1 : ∀ x ∈ envelope_709_i1, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_709_i1 j := by decide +kernel +theorem envelope_exact_709_i1 : envelope_709_i1 = + insert (5, 4) (Finset.univ.biUnion childrenD_709_i1) := by + exact envelope_eq_combination childrenD_709_i1 (5, 4) envelope_709_i1 + pivot_mem_709_i1 child_envelope_sub_709_i1 envelope_origin_709_i1 +def checked_709_i1 : CheckedCard where + required := required_709_i1 + envelope := envelope_709_i1 + height := height_709_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_709_i1 +def height_709_i4 : ℕ := 5 +def childrenH_709_i4 : Fin 2 → ℕ := ![height_6, height_89] +theorem height_exact_709_i4 : height_709_i4 = 1 + Finset.univ.sup childrenH_709_i4 := by decide +kernel +theorem required_origin_709_i4 : ∀ x ∈ required_709_i4, + (∃ j, x ∈ childrenC_709_i4 j) ∨ ∀ j, x ∈ childrenD_709_i4 j := by decide +kernel +theorem required_exact_709_i4 : required_709_i4 = + ((Finset.univ.biUnion childrenC_709_i4) ∪ commonEnvelope childrenD_709_i4).erase (5, 3) := by + exact required_eq_combination childrenC_709_i4 childrenD_709_i4 (5, 3) required_709_i4 + (by decide +kernel) child_required_sub_709_i4 common_sub_709_i4 required_origin_709_i4 +theorem envelope_origin_709_i4 : ∀ x ∈ envelope_709_i4, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_709_i4 j := by decide +kernel +theorem envelope_exact_709_i4 : envelope_709_i4 = + insert (5, 3) (Finset.univ.biUnion childrenD_709_i4) := by + exact envelope_eq_combination childrenD_709_i4 (5, 3) envelope_709_i4 + pivot_mem_709_i4 child_envelope_sub_709_i4 envelope_origin_709_i4 +def checked_709_i4 : CheckedCard where + required := required_709_i4 + envelope := envelope_709_i4 + height := height_709_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_709_i4 +def height_709_i3 : ℕ := 7 +def childrenH_709_i3 : Fin 3 → ℕ := ![height_11, height_521, height_709_i4] +theorem height_exact_709_i3 : height_709_i3 = 1 + Finset.univ.sup childrenH_709_i3 := by decide +kernel +theorem required_origin_709_i3 : ∀ x ∈ required_709_i3, + (∃ j, x ∈ childrenC_709_i3 j) ∨ ∀ j, x ∈ childrenD_709_i3 j := by decide +kernel +theorem required_exact_709_i3 : required_709_i3 = + ((Finset.univ.biUnion childrenC_709_i3) ∪ commonEnvelope childrenD_709_i3).erase (5, 4) := by + exact required_eq_combination childrenC_709_i3 childrenD_709_i3 (5, 4) required_709_i3 + (by decide +kernel) child_required_sub_709_i3 common_sub_709_i3 required_origin_709_i3 +theorem envelope_origin_709_i3 : ∀ x ∈ envelope_709_i3, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_709_i3 j := by decide +kernel +theorem envelope_exact_709_i3 : envelope_709_i3 = + insert (5, 4) (Finset.univ.biUnion childrenD_709_i3) := by + exact envelope_eq_combination childrenD_709_i3 (5, 4) envelope_709_i3 + pivot_mem_709_i3 child_envelope_sub_709_i3 envelope_origin_709_i3 +def checked_709_i3 : CheckedCard where + required := required_709_i3 + envelope := envelope_709_i3 + height := height_709_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_709_i3 +def height_709_i0 : ℕ := 12 +def childrenH_709_i0 : Fin 7 → ℕ := ![height_524, height_536, height_545, height_655, height_664, height_709_i1, height_709_i3] +theorem height_exact_709_i0 : height_709_i0 = 1 + Finset.univ.sup childrenH_709_i0 := by decide +kernel +theorem required_origin_709_i0 : ∀ x ∈ required_709_i0, + (∃ j, x ∈ childrenC_709_i0 j) ∨ ∀ j, x ∈ childrenD_709_i0 j := by decide +kernel +theorem required_exact_709_i0 : required_709_i0 = + ((Finset.univ.biUnion childrenC_709_i0) ∪ commonEnvelope childrenD_709_i0).erase (6, 6) := by + exact required_eq_combination childrenC_709_i0 childrenD_709_i0 (6, 6) required_709_i0 + (by decide +kernel) child_required_sub_709_i0 common_sub_709_i0 required_origin_709_i0 +theorem envelope_origin_709_i0 : ∀ x ∈ envelope_709_i0, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_709_i0 j := by decide +kernel +theorem envelope_exact_709_i0 : envelope_709_i0 = + insert (6, 6) (Finset.univ.biUnion childrenD_709_i0) := by + exact envelope_eq_combination childrenD_709_i0 (6, 6) envelope_709_i0 + pivot_mem_709_i0 child_envelope_sub_709_i0 envelope_origin_709_i0 +def checked_709_i0 : CheckedCard where + required := required_709_i0 + envelope := envelope_709_i0 + height := height_709_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_709_i0 +def height_709 : ℕ := 13 +def childrenH_709 : Fin 4 → ℕ := ![height_14, height_116, height_181, height_709_i0] +theorem height_exact_709 : height_709 = 1 + Finset.univ.sup childrenH_709 := by decide +kernel +theorem required_origin_709 : ∀ x ∈ required_709, + (∃ j, x ∈ childrenC_709 j) ∨ ∀ j, x ∈ childrenD_709 j := by decide +kernel +theorem required_exact_709 : required_709 = + ((Finset.univ.biUnion childrenC_709) ∪ commonEnvelope childrenD_709).erase (5, 7) := by + exact required_eq_combination childrenC_709 childrenD_709 (5, 7) required_709 + (by decide +kernel) child_required_sub_709 common_sub_709 required_origin_709 +theorem envelope_origin_709 : ∀ x ∈ envelope_709, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_709 j := by decide +kernel +theorem envelope_exact_709 : envelope_709 = + insert (5, 7) (Finset.univ.biUnion childrenD_709) := by + exact envelope_eq_combination childrenD_709 (5, 7) envelope_709 + pivot_mem_709 child_envelope_sub_709 envelope_origin_709 +def checked_709 : CheckedCard where + required := required_709 + envelope := envelope_709 + height := height_709 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_709 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part07.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part07.lean new file mode 100644 index 0000000..79c1f42 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part07.lean @@ -0,0 +1,317 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_720_i0 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_720_i0 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (4, 5), (4, 6), (5, 5), (5, 6), (6, 5), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_720_i0 : Fin 3 → Finset Cell := ![(placed21 7 (6, 6) required_10), (placed21 2 (6, 3) required_180), (placed21 1 (3, 5) required_200)] +def childrenD_720_i0 : Fin 3 → Finset Cell := ![(placed21 7 (6, 6) envelope_10), (placed21 2 (6, 3) envelope_180), (placed21 1 (3, 5) envelope_200)] +theorem common_sub_720_i0 : commonEnvelope childrenD_720_i0 ⊆ insert (3, 5) required_720_i0 := by decide +kernel +theorem child_required_sub_720_i0 : ∀ j, childrenC_720_i0 j ⊆ insert (3, 5) required_720_i0 := by decide +kernel +theorem child_envelope_sub_720_i0 : ∀ j, childrenD_720_i0 j ⊆ envelope_720_i0 := by decide +kernel +theorem pivot_mem_720_i0 : (3, 5) ∈ envelope_720_i0 := by decide +kernel +theorem children_work_720_i0 : ∀ j, Template HasSnaky 6 (childrenC_720_i0 j) (childrenD_720_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 7 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_180 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_200 1 (3, 5)).mono (by decide +kernel) +theorem row_works_720_i0 : Template HasSnaky 7 required_720_i0 envelope_720_i0 := by + refine compose HasSnaky 6 childrenC_720_i0 childrenD_720_i0 children_work_720_i0 (3, 5) + required_720_i0 envelope_720_i0 pivot_mem_720_i0 child_required_sub_720_i0 child_envelope_sub_720_i0 ?_ + intro b hb + exact common_sub_720_i0 (mem_commonEnvelope childrenD_720_i0 b hb) +def required_720_i4 : Finset Cell := ⟨(([(5, 6), (5, 7), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_720_i4 : Finset Cell := ⟨(([(4, 6), (5, 6), (5, 7), (6, 7), (6, 8), (6, 9), (6, 10), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 6), (8, 7), (9, 6), (9, 7), (9, 8), (10, 6), (10, 7), (10, 8), (11, 6), (11, 7), (11, 8), (12, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_720_i4 : Fin 2 → Finset Cell := ![(placed21 2 (7, 4) required_52), (placed21 1 (4, 6) required_315)] +def childrenD_720_i4 : Fin 2 → Finset Cell := ![(placed21 2 (7, 4) envelope_52), (placed21 1 (4, 6) envelope_315)] +theorem common_sub_720_i4 : commonEnvelope childrenD_720_i4 ⊆ insert (6, 7) required_720_i4 := by decide +kernel +theorem child_required_sub_720_i4 : ∀ j, childrenC_720_i4 j ⊆ insert (6, 7) required_720_i4 := by decide +kernel +theorem child_envelope_sub_720_i4 : ∀ j, childrenD_720_i4 j ⊆ envelope_720_i4 := by decide +kernel +theorem pivot_mem_720_i4 : (6, 7) ∈ envelope_720_i4 := by decide +kernel +theorem children_work_720_i4 : ∀ j, Template HasSnaky 6 (childrenC_720_i4 j) (childrenD_720_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 2 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_315 1 (4, 6)).mono (by decide +kernel) +theorem row_works_720_i4 : Template HasSnaky 7 required_720_i4 envelope_720_i4 := by + refine compose HasSnaky 6 childrenC_720_i4 childrenD_720_i4 children_work_720_i4 (6, 7) + required_720_i4 envelope_720_i4 pivot_mem_720_i4 child_required_sub_720_i4 child_envelope_sub_720_i4 ?_ + intro b hb + exact common_sub_720_i4 (mem_commonEnvelope childrenD_720_i4 b hb) +def required_720_i5 : Finset Cell := ⟨(([(5, 6), (5, 7), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_720_i5 : Finset Cell := ⟨(([(4, 6), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_720_i5 : Fin 2 → Finset Cell := ![(placed21 7 (8, 7) required_197), (placed21 5 (8, 4) required_201)] +def childrenD_720_i5 : Fin 2 → Finset Cell := ![(placed21 7 (8, 7) envelope_197), (placed21 5 (8, 4) envelope_201)] +theorem common_sub_720_i5 : commonEnvelope childrenD_720_i5 ⊆ insert (7, 4) required_720_i5 := by decide +kernel +theorem child_required_sub_720_i5 : ∀ j, childrenC_720_i5 j ⊆ insert (7, 4) required_720_i5 := by decide +kernel +theorem child_envelope_sub_720_i5 : ∀ j, childrenD_720_i5 j ⊆ envelope_720_i5 := by decide +kernel +theorem pivot_mem_720_i5 : (7, 4) ∈ envelope_720_i5 := by decide +kernel +theorem children_work_720_i5 : ∀ j, Template HasSnaky 5 (childrenC_720_i5 j) (childrenD_720_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_197 7 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_201 5 (8, 4)).mono (by decide +kernel) +theorem row_works_720_i5 : Template HasSnaky 6 required_720_i5 envelope_720_i5 := by + refine compose HasSnaky 5 childrenC_720_i5 childrenD_720_i5 children_work_720_i5 (7, 4) + required_720_i5 envelope_720_i5 pivot_mem_720_i5 child_required_sub_720_i5 child_envelope_sub_720_i5 ?_ + intro b hb + exact common_sub_720_i5 (mem_commonEnvelope childrenD_720_i5 b hb) +def required_720_i3 : Finset Cell := ⟨(([(5, 6), (5, 7), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_720_i3 : Finset Cell := ⟨(([(4, 6), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 6), (9, 7), (9, 8), (9, 9), (10, 6), (10, 7), (10, 8), (10, 9), (11, 6), (11, 7), (11, 8), (12, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_720_i3 : Fin 6 → Finset Cell := ![(placed21 2 (8, 3) required_12), (placed21 2 (8, 3) required_13), (placed21 6 (8, 10) required_369), (placed21 1 (5, 4) required_474), required_720_i4, required_720_i5] +def childrenD_720_i3 : Fin 6 → Finset Cell := ![(placed21 2 (8, 3) envelope_12), (placed21 2 (8, 3) envelope_13), (placed21 6 (8, 10) envelope_369), (placed21 1 (5, 4) envelope_474), envelope_720_i4, envelope_720_i5] +theorem common_sub_720_i3 : commonEnvelope childrenD_720_i3 ⊆ insert (7, 7) required_720_i3 := by decide +kernel +theorem child_required_sub_720_i3 : ∀ j, childrenC_720_i3 j ⊆ insert (7, 7) required_720_i3 := by decide +kernel +theorem child_envelope_sub_720_i3 : ∀ j, childrenD_720_i3 j ⊆ envelope_720_i3 := by decide +kernel +theorem pivot_mem_720_i3 : (7, 7) ∈ envelope_720_i3 := by decide +kernel +theorem children_work_720_i3 : ∀ j, Template HasSnaky 9 (childrenC_720_i3 j) (childrenD_720_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 2 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_13 2 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_369 6 (8, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_474 1 (5, 4)).mono (by decide +kernel) + · exact row_works_720_i4.mono (by decide +kernel) + · exact row_works_720_i5.mono (by decide +kernel) +theorem row_works_720_i3 : Template HasSnaky 10 required_720_i3 envelope_720_i3 := by + refine compose HasSnaky 9 childrenC_720_i3 childrenD_720_i3 children_work_720_i3 (7, 7) + required_720_i3 envelope_720_i3 pivot_mem_720_i3 child_required_sub_720_i3 child_envelope_sub_720_i3 ?_ + intro b hb + exact common_sub_720_i3 (mem_commonEnvelope childrenD_720_i3 b hb) +def required_720_i2 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 5), (5, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_720_i2 : Finset Cell := ⟨(([(4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 6), (9, 7), (9, 8), (9, 9), (10, 6), (10, 7), (10, 8), (10, 9), (11, 6), (11, 7), (11, 8), (12, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_720_i2 : Fin 2 → Finset Cell := ![(placed21 7 (5, 8) required_0), required_720_i3] +def childrenD_720_i2 : Fin 2 → Finset Cell := ![(placed21 7 (5, 8) envelope_0), envelope_720_i3] +theorem common_sub_720_i2 : commonEnvelope childrenD_720_i2 ⊆ insert (5, 7) required_720_i2 := by decide +kernel +theorem child_required_sub_720_i2 : ∀ j, childrenC_720_i2 j ⊆ insert (5, 7) required_720_i2 := by decide +kernel +theorem child_envelope_sub_720_i2 : ∀ j, childrenD_720_i2 j ⊆ envelope_720_i2 := by decide +kernel +theorem pivot_mem_720_i2 : (5, 7) ∈ envelope_720_i2 := by decide +kernel +theorem children_work_720_i2 : ∀ j, Template HasSnaky 10 (childrenC_720_i2 j) (childrenD_720_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (5, 8)).mono (by decide +kernel) + · exact row_works_720_i3.mono (by decide +kernel) +theorem row_works_720_i2 : Template HasSnaky 11 required_720_i2 envelope_720_i2 := by + refine compose HasSnaky 10 childrenC_720_i2 childrenD_720_i2 children_work_720_i2 (5, 7) + required_720_i2 envelope_720_i2 pivot_mem_720_i2 child_required_sub_720_i2 child_envelope_sub_720_i2 ?_ + intro b hb + exact common_sub_720_i2 (mem_commonEnvelope childrenD_720_i2 b hb) +def required_720_i1 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 5), (5, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_720_i1 : Finset Cell := ⟨(([(3, 4), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 5), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 6), (9, 7), (9, 8), (9, 9), (10, 6), (10, 7), (10, 8), (10, 9), (11, 6), (11, 7), (11, 8), (12, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_720_i1 : Fin 3 → Finset Cell := ![(placed21 1 (3, 4) required_40), (placed21 1 (3, 4) required_310), required_720_i2] +def childrenD_720_i1 : Fin 3 → Finset Cell := ![(placed21 1 (3, 4) envelope_40), (placed21 1 (3, 4) envelope_310), envelope_720_i2] +theorem common_sub_720_i1 : commonEnvelope childrenD_720_i1 ⊆ insert (7, 5) required_720_i1 := by decide +kernel +theorem child_required_sub_720_i1 : ∀ j, childrenC_720_i1 j ⊆ insert (7, 5) required_720_i1 := by decide +kernel +theorem child_envelope_sub_720_i1 : ∀ j, childrenD_720_i1 j ⊆ envelope_720_i1 := by decide +kernel +theorem pivot_mem_720_i1 : (7, 5) ∈ envelope_720_i1 := by decide +kernel +theorem children_work_720_i1 : ∀ j, Template HasSnaky 11 (childrenC_720_i1 j) (childrenD_720_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_40 1 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_310 1 (3, 4)).mono (by decide +kernel) + · exact row_works_720_i2.mono (by decide +kernel) +theorem row_works_720_i1 : Template HasSnaky 12 required_720_i1 envelope_720_i1 := by + refine compose HasSnaky 11 childrenC_720_i1 childrenD_720_i1 children_work_720_i1 (7, 5) + required_720_i1 envelope_720_i1 pivot_mem_720_i1 child_required_sub_720_i1 child_envelope_sub_720_i1 ?_ + intro b hb + exact common_sub_720_i1 (mem_commonEnvelope childrenD_720_i1 b hb) +def required_720 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_720 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5), (4, 6), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 6), (9, 7), (9, 8), (9, 9), (10, 6), (10, 7), (10, 8), (10, 9), (11, 6), (11, 7), (11, 8), (12, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_720 : Fin 4 → Finset Cell := ![(placed21 7 (8, 6) required_54), (placed21 7 (8, 6) required_64), required_720_i0, required_720_i1] +def childrenD_720 : Fin 4 → Finset Cell := ![(placed21 7 (8, 6) envelope_54), (placed21 7 (8, 6) envelope_64), envelope_720_i0, envelope_720_i1] +theorem common_sub_720 : commonEnvelope childrenD_720 ⊆ insert (7, 6) required_720 := by decide +kernel +theorem child_required_sub_720 : ∀ j, childrenC_720 j ⊆ insert (7, 6) required_720 := by decide +kernel +theorem child_envelope_sub_720 : ∀ j, childrenD_720 j ⊆ envelope_720 := by decide +kernel +theorem pivot_mem_720 : (7, 6) ∈ envelope_720 := by decide +kernel +theorem children_work_720 : ∀ j, Template HasSnaky 12 (childrenC_720 j) (childrenD_720 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 7 (8, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_64 7 (8, 6)).mono (by decide +kernel) + · exact row_works_720_i0.mono (by decide +kernel) + · exact row_works_720_i1.mono (by decide +kernel) +theorem row_works_720 : Template HasSnaky 13 required_720 envelope_720 := by + refine compose HasSnaky 12 childrenC_720 childrenD_720 children_work_720 (7, 6) + required_720 envelope_720 pivot_mem_720 child_required_sub_720 child_envelope_sub_720 ?_ + intro b hb + exact common_sub_720 (mem_commonEnvelope childrenD_720 b hb) +def height_720_i0 : ℕ := 7 +def childrenH_720_i0 : Fin 3 → ℕ := ![height_10, height_180, height_200] +theorem height_exact_720_i0 : height_720_i0 = 1 + Finset.univ.sup childrenH_720_i0 := by decide +kernel +theorem required_origin_720_i0 : ∀ x ∈ required_720_i0, + (∃ j, x ∈ childrenC_720_i0 j) ∨ ∀ j, x ∈ childrenD_720_i0 j := by decide +kernel +theorem required_exact_720_i0 : required_720_i0 = + ((Finset.univ.biUnion childrenC_720_i0) ∪ commonEnvelope childrenD_720_i0).erase (3, 5) := by + exact required_eq_combination childrenC_720_i0 childrenD_720_i0 (3, 5) required_720_i0 + (by decide +kernel) child_required_sub_720_i0 common_sub_720_i0 required_origin_720_i0 +theorem envelope_origin_720_i0 : ∀ x ∈ envelope_720_i0, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_720_i0 j := by decide +kernel +theorem envelope_exact_720_i0 : envelope_720_i0 = + insert (3, 5) (Finset.univ.biUnion childrenD_720_i0) := by + exact envelope_eq_combination childrenD_720_i0 (3, 5) envelope_720_i0 + pivot_mem_720_i0 child_envelope_sub_720_i0 envelope_origin_720_i0 +def checked_720_i0 : CheckedCard where + required := required_720_i0 + envelope := envelope_720_i0 + height := height_720_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_720_i0 +def height_720_i4 : ℕ := 7 +def childrenH_720_i4 : Fin 2 → ℕ := ![height_52, height_315] +theorem height_exact_720_i4 : height_720_i4 = 1 + Finset.univ.sup childrenH_720_i4 := by decide +kernel +theorem required_origin_720_i4 : ∀ x ∈ required_720_i4, + (∃ j, x ∈ childrenC_720_i4 j) ∨ ∀ j, x ∈ childrenD_720_i4 j := by decide +kernel +theorem required_exact_720_i4 : required_720_i4 = + ((Finset.univ.biUnion childrenC_720_i4) ∪ commonEnvelope childrenD_720_i4).erase (6, 7) := by + exact required_eq_combination childrenC_720_i4 childrenD_720_i4 (6, 7) required_720_i4 + (by decide +kernel) child_required_sub_720_i4 common_sub_720_i4 required_origin_720_i4 +theorem envelope_origin_720_i4 : ∀ x ∈ envelope_720_i4, + x = (6, 7) ∨ ∃ j, x ∈ childrenD_720_i4 j := by decide +kernel +theorem envelope_exact_720_i4 : envelope_720_i4 = + insert (6, 7) (Finset.univ.biUnion childrenD_720_i4) := by + exact envelope_eq_combination childrenD_720_i4 (6, 7) envelope_720_i4 + pivot_mem_720_i4 child_envelope_sub_720_i4 envelope_origin_720_i4 +def checked_720_i4 : CheckedCard where + required := required_720_i4 + envelope := envelope_720_i4 + height := height_720_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_720_i4 +def height_720_i5 : ℕ := 6 +def childrenH_720_i5 : Fin 2 → ℕ := ![height_197, height_201] +theorem height_exact_720_i5 : height_720_i5 = 1 + Finset.univ.sup childrenH_720_i5 := by decide +kernel +theorem required_origin_720_i5 : ∀ x ∈ required_720_i5, + (∃ j, x ∈ childrenC_720_i5 j) ∨ ∀ j, x ∈ childrenD_720_i5 j := by decide +kernel +theorem required_exact_720_i5 : required_720_i5 = + ((Finset.univ.biUnion childrenC_720_i5) ∪ commonEnvelope childrenD_720_i5).erase (7, 4) := by + exact required_eq_combination childrenC_720_i5 childrenD_720_i5 (7, 4) required_720_i5 + (by decide +kernel) child_required_sub_720_i5 common_sub_720_i5 required_origin_720_i5 +theorem envelope_origin_720_i5 : ∀ x ∈ envelope_720_i5, + x = (7, 4) ∨ ∃ j, x ∈ childrenD_720_i5 j := by decide +kernel +theorem envelope_exact_720_i5 : envelope_720_i5 = + insert (7, 4) (Finset.univ.biUnion childrenD_720_i5) := by + exact envelope_eq_combination childrenD_720_i5 (7, 4) envelope_720_i5 + pivot_mem_720_i5 child_envelope_sub_720_i5 envelope_origin_720_i5 +def checked_720_i5 : CheckedCard where + required := required_720_i5 + envelope := envelope_720_i5 + height := height_720_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_720_i5 +def height_720_i3 : ℕ := 10 +def childrenH_720_i3 : Fin 6 → ℕ := ![height_12, height_13, height_369, height_474, height_720_i4, height_720_i5] +theorem height_exact_720_i3 : height_720_i3 = 1 + Finset.univ.sup childrenH_720_i3 := by decide +kernel +theorem required_origin_720_i3 : ∀ x ∈ required_720_i3, + (∃ j, x ∈ childrenC_720_i3 j) ∨ ∀ j, x ∈ childrenD_720_i3 j := by decide +kernel +theorem required_exact_720_i3 : required_720_i3 = + ((Finset.univ.biUnion childrenC_720_i3) ∪ commonEnvelope childrenD_720_i3).erase (7, 7) := by + exact required_eq_combination childrenC_720_i3 childrenD_720_i3 (7, 7) required_720_i3 + (by decide +kernel) child_required_sub_720_i3 common_sub_720_i3 required_origin_720_i3 +theorem envelope_origin_720_i3 : ∀ x ∈ envelope_720_i3, + x = (7, 7) ∨ ∃ j, x ∈ childrenD_720_i3 j := by decide +kernel +theorem envelope_exact_720_i3 : envelope_720_i3 = + insert (7, 7) (Finset.univ.biUnion childrenD_720_i3) := by + exact envelope_eq_combination childrenD_720_i3 (7, 7) envelope_720_i3 + pivot_mem_720_i3 child_envelope_sub_720_i3 envelope_origin_720_i3 +def checked_720_i3 : CheckedCard where + required := required_720_i3 + envelope := envelope_720_i3 + height := height_720_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_720_i3 +def height_720_i2 : ℕ := 11 +def childrenH_720_i2 : Fin 2 → ℕ := ![height_0, height_720_i3] +theorem height_exact_720_i2 : height_720_i2 = 1 + Finset.univ.sup childrenH_720_i2 := by decide +kernel +theorem required_origin_720_i2 : ∀ x ∈ required_720_i2, + (∃ j, x ∈ childrenC_720_i2 j) ∨ ∀ j, x ∈ childrenD_720_i2 j := by decide +kernel +theorem required_exact_720_i2 : required_720_i2 = + ((Finset.univ.biUnion childrenC_720_i2) ∪ commonEnvelope childrenD_720_i2).erase (5, 7) := by + exact required_eq_combination childrenC_720_i2 childrenD_720_i2 (5, 7) required_720_i2 + (by decide +kernel) child_required_sub_720_i2 common_sub_720_i2 required_origin_720_i2 +theorem envelope_origin_720_i2 : ∀ x ∈ envelope_720_i2, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_720_i2 j := by decide +kernel +theorem envelope_exact_720_i2 : envelope_720_i2 = + insert (5, 7) (Finset.univ.biUnion childrenD_720_i2) := by + exact envelope_eq_combination childrenD_720_i2 (5, 7) envelope_720_i2 + pivot_mem_720_i2 child_envelope_sub_720_i2 envelope_origin_720_i2 +def checked_720_i2 : CheckedCard where + required := required_720_i2 + envelope := envelope_720_i2 + height := height_720_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_720_i2 +def height_720_i1 : ℕ := 12 +def childrenH_720_i1 : Fin 3 → ℕ := ![height_40, height_310, height_720_i2] +theorem height_exact_720_i1 : height_720_i1 = 1 + Finset.univ.sup childrenH_720_i1 := by decide +kernel +theorem required_origin_720_i1 : ∀ x ∈ required_720_i1, + (∃ j, x ∈ childrenC_720_i1 j) ∨ ∀ j, x ∈ childrenD_720_i1 j := by decide +kernel +theorem required_exact_720_i1 : required_720_i1 = + ((Finset.univ.biUnion childrenC_720_i1) ∪ commonEnvelope childrenD_720_i1).erase (7, 5) := by + exact required_eq_combination childrenC_720_i1 childrenD_720_i1 (7, 5) required_720_i1 + (by decide +kernel) child_required_sub_720_i1 common_sub_720_i1 required_origin_720_i1 +theorem envelope_origin_720_i1 : ∀ x ∈ envelope_720_i1, + x = (7, 5) ∨ ∃ j, x ∈ childrenD_720_i1 j := by decide +kernel +theorem envelope_exact_720_i1 : envelope_720_i1 = + insert (7, 5) (Finset.univ.biUnion childrenD_720_i1) := by + exact envelope_eq_combination childrenD_720_i1 (7, 5) envelope_720_i1 + pivot_mem_720_i1 child_envelope_sub_720_i1 envelope_origin_720_i1 +def checked_720_i1 : CheckedCard where + required := required_720_i1 + envelope := envelope_720_i1 + height := height_720_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_720_i1 +def height_720 : ℕ := 13 +def childrenH_720 : Fin 4 → ℕ := ![height_54, height_64, height_720_i0, height_720_i1] +theorem height_exact_720 : height_720 = 1 + Finset.univ.sup childrenH_720 := by decide +kernel +theorem required_origin_720 : ∀ x ∈ required_720, + (∃ j, x ∈ childrenC_720 j) ∨ ∀ j, x ∈ childrenD_720 j := by decide +kernel +theorem required_exact_720 : required_720 = + ((Finset.univ.biUnion childrenC_720) ∪ commonEnvelope childrenD_720).erase (7, 6) := by + exact required_eq_combination childrenC_720 childrenD_720 (7, 6) required_720 + (by decide +kernel) child_required_sub_720 common_sub_720 required_origin_720 +theorem envelope_origin_720 : ∀ x ∈ envelope_720, + x = (7, 6) ∨ ∃ j, x ∈ childrenD_720 j := by decide +kernel +theorem envelope_exact_720 : envelope_720 = + insert (7, 6) (Finset.univ.biUnion childrenD_720) := by + exact envelope_eq_combination childrenD_720 (7, 6) envelope_720 + pivot_mem_720 child_envelope_sub_720 envelope_origin_720 +def checked_720 : CheckedCard where + required := required_720 + envelope := envelope_720 + height := height_720 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_720 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part01.lean new file mode 100644 index 0000000..282a9f7 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part01.lean @@ -0,0 +1,992 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_553_i3 : Finset Cell := ⟨(([(3, 7), (4, 4), (4, 7), (5, 4), (5, 5), (5, 6), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_553_i3 : Finset Cell := ⟨(([(3, 7), (4, 3), (4, 4), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (6, 6), (6, 7), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_553_i3 : Fin 2 → Finset Cell := ![(placed21 4 (3, 7) required_3), (placed21 7 (5, 7) required_5)] +def childrenD_553_i3 : Fin 2 → Finset Cell := ![(placed21 4 (3, 7) envelope_3), (placed21 7 (5, 7) envelope_5)] +theorem common_sub_553_i3 : commonEnvelope childrenD_553_i3 ⊆ insert (5, 7) required_553_i3 := by decide +kernel +theorem child_required_sub_553_i3 : ∀ j, childrenC_553_i3 j ⊆ insert (5, 7) required_553_i3 := by decide +kernel +theorem child_envelope_sub_553_i3 : ∀ j, childrenD_553_i3 j ⊆ envelope_553_i3 := by decide +kernel +theorem pivot_mem_553_i3 : (5, 7) ∈ envelope_553_i3 := by decide +kernel +theorem children_work_553_i3 : ∀ j, Template HasSnaky 1 (childrenC_553_i3 j) (childrenD_553_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_5 7 (5, 7)).mono (by decide +kernel) +theorem row_works_553_i3 : Template HasSnaky 2 required_553_i3 envelope_553_i3 := by + refine compose HasSnaky 1 childrenC_553_i3 childrenD_553_i3 children_work_553_i3 (5, 7) + required_553_i3 envelope_553_i3 pivot_mem_553_i3 child_required_sub_553_i3 child_envelope_sub_553_i3 ?_ + intro b hb + exact common_sub_553_i3 (mem_commonEnvelope childrenD_553_i3 b hb) +def required_553_i2 : Finset Cell := ⟨(([(3, 7), (4, 4), (4, 7), (5, 4), (5, 6), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_553_i2 : Finset Cell := ⟨(([(3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 6), (6, 7), (6, 8), (6, 9), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_553_i2 : Fin 4 → Finset Cell := ![(placed21 6 (6, 7) required_10), (placed21 6 (5, 7) required_52), (placed21 0 (5, 3) required_52), required_553_i3] +def childrenD_553_i2 : Fin 4 → Finset Cell := ![(placed21 6 (6, 7) envelope_10), (placed21 6 (5, 7) envelope_52), (placed21 0 (5, 3) envelope_52), envelope_553_i3] +theorem common_sub_553_i2 : commonEnvelope childrenD_553_i2 ⊆ insert (5, 5) required_553_i2 := by decide +kernel +theorem child_required_sub_553_i2 : ∀ j, childrenC_553_i2 j ⊆ insert (5, 5) required_553_i2 := by decide +kernel +theorem child_envelope_sub_553_i2 : ∀ j, childrenD_553_i2 j ⊆ envelope_553_i2 := by decide +kernel +theorem pivot_mem_553_i2 : (5, 5) ∈ envelope_553_i2 := by decide +kernel +theorem children_work_553_i2 : ∀ j, Template HasSnaky 4 (childrenC_553_i2 j) (childrenD_553_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 6 (6, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_52 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (5, 3)).mono (by decide +kernel) + · exact row_works_553_i3.mono (by decide +kernel) +theorem row_works_553_i2 : Template HasSnaky 5 required_553_i2 envelope_553_i2 := by + refine compose HasSnaky 4 childrenC_553_i2 childrenD_553_i2 children_work_553_i2 (5, 5) + required_553_i2 envelope_553_i2 pivot_mem_553_i2 child_required_sub_553_i2 child_envelope_sub_553_i2 ?_ + intro b hb + exact common_sub_553_i2 (mem_commonEnvelope childrenD_553_i2 b hb) +def required_553_i1 : Finset Cell := ⟨(([(3, 7), (4, 4), (4, 7), (5, 4), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_553_i1 : Finset Cell := ⟨(([(3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 6), (6, 7), (6, 8), (6, 9), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_553_i1 : Fin 2 → Finset Cell := ![(placed21 2 (7, 6) required_3), required_553_i2] +def childrenD_553_i1 : Fin 2 → Finset Cell := ![(placed21 2 (7, 6) envelope_3), envelope_553_i2] +theorem common_sub_553_i1 : commonEnvelope childrenD_553_i1 ⊆ insert (5, 6) required_553_i1 := by decide +kernel +theorem child_required_sub_553_i1 : ∀ j, childrenC_553_i1 j ⊆ insert (5, 6) required_553_i1 := by decide +kernel +theorem child_envelope_sub_553_i1 : ∀ j, childrenD_553_i1 j ⊆ envelope_553_i1 := by decide +kernel +theorem pivot_mem_553_i1 : (5, 6) ∈ envelope_553_i1 := by decide +kernel +theorem children_work_553_i1 : ∀ j, Template HasSnaky 5 (childrenC_553_i1 j) (childrenD_553_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 2 (7, 6)).mono (by decide +kernel) + · exact row_works_553_i2.mono (by decide +kernel) +theorem row_works_553_i1 : Template HasSnaky 6 required_553_i1 envelope_553_i1 := by + refine compose HasSnaky 5 childrenC_553_i1 childrenD_553_i1 children_work_553_i1 (5, 6) + required_553_i1 envelope_553_i1 pivot_mem_553_i1 child_required_sub_553_i1 child_envelope_sub_553_i1 ?_ + intro b hb + exact common_sub_553_i1 (mem_commonEnvelope childrenD_553_i1 b hb) +def required_553_i6 : Finset Cell := ⟨(([(3, 4), (4, 4), (5, 4), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_553_i6 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 3), (4, 4), (5, 4), (6, 3), (6, 4), (6, 7), (6, 8), (6, 9), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 5), (8, 7), (8, 8), (8, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_553_i6 : Fin 2 → Finset Cell := ![(placed21 7 (7, 4) required_6), (placed21 0 (4, 3) required_145)] +def childrenD_553_i6 : Fin 2 → Finset Cell := ![(placed21 7 (7, 4) envelope_6), (placed21 0 (4, 3) envelope_145)] +theorem common_sub_553_i6 : commonEnvelope childrenD_553_i6 ⊆ insert (6, 4) required_553_i6 := by decide +kernel +theorem child_required_sub_553_i6 : ∀ j, childrenC_553_i6 j ⊆ insert (6, 4) required_553_i6 := by decide +kernel +theorem child_envelope_sub_553_i6 : ∀ j, childrenD_553_i6 j ⊆ envelope_553_i6 := by decide +kernel +theorem pivot_mem_553_i6 : (6, 4) ∈ envelope_553_i6 := by decide +kernel +theorem children_work_553_i6 : ∀ j, Template HasSnaky 5 (childrenC_553_i6 j) (childrenD_553_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 7 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_145 0 (4, 3)).mono (by decide +kernel) +theorem row_works_553_i6 : Template HasSnaky 6 required_553_i6 envelope_553_i6 := by + refine compose HasSnaky 5 childrenC_553_i6 childrenD_553_i6 children_work_553_i6 (6, 4) + required_553_i6 envelope_553_i6 pivot_mem_553_i6 child_required_sub_553_i6 child_envelope_sub_553_i6 ?_ + intro b hb + exact common_sub_553_i6 (mem_commonEnvelope childrenD_553_i6 b hb) +def required_553_i5 : Finset Cell := ⟨(([(3, 4), (4, 4), (5, 4), (6, 6), (6, 7), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_553_i5 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 3), (4, 4), (5, 4), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 3), (8, 5), (8, 7), (8, 8), (8, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_553_i5 : Fin 3 → Finset Cell := ![(placed21 2 (7, 3) required_54), (placed21 3 (2, 4) required_158), required_553_i6] +def childrenD_553_i5 : Fin 3 → Finset Cell := ![(placed21 2 (7, 3) envelope_54), (placed21 3 (2, 4) envelope_158), envelope_553_i6] +theorem common_sub_553_i5 : commonEnvelope childrenD_553_i5 ⊆ insert (7, 4) required_553_i5 := by decide +kernel +theorem child_required_sub_553_i5 : ∀ j, childrenC_553_i5 j ⊆ insert (7, 4) required_553_i5 := by decide +kernel +theorem child_envelope_sub_553_i5 : ∀ j, childrenD_553_i5 j ⊆ envelope_553_i5 := by decide +kernel +theorem pivot_mem_553_i5 : (7, 4) ∈ envelope_553_i5 := by decide +kernel +theorem children_work_553_i5 : ∀ j, Template HasSnaky 6 (childrenC_553_i5 j) (childrenD_553_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_158 3 (2, 4)).mono (by decide +kernel) + · exact row_works_553_i6.mono (by decide +kernel) +theorem row_works_553_i5 : Template HasSnaky 7 required_553_i5 envelope_553_i5 := by + refine compose HasSnaky 6 childrenC_553_i5 childrenD_553_i5 children_work_553_i5 (7, 4) + required_553_i5 envelope_553_i5 pivot_mem_553_i5 child_required_sub_553_i5 child_envelope_sub_553_i5 ?_ + intro b hb + exact common_sub_553_i5 (mem_commonEnvelope childrenD_553_i5 b hb) +def required_553_i4 : Finset Cell := ⟨(([(3, 4), (3, 7), (4, 4), (4, 7), (5, 4), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_553_i4 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (3, 7), (4, 3), (4, 4), (4, 7), (5, 4), (5, 7), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 3), (8, 5), (8, 7), (8, 8), (8, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_553_i4 : Fin 2 → Finset Cell := ![(placed21 4 (3, 7) required_2), required_553_i5] +def childrenD_553_i4 : Fin 2 → Finset Cell := ![(placed21 4 (3, 7) envelope_2), envelope_553_i5] +theorem common_sub_553_i4 : commonEnvelope childrenD_553_i4 ⊆ insert (6, 7) required_553_i4 := by decide +kernel +theorem child_required_sub_553_i4 : ∀ j, childrenC_553_i4 j ⊆ insert (6, 7) required_553_i4 := by decide +kernel +theorem child_envelope_sub_553_i4 : ∀ j, childrenD_553_i4 j ⊆ envelope_553_i4 := by decide +kernel +theorem pivot_mem_553_i4 : (6, 7) ∈ envelope_553_i4 := by decide +kernel +theorem children_work_553_i4 : ∀ j, Template HasSnaky 7 (childrenC_553_i4 j) (childrenD_553_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (3, 7)).mono (by decide +kernel) + · exact row_works_553_i5.mono (by decide +kernel) +theorem row_works_553_i4 : Template HasSnaky 8 required_553_i4 envelope_553_i4 := by + refine compose HasSnaky 7 childrenC_553_i4 childrenD_553_i4 children_work_553_i4 (6, 7) + required_553_i4 envelope_553_i4 pivot_mem_553_i4 child_required_sub_553_i4 child_envelope_sub_553_i4 ?_ + intro b hb + exact common_sub_553_i4 (mem_commonEnvelope childrenD_553_i4 b hb) +def required_553_i8 : Finset Cell := ⟨(([(3, 4), (3, 7), (4, 4), (5, 4), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_553_i8 : Finset Cell := ⟨(([(2, 3), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_553_i8 : Fin 2 → Finset Cell := ![(placed21 6 (5, 7) required_54), (placed21 3 (2, 7) required_247)] +def childrenD_553_i8 : Fin 2 → Finset Cell := ![(placed21 6 (5, 7) envelope_54), (placed21 3 (2, 7) envelope_247)] +theorem common_sub_553_i8 : commonEnvelope childrenD_553_i8 ⊆ insert (4, 3) required_553_i8 := by decide +kernel +theorem child_required_sub_553_i8 : ∀ j, childrenC_553_i8 j ⊆ insert (4, 3) required_553_i8 := by decide +kernel +theorem child_envelope_sub_553_i8 : ∀ j, childrenD_553_i8 j ⊆ envelope_553_i8 := by decide +kernel +theorem pivot_mem_553_i8 : (4, 3) ∈ envelope_553_i8 := by decide +kernel +theorem children_work_553_i8 : ∀ j, Template HasSnaky 3 (childrenC_553_i8 j) (childrenD_553_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_54 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_247 3 (2, 7)).mono (by decide +kernel) +theorem row_works_553_i8 : Template HasSnaky 4 required_553_i8 envelope_553_i8 := by + refine compose HasSnaky 3 childrenC_553_i8 childrenD_553_i8 children_work_553_i8 (4, 3) + required_553_i8 envelope_553_i8 pivot_mem_553_i8 child_required_sub_553_i8 child_envelope_sub_553_i8 ?_ + intro b hb + exact common_sub_553_i8 (mem_commonEnvelope childrenD_553_i8 b hb) +def required_553_i7 : Finset Cell := ⟨(([(3, 4), (3, 7), (4, 4), (4, 7), (5, 4), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_553_i7 : Finset Cell := ⟨(([(2, 3), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (6, 6), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_553_i7 : Fin 2 → Finset Cell := ![(placed21 2 (7, 6) required_3), required_553_i8] +def childrenD_553_i7 : Fin 2 → Finset Cell := ![(placed21 2 (7, 6) envelope_3), envelope_553_i8] +theorem common_sub_553_i7 : commonEnvelope childrenD_553_i7 ⊆ insert (5, 6) required_553_i7 := by decide +kernel +theorem child_required_sub_553_i7 : ∀ j, childrenC_553_i7 j ⊆ insert (5, 6) required_553_i7 := by decide +kernel +theorem child_envelope_sub_553_i7 : ∀ j, childrenD_553_i7 j ⊆ envelope_553_i7 := by decide +kernel +theorem pivot_mem_553_i7 : (5, 6) ∈ envelope_553_i7 := by decide +kernel +theorem children_work_553_i7 : ∀ j, Template HasSnaky 4 (childrenC_553_i7 j) (childrenD_553_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 2 (7, 6)).mono (by decide +kernel) + · exact row_works_553_i8.mono (by decide +kernel) +theorem row_works_553_i7 : Template HasSnaky 5 required_553_i7 envelope_553_i7 := by + refine compose HasSnaky 4 childrenC_553_i7 childrenD_553_i7 children_work_553_i7 (5, 6) + required_553_i7 envelope_553_i7 pivot_mem_553_i7 child_required_sub_553_i7 child_envelope_sub_553_i7 ?_ + intro b hb + exact common_sub_553_i7 (mem_commonEnvelope childrenD_553_i7 b hb) +def required_553_i0 : Finset Cell := ⟨(([(3, 4), (3, 7), (4, 4), (4, 7), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_553_i0 : Finset Cell := ⟨(([(2, 3), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 3), (8, 5), (8, 7), (8, 8), (8, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_553_i0 : Fin 4 → Finset Cell := ![(placed21 3 (2, 7) required_433), required_553_i1, required_553_i4, required_553_i7] +def childrenD_553_i0 : Fin 4 → Finset Cell := ![(placed21 3 (2, 7) envelope_433), envelope_553_i1, envelope_553_i4, envelope_553_i7] +theorem common_sub_553_i0 : commonEnvelope childrenD_553_i0 ⊆ insert (5, 4) required_553_i0 := by decide +kernel +theorem child_required_sub_553_i0 : ∀ j, childrenC_553_i0 j ⊆ insert (5, 4) required_553_i0 := by decide +kernel +theorem child_envelope_sub_553_i0 : ∀ j, childrenD_553_i0 j ⊆ envelope_553_i0 := by decide +kernel +theorem pivot_mem_553_i0 : (5, 4) ∈ envelope_553_i0 := by decide +kernel +theorem children_work_553_i0 : ∀ j, Template HasSnaky 8 (childrenC_553_i0 j) (childrenD_553_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_433 3 (2, 7)).mono (by decide +kernel) + · exact row_works_553_i1.mono (by decide +kernel) + · exact row_works_553_i4.mono (by decide +kernel) + · exact row_works_553_i7.mono (by decide +kernel) +theorem row_works_553_i0 : Template HasSnaky 9 required_553_i0 envelope_553_i0 := by + refine compose HasSnaky 8 childrenC_553_i0 childrenD_553_i0 children_work_553_i0 (5, 4) + required_553_i0 envelope_553_i0 pivot_mem_553_i0 child_required_sub_553_i0 child_envelope_sub_553_i0 ?_ + intro b hb + exact common_sub_553_i0 (mem_commonEnvelope childrenD_553_i0 b hb) +def required_553 : Finset Cell := ⟨(([(3, 4), (3, 7), (4, 4), (4, 7), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_553 : Finset Cell := ⟨(([(0, 3), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 9), (3, 10), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (4, 9), (4, 10), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (12, 5), (12, 7), (12, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_553 : Fin 5 → Finset Cell := ![(placed21 3 (3, 7) required_107), (placed21 3 (3, 7) required_163), (placed21 0 (2, 1) required_538), required_552, required_553_i0] +def childrenD_553 : Fin 5 → Finset Cell := ![(placed21 3 (3, 7) envelope_107), (placed21 3 (3, 7) envelope_163), (placed21 0 (2, 1) envelope_538), envelope_552, envelope_553_i0] +theorem common_sub_553 : commonEnvelope childrenD_553 ⊆ insert (7, 6) required_553 := by decide +kernel +theorem child_required_sub_553 : ∀ j, childrenC_553 j ⊆ insert (7, 6) required_553 := by decide +kernel +theorem child_envelope_sub_553 : ∀ j, childrenD_553 j ⊆ envelope_553 := by decide +kernel +theorem pivot_mem_553 : (7, 6) ∈ envelope_553 := by decide +kernel +theorem children_work_553 : ∀ j, Template HasSnaky 13 (childrenC_553 j) (childrenD_553 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_107 3 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_163 3 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_538 0 (2, 1)).mono (by decide +kernel) + · exact row_works_552.mono (by decide +kernel) + · exact row_works_553_i0.mono (by decide +kernel) +theorem row_works_553 : Template HasSnaky 14 required_553 envelope_553 := by + refine compose HasSnaky 13 childrenC_553 childrenD_553 children_work_553 (7, 6) + required_553 envelope_553 pivot_mem_553 child_required_sub_553 child_envelope_sub_553 ?_ + intro b hb + exact common_sub_553 (mem_commonEnvelope childrenD_553 b hb) +def required_557_i0 : Finset Cell := ⟨(([(1, 6), (2, 6), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_557_i0 : Finset Cell := ⟨(([(1, 6), (2, 6), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_557_i0 : Fin 3 → Finset Cell := ![(placed21 6 (5, 9) required_13), (placed21 7 (5, 7) required_28), (placed21 4 (1, 8) required_58)] +def childrenD_557_i0 : Fin 3 → Finset Cell := ![(placed21 6 (5, 9) envelope_13), (placed21 7 (5, 7) envelope_28), (placed21 4 (1, 8) envelope_58)] +theorem common_sub_557_i0 : commonEnvelope childrenD_557_i0 ⊆ insert (4, 7) required_557_i0 := by decide +kernel +theorem child_required_sub_557_i0 : ∀ j, childrenC_557_i0 j ⊆ insert (4, 7) required_557_i0 := by decide +kernel +theorem child_envelope_sub_557_i0 : ∀ j, childrenD_557_i0 j ⊆ envelope_557_i0 := by decide +kernel +theorem pivot_mem_557_i0 : (4, 7) ∈ envelope_557_i0 := by decide +kernel +theorem children_work_557_i0 : ∀ j, Template HasSnaky 4 (childrenC_557_i0 j) (childrenD_557_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 6 (5, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_28 7 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_58 4 (1, 8)).mono (by decide +kernel) +theorem row_works_557_i0 : Template HasSnaky 5 required_557_i0 envelope_557_i0 := by + refine compose HasSnaky 4 childrenC_557_i0 childrenD_557_i0 children_work_557_i0 (4, 7) + required_557_i0 envelope_557_i0 pivot_mem_557_i0 child_required_sub_557_i0 child_envelope_sub_557_i0 ?_ + intro b hb + exact common_sub_557_i0 (mem_commonEnvelope childrenD_557_i0 b hb) +def required_557_i4 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 2), (2, 3), (2, 6), (3, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_557_i4 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (2, 2), (2, 3), (2, 6), (3, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_557_i4 : Fin 2 → Finset Cell := ![(placed21 3 (1, 6) required_2), (placed21 6 (4, 6) required_5)] +def childrenD_557_i4 : Fin 2 → Finset Cell := ![(placed21 3 (1, 6) envelope_2), (placed21 6 (4, 6) envelope_5)] +theorem common_sub_557_i4 : commonEnvelope childrenD_557_i4 ⊆ insert (1, 5) required_557_i4 := by decide +kernel +theorem child_required_sub_557_i4 : ∀ j, childrenC_557_i4 j ⊆ insert (1, 5) required_557_i4 := by decide +kernel +theorem child_envelope_sub_557_i4 : ∀ j, childrenD_557_i4 j ⊆ envelope_557_i4 := by decide +kernel +theorem pivot_mem_557_i4 : (1, 5) ∈ envelope_557_i4 := by decide +kernel +theorem children_work_557_i4 : ∀ j, Template HasSnaky 1 (childrenC_557_i4 j) (childrenD_557_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_5 6 (4, 6)).mono (by decide +kernel) +theorem row_works_557_i4 : Template HasSnaky 2 required_557_i4 envelope_557_i4 := by + refine compose HasSnaky 1 childrenC_557_i4 childrenD_557_i4 children_work_557_i4 (1, 5) + required_557_i4 envelope_557_i4 pivot_mem_557_i4 child_required_sub_557_i4 child_envelope_sub_557_i4 ?_ + intro b hb + exact common_sub_557_i4 (mem_commonEnvelope childrenD_557_i4 b hb) +def required_557_i6 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 3), (3, 6), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_557_i6 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_557_i6 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) required_1), (placed21 7 (5, 4) required_392)] +def childrenD_557_i6 : Fin 2 → Finset Cell := ![(placed21 7 (3, 6) envelope_1), (placed21 7 (5, 4) envelope_392)] +theorem common_sub_557_i6 : commonEnvelope childrenD_557_i6 ⊆ insert (3, 4) required_557_i6 := by decide +kernel +theorem child_required_sub_557_i6 : ∀ j, childrenC_557_i6 j ⊆ insert (3, 4) required_557_i6 := by decide +kernel +theorem child_envelope_sub_557_i6 : ∀ j, childrenD_557_i6 j ⊆ envelope_557_i6 := by decide +kernel +theorem pivot_mem_557_i6 : (3, 4) ∈ envelope_557_i6 := by decide +kernel +theorem children_work_557_i6 : ∀ j, Template HasSnaky 6 (childrenC_557_i6 j) (childrenD_557_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 7 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_392 7 (5, 4)).mono (by decide +kernel) +theorem row_works_557_i6 : Template HasSnaky 7 required_557_i6 envelope_557_i6 := by + refine compose HasSnaky 6 childrenC_557_i6 childrenD_557_i6 children_work_557_i6 (3, 4) + required_557_i6 envelope_557_i6 pivot_mem_557_i6 child_required_sub_557_i6 child_envelope_sub_557_i6 ?_ + intro b hb + exact common_sub_557_i6 (mem_commonEnvelope childrenD_557_i6 b hb) +def required_557_i5 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (3, 6), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_557_i5 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_557_i5 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) required_11), (placed21 1 (1, 2) required_41), required_557_i6] +def childrenD_557_i5 : Fin 3 → Finset Cell := ![(placed21 3 (0, 3) envelope_11), (placed21 1 (1, 2) envelope_41), envelope_557_i6] +theorem common_sub_557_i5 : commonEnvelope childrenD_557_i5 ⊆ insert (3, 3) required_557_i5 := by decide +kernel +theorem child_required_sub_557_i5 : ∀ j, childrenC_557_i5 j ⊆ insert (3, 3) required_557_i5 := by decide +kernel +theorem child_envelope_sub_557_i5 : ∀ j, childrenD_557_i5 j ⊆ envelope_557_i5 := by decide +kernel +theorem pivot_mem_557_i5 : (3, 3) ∈ envelope_557_i5 := by decide +kernel +theorem children_work_557_i5 : ∀ j, Template HasSnaky 7 (childrenC_557_i5 j) (childrenD_557_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_11 3 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_41 1 (1, 2)).mono (by decide +kernel) + · exact row_works_557_i6.mono (by decide +kernel) +theorem row_works_557_i5 : Template HasSnaky 8 required_557_i5 envelope_557_i5 := by + refine compose HasSnaky 7 childrenC_557_i5 childrenD_557_i5 children_work_557_i5 (3, 3) + required_557_i5 envelope_557_i5 pivot_mem_557_i5 child_required_sub_557_i5 child_envelope_sub_557_i5 ?_ + intro b hb + exact common_sub_557_i5 (mem_commonEnvelope childrenD_557_i5 b hb) +def required_557_i3 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 6), (3, 6), (4, 3), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_557_i3 : Finset Cell := ⟨(([(0, 2), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_557_i3 : Fin 2 → Finset Cell := ![required_557_i4, required_557_i5] +def childrenD_557_i3 : Fin 2 → Finset Cell := ![envelope_557_i4, envelope_557_i5] +theorem common_sub_557_i3 : commonEnvelope childrenD_557_i3 ⊆ insert (2, 2) required_557_i3 := by decide +kernel +theorem child_required_sub_557_i3 : ∀ j, childrenC_557_i3 j ⊆ insert (2, 2) required_557_i3 := by decide +kernel +theorem child_envelope_sub_557_i3 : ∀ j, childrenD_557_i3 j ⊆ envelope_557_i3 := by decide +kernel +theorem pivot_mem_557_i3 : (2, 2) ∈ envelope_557_i3 := by decide +kernel +theorem children_work_557_i3 : ∀ j, Template HasSnaky 8 (childrenC_557_i3 j) (childrenD_557_i3 j) := by + intro j + fin_cases j + · exact row_works_557_i4.mono (by decide +kernel) + · exact row_works_557_i5.mono (by decide +kernel) +theorem row_works_557_i3 : Template HasSnaky 9 required_557_i3 envelope_557_i3 := by + refine compose HasSnaky 8 childrenC_557_i3 childrenD_557_i3 children_work_557_i3 (2, 2) + required_557_i3 envelope_557_i3 pivot_mem_557_i3 child_required_sub_557_i3 child_envelope_sub_557_i3 ?_ + intro b hb + exact common_sub_557_i3 (mem_commonEnvelope childrenD_557_i3 b hb) +def required_557_i2 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 6), (3, 6), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_557_i2 : Finset Cell := ⟨(([(0, 2), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (6, 2), (6, 3), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_557_i2 : Fin 3 → Finset Cell := ![(placed21 4 (3, 7) required_42), (placed21 1 (1, 2) required_152), required_557_i3] +def childrenD_557_i2 : Fin 3 → Finset Cell := ![(placed21 4 (3, 7) envelope_42), (placed21 1 (1, 2) envelope_152), envelope_557_i3] +theorem common_sub_557_i2 : commonEnvelope childrenD_557_i2 ⊆ insert (4, 3) required_557_i2 := by decide +kernel +theorem child_required_sub_557_i2 : ∀ j, childrenC_557_i2 j ⊆ insert (4, 3) required_557_i2 := by decide +kernel +theorem child_envelope_sub_557_i2 : ∀ j, childrenD_557_i2 j ⊆ envelope_557_i2 := by decide +kernel +theorem pivot_mem_557_i2 : (4, 3) ∈ envelope_557_i2 := by decide +kernel +theorem children_work_557_i2 : ∀ j, Template HasSnaky 9 (childrenC_557_i2 j) (childrenD_557_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_42 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_152 1 (1, 2)).mono (by decide +kernel) + · exact row_works_557_i3.mono (by decide +kernel) +theorem row_works_557_i2 : Template HasSnaky 10 required_557_i2 envelope_557_i2 := by + refine compose HasSnaky 9 childrenC_557_i2 childrenD_557_i2 children_work_557_i2 (4, 3) + required_557_i2 envelope_557_i2 pivot_mem_557_i2 child_required_sub_557_i2 child_envelope_sub_557_i2 ?_ + intro b hb + exact common_sub_557_i2 (mem_commonEnvelope childrenD_557_i2 b hb) +def required_557_i1 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 6), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_557_i1 : Finset Cell := ⟨(([(0, 2), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 2), (6, 3), (6, 4), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_557_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) required_5), required_557_i2] +def childrenD_557_i1 : Fin 2 → Finset Cell := ![(placed21 4 (1, 6) envelope_5), envelope_557_i2] +theorem common_sub_557_i1 : commonEnvelope childrenD_557_i1 ⊆ insert (3, 6) required_557_i1 := by decide +kernel +theorem child_required_sub_557_i1 : ∀ j, childrenC_557_i1 j ⊆ insert (3, 6) required_557_i1 := by decide +kernel +theorem child_envelope_sub_557_i1 : ∀ j, childrenD_557_i1 j ⊆ envelope_557_i1 := by decide +kernel +theorem pivot_mem_557_i1 : (3, 6) ∈ envelope_557_i1 := by decide +kernel +theorem children_work_557_i1 : ∀ j, Template HasSnaky 10 (childrenC_557_i1 j) (childrenD_557_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (1, 6)).mono (by decide +kernel) + · exact row_works_557_i2.mono (by decide +kernel) +theorem row_works_557_i1 : Template HasSnaky 11 required_557_i1 envelope_557_i1 := by + refine compose HasSnaky 10 childrenC_557_i1 childrenD_557_i1 children_work_557_i1 (3, 6) + required_557_i1 envelope_557_i1 pivot_mem_557_i1 child_required_sub_557_i1 child_envelope_sub_557_i1 ?_ + intro b hb + exact common_sub_557_i1 (mem_commonEnvelope childrenD_557_i1 b hb) +def required_557 : Finset Cell := ⟨(([(1, 3), (1, 6), (2, 3), (2, 6), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_557 : Finset Cell := ⟨(([(0, 2), (0, 5), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 8), (2, 0), (2, 1), (2, 2), (2, 3), (2, 6), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6), (8, 7), (8, 8), (8, 9), (9, 6), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_557 : Fin 7 → Finset Cell := ![(placed21 0 (1, 3) required_110), (placed21 0 (1, 3) required_119), (placed21 0 (1, 2) required_430), (placed21 0 (1, 4) required_461), (placed21 0 (1, 1) required_555), required_557_i0, required_557_i1] +def childrenD_557 : Fin 7 → Finset Cell := ![(placed21 0 (1, 3) envelope_110), (placed21 0 (1, 3) envelope_119), (placed21 0 (1, 2) envelope_430), (placed21 0 (1, 4) envelope_461), (placed21 0 (1, 1) envelope_555), envelope_557_i0, envelope_557_i1] +theorem common_sub_557 : commonEnvelope childrenD_557 ⊆ insert (4, 6) required_557 := by decide +kernel +theorem child_required_sub_557 : ∀ j, childrenC_557 j ⊆ insert (4, 6) required_557 := by decide +kernel +theorem child_envelope_sub_557 : ∀ j, childrenD_557 j ⊆ envelope_557 := by decide +kernel +theorem pivot_mem_557 : (4, 6) ∈ envelope_557 := by decide +kernel +theorem children_work_557 : ∀ j, Template HasSnaky 13 (childrenC_557 j) (childrenD_557 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_110 0 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_119 0 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_430 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_461 0 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_555 0 (1, 1)).mono (by decide +kernel) + · exact row_works_557_i0.mono (by decide +kernel) + · exact row_works_557_i1.mono (by decide +kernel) +theorem row_works_557 : Template HasSnaky 14 required_557 envelope_557 := by + refine compose HasSnaky 13 childrenC_557 childrenD_557 children_work_557 (4, 6) + required_557 envelope_557 pivot_mem_557 child_required_sub_557 child_envelope_sub_557 ?_ + intro b hb + exact common_sub_557 (mem_commonEnvelope childrenD_557 b hb) +def required_582_i1 : Finset Cell := ⟨(([(2, 6), (2, 7), (4, 3), (4, 4), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_582_i1 : Finset Cell := ⟨(([(1, 6), (1, 7), (2, 6), (2, 7), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_582_i1 : Fin 2 → Finset Cell := ![(placed21 1 (4, 3) required_5), (placed21 3 (1, 7) required_160)] +def childrenD_582_i1 : Fin 2 → Finset Cell := ![(placed21 1 (4, 3) envelope_5), (placed21 3 (1, 7) envelope_160)] +theorem common_sub_582_i1 : commonEnvelope childrenD_582_i1 ⊆ insert (5, 6) required_582_i1 := by decide +kernel +theorem child_required_sub_582_i1 : ∀ j, childrenC_582_i1 j ⊆ insert (5, 6) required_582_i1 := by decide +kernel +theorem child_envelope_sub_582_i1 : ∀ j, childrenD_582_i1 j ⊆ envelope_582_i1 := by decide +kernel +theorem pivot_mem_582_i1 : (5, 6) ∈ envelope_582_i1 := by decide +kernel +theorem children_work_582_i1 : ∀ j, Template HasSnaky 3 (childrenC_582_i1 j) (childrenD_582_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_160 3 (1, 7)).mono (by decide +kernel) +theorem row_works_582_i1 : Template HasSnaky 4 required_582_i1 envelope_582_i1 := by + refine compose HasSnaky 3 childrenC_582_i1 childrenD_582_i1 children_work_582_i1 (5, 6) + required_582_i1 envelope_582_i1 pivot_mem_582_i1 child_required_sub_582_i1 child_envelope_sub_582_i1 ?_ + intro b hb + exact common_sub_582_i1 (mem_commonEnvelope childrenD_582_i1 b hb) +def required_582_i0 : Finset Cell := ⟨(([(2, 6), (2, 7), (4, 3), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_582_i0 : Finset Cell := ⟨(([(1, 6), (1, 7), (2, 3), (2, 6), (2, 7), (3, 2), (3, 3), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 4), (6, 5), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_582_i0 : Fin 2 → Finset Cell := ![(placed21 1 (2, 2) required_133), required_582_i1] +def childrenD_582_i0 : Fin 2 → Finset Cell := ![(placed21 1 (2, 2) envelope_133), envelope_582_i1] +theorem common_sub_582_i0 : commonEnvelope childrenD_582_i0 ⊆ insert (4, 5) required_582_i0 := by decide +kernel +theorem child_required_sub_582_i0 : ∀ j, childrenC_582_i0 j ⊆ insert (4, 5) required_582_i0 := by decide +kernel +theorem child_envelope_sub_582_i0 : ∀ j, childrenD_582_i0 j ⊆ envelope_582_i0 := by decide +kernel +theorem pivot_mem_582_i0 : (4, 5) ∈ envelope_582_i0 := by decide +kernel +theorem children_work_582_i0 : ∀ j, Template HasSnaky 5 (childrenC_582_i0 j) (childrenD_582_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_133 1 (2, 2)).mono (by decide +kernel) + · exact row_works_582_i1.mono (by decide +kernel) +theorem row_works_582_i0 : Template HasSnaky 6 required_582_i0 envelope_582_i0 := by + refine compose HasSnaky 5 childrenC_582_i0 childrenD_582_i0 children_work_582_i0 (4, 5) + required_582_i0 envelope_582_i0 pivot_mem_582_i0 child_required_sub_582_i0 child_envelope_sub_582_i0 ?_ + intro b hb + exact common_sub_582_i0 (mem_commonEnvelope childrenD_582_i0 b hb) +def required_582_i2 : Finset Cell := ⟨(([(2, 6), (4, 3), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_582_i2 : Finset Cell := ⟨(([(0, 7), (1, 6), (1, 7), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_582_i2 : Fin 4 → Finset Cell := ![(placed21 3 (0, 7) required_12), (placed21 3 (0, 7) required_14), (placed21 1 (1, 3) required_109), (placed21 1 (1, 3) required_424)] +def childrenD_582_i2 : Fin 4 → Finset Cell := ![(placed21 3 (0, 7) envelope_12), (placed21 3 (0, 7) envelope_14), (placed21 1 (1, 3) envelope_109), (placed21 1 (1, 3) envelope_424)] +theorem common_sub_582_i2 : commonEnvelope childrenD_582_i2 ⊆ insert (3, 6) required_582_i2 := by decide +kernel +theorem child_required_sub_582_i2 : ∀ j, childrenC_582_i2 j ⊆ insert (3, 6) required_582_i2 := by decide +kernel +theorem child_envelope_sub_582_i2 : ∀ j, childrenD_582_i2 j ⊆ envelope_582_i2 := by decide +kernel +theorem pivot_mem_582_i2 : (3, 6) ∈ envelope_582_i2 := by decide +kernel +theorem children_work_582_i2 : ∀ j, Template HasSnaky 4 (childrenC_582_i2 j) (childrenD_582_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 3 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_14 3 (0, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_109 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_424 1 (1, 3)).mono (by decide +kernel) +theorem row_works_582_i2 : Template HasSnaky 5 required_582_i2 envelope_582_i2 := by + refine compose HasSnaky 4 childrenC_582_i2 childrenD_582_i2 children_work_582_i2 (3, 6) + required_582_i2 envelope_582_i2 pivot_mem_582_i2 child_required_sub_582_i2 child_envelope_sub_582_i2 ?_ + intro b hb + exact common_sub_582_i2 (mem_commonEnvelope childrenD_582_i2 b hb) +def required_582_i3 : Finset Cell := ⟨(([(1, 4), (2, 6), (2, 7), (4, 3), (4, 4), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_582_i3 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 6), (2, 3), (2, 4), (2, 6), (2, 7), (3, 2), (3, 3), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_582_i3 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) required_383), (placed21 5 (5, 3) required_432)] +def childrenD_582_i3 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) envelope_383), (placed21 5 (5, 3) envelope_432)] +theorem common_sub_582_i3 : commonEnvelope childrenD_582_i3 ⊆ insert (4, 5) required_582_i3 := by decide +kernel +theorem child_required_sub_582_i3 : ∀ j, childrenC_582_i3 j ⊆ insert (4, 5) required_582_i3 := by decide +kernel +theorem child_envelope_sub_582_i3 : ∀ j, childrenD_582_i3 j ⊆ envelope_582_i3 := by decide +kernel +theorem pivot_mem_582_i3 : (4, 5) ∈ envelope_582_i3 := by decide +kernel +theorem children_work_582_i3 : ∀ j, Template HasSnaky 5 (childrenC_582_i3 j) (childrenD_582_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_383 7 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_432 5 (5, 3)).mono (by decide +kernel) +theorem row_works_582_i3 : Template HasSnaky 6 required_582_i3 envelope_582_i3 := by + refine compose HasSnaky 5 childrenC_582_i3 childrenD_582_i3 children_work_582_i3 (4, 5) + required_582_i3 envelope_582_i3 pivot_mem_582_i3 child_required_sub_582_i3 child_envelope_sub_582_i3 ?_ + intro b hb + exact common_sub_582_i3 (mem_commonEnvelope childrenD_582_i3 b hb) +def required_582 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 6), (2, 7), (4, 3), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_582 : Finset Cell := ⟨(([(0, 7), (1, 3), (1, 4), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 5), (9, 6), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_582 : Fin 6 → Finset Cell := ![(placed21 3 (1, 7) required_184), (placed21 3 (1, 7) required_423), (placed21 0 (1, 0) required_572), required_582_i0, required_582_i2, required_582_i3] +def childrenD_582 : Fin 6 → Finset Cell := ![(placed21 3 (1, 7) envelope_184), (placed21 3 (1, 7) envelope_423), (placed21 0 (1, 0) envelope_572), envelope_582_i0, envelope_582_i2, envelope_582_i3] +theorem common_sub_582 : commonEnvelope childrenD_582 ⊆ insert (4, 6) required_582 := by decide +kernel +theorem child_required_sub_582 : ∀ j, childrenC_582 j ⊆ insert (4, 6) required_582 := by decide +kernel +theorem child_envelope_sub_582 : ∀ j, childrenD_582 j ⊆ envelope_582 := by decide +kernel +theorem pivot_mem_582 : (4, 6) ∈ envelope_582 := by decide +kernel +theorem children_work_582 : ∀ j, Template HasSnaky 13 (childrenC_582 j) (childrenD_582 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_184 3 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_423 3 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_572 0 (1, 0)).mono (by decide +kernel) + · exact row_works_582_i0.mono (by decide +kernel) + · exact row_works_582_i2.mono (by decide +kernel) + · exact row_works_582_i3.mono (by decide +kernel) +theorem row_works_582 : Template HasSnaky 14 required_582 envelope_582 := by + refine compose HasSnaky 13 childrenC_582 childrenD_582 children_work_582 (4, 6) + required_582 envelope_582 pivot_mem_582 child_required_sub_582 child_envelope_sub_582 ?_ + intro b hb + exact common_sub_582 (mem_commonEnvelope childrenD_582 b hb) +def height_553_i3 : ℕ := 2 +def childrenH_553_i3 : Fin 2 → ℕ := ![height_3, height_5] +theorem height_exact_553_i3 : height_553_i3 = 1 + Finset.univ.sup childrenH_553_i3 := by decide +kernel +theorem required_origin_553_i3 : ∀ x ∈ required_553_i3, + (∃ j, x ∈ childrenC_553_i3 j) ∨ ∀ j, x ∈ childrenD_553_i3 j := by decide +kernel +theorem required_exact_553_i3 : required_553_i3 = + ((Finset.univ.biUnion childrenC_553_i3) ∪ commonEnvelope childrenD_553_i3).erase (5, 7) := by + exact required_eq_combination childrenC_553_i3 childrenD_553_i3 (5, 7) required_553_i3 + (by decide +kernel) child_required_sub_553_i3 common_sub_553_i3 required_origin_553_i3 +theorem envelope_origin_553_i3 : ∀ x ∈ envelope_553_i3, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_553_i3 j := by decide +kernel +theorem envelope_exact_553_i3 : envelope_553_i3 = + insert (5, 7) (Finset.univ.biUnion childrenD_553_i3) := by + exact envelope_eq_combination childrenD_553_i3 (5, 7) envelope_553_i3 + pivot_mem_553_i3 child_envelope_sub_553_i3 envelope_origin_553_i3 +def checked_553_i3 : CheckedCard where + required := required_553_i3 + envelope := envelope_553_i3 + height := height_553_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_553_i3 +def height_553_i2 : ℕ := 5 +def childrenH_553_i2 : Fin 4 → ℕ := ![height_10, height_52, height_52, height_553_i3] +theorem height_exact_553_i2 : height_553_i2 = 1 + Finset.univ.sup childrenH_553_i2 := by decide +kernel +theorem required_origin_553_i2 : ∀ x ∈ required_553_i2, + (∃ j, x ∈ childrenC_553_i2 j) ∨ ∀ j, x ∈ childrenD_553_i2 j := by decide +kernel +theorem required_exact_553_i2 : required_553_i2 = + ((Finset.univ.biUnion childrenC_553_i2) ∪ commonEnvelope childrenD_553_i2).erase (5, 5) := by + exact required_eq_combination childrenC_553_i2 childrenD_553_i2 (5, 5) required_553_i2 + (by decide +kernel) child_required_sub_553_i2 common_sub_553_i2 required_origin_553_i2 +theorem envelope_origin_553_i2 : ∀ x ∈ envelope_553_i2, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_553_i2 j := by decide +kernel +theorem envelope_exact_553_i2 : envelope_553_i2 = + insert (5, 5) (Finset.univ.biUnion childrenD_553_i2) := by + exact envelope_eq_combination childrenD_553_i2 (5, 5) envelope_553_i2 + pivot_mem_553_i2 child_envelope_sub_553_i2 envelope_origin_553_i2 +def checked_553_i2 : CheckedCard where + required := required_553_i2 + envelope := envelope_553_i2 + height := height_553_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_553_i2 +def height_553_i1 : ℕ := 6 +def childrenH_553_i1 : Fin 2 → ℕ := ![height_3, height_553_i2] +theorem height_exact_553_i1 : height_553_i1 = 1 + Finset.univ.sup childrenH_553_i1 := by decide +kernel +theorem required_origin_553_i1 : ∀ x ∈ required_553_i1, + (∃ j, x ∈ childrenC_553_i1 j) ∨ ∀ j, x ∈ childrenD_553_i1 j := by decide +kernel +theorem required_exact_553_i1 : required_553_i1 = + ((Finset.univ.biUnion childrenC_553_i1) ∪ commonEnvelope childrenD_553_i1).erase (5, 6) := by + exact required_eq_combination childrenC_553_i1 childrenD_553_i1 (5, 6) required_553_i1 + (by decide +kernel) child_required_sub_553_i1 common_sub_553_i1 required_origin_553_i1 +theorem envelope_origin_553_i1 : ∀ x ∈ envelope_553_i1, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_553_i1 j := by decide +kernel +theorem envelope_exact_553_i1 : envelope_553_i1 = + insert (5, 6) (Finset.univ.biUnion childrenD_553_i1) := by + exact envelope_eq_combination childrenD_553_i1 (5, 6) envelope_553_i1 + pivot_mem_553_i1 child_envelope_sub_553_i1 envelope_origin_553_i1 +def checked_553_i1 : CheckedCard where + required := required_553_i1 + envelope := envelope_553_i1 + height := height_553_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_553_i1 +def height_553_i6 : ℕ := 6 +def childrenH_553_i6 : Fin 2 → ℕ := ![height_6, height_145] +theorem height_exact_553_i6 : height_553_i6 = 1 + Finset.univ.sup childrenH_553_i6 := by decide +kernel +theorem required_origin_553_i6 : ∀ x ∈ required_553_i6, + (∃ j, x ∈ childrenC_553_i6 j) ∨ ∀ j, x ∈ childrenD_553_i6 j := by decide +kernel +theorem required_exact_553_i6 : required_553_i6 = + ((Finset.univ.biUnion childrenC_553_i6) ∪ commonEnvelope childrenD_553_i6).erase (6, 4) := by + exact required_eq_combination childrenC_553_i6 childrenD_553_i6 (6, 4) required_553_i6 + (by decide +kernel) child_required_sub_553_i6 common_sub_553_i6 required_origin_553_i6 +theorem envelope_origin_553_i6 : ∀ x ∈ envelope_553_i6, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_553_i6 j := by decide +kernel +theorem envelope_exact_553_i6 : envelope_553_i6 = + insert (6, 4) (Finset.univ.biUnion childrenD_553_i6) := by + exact envelope_eq_combination childrenD_553_i6 (6, 4) envelope_553_i6 + pivot_mem_553_i6 child_envelope_sub_553_i6 envelope_origin_553_i6 +def checked_553_i6 : CheckedCard where + required := required_553_i6 + envelope := envelope_553_i6 + height := height_553_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_553_i6 +def height_553_i5 : ℕ := 7 +def childrenH_553_i5 : Fin 3 → ℕ := ![height_54, height_158, height_553_i6] +theorem height_exact_553_i5 : height_553_i5 = 1 + Finset.univ.sup childrenH_553_i5 := by decide +kernel +theorem required_origin_553_i5 : ∀ x ∈ required_553_i5, + (∃ j, x ∈ childrenC_553_i5 j) ∨ ∀ j, x ∈ childrenD_553_i5 j := by decide +kernel +theorem required_exact_553_i5 : required_553_i5 = + ((Finset.univ.biUnion childrenC_553_i5) ∪ commonEnvelope childrenD_553_i5).erase (7, 4) := by + exact required_eq_combination childrenC_553_i5 childrenD_553_i5 (7, 4) required_553_i5 + (by decide +kernel) child_required_sub_553_i5 common_sub_553_i5 required_origin_553_i5 +theorem envelope_origin_553_i5 : ∀ x ∈ envelope_553_i5, + x = (7, 4) ∨ ∃ j, x ∈ childrenD_553_i5 j := by decide +kernel +theorem envelope_exact_553_i5 : envelope_553_i5 = + insert (7, 4) (Finset.univ.biUnion childrenD_553_i5) := by + exact envelope_eq_combination childrenD_553_i5 (7, 4) envelope_553_i5 + pivot_mem_553_i5 child_envelope_sub_553_i5 envelope_origin_553_i5 +def checked_553_i5 : CheckedCard where + required := required_553_i5 + envelope := envelope_553_i5 + height := height_553_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_553_i5 +def height_553_i4 : ℕ := 8 +def childrenH_553_i4 : Fin 2 → ℕ := ![height_2, height_553_i5] +theorem height_exact_553_i4 : height_553_i4 = 1 + Finset.univ.sup childrenH_553_i4 := by decide +kernel +theorem required_origin_553_i4 : ∀ x ∈ required_553_i4, + (∃ j, x ∈ childrenC_553_i4 j) ∨ ∀ j, x ∈ childrenD_553_i4 j := by decide +kernel +theorem required_exact_553_i4 : required_553_i4 = + ((Finset.univ.biUnion childrenC_553_i4) ∪ commonEnvelope childrenD_553_i4).erase (6, 7) := by + exact required_eq_combination childrenC_553_i4 childrenD_553_i4 (6, 7) required_553_i4 + (by decide +kernel) child_required_sub_553_i4 common_sub_553_i4 required_origin_553_i4 +theorem envelope_origin_553_i4 : ∀ x ∈ envelope_553_i4, + x = (6, 7) ∨ ∃ j, x ∈ childrenD_553_i4 j := by decide +kernel +theorem envelope_exact_553_i4 : envelope_553_i4 = + insert (6, 7) (Finset.univ.biUnion childrenD_553_i4) := by + exact envelope_eq_combination childrenD_553_i4 (6, 7) envelope_553_i4 + pivot_mem_553_i4 child_envelope_sub_553_i4 envelope_origin_553_i4 +def checked_553_i4 : CheckedCard where + required := required_553_i4 + envelope := envelope_553_i4 + height := height_553_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_553_i4 +def height_553_i8 : ℕ := 4 +def childrenH_553_i8 : Fin 2 → ℕ := ![height_54, height_247] +theorem height_exact_553_i8 : height_553_i8 = 1 + Finset.univ.sup childrenH_553_i8 := by decide +kernel +theorem required_origin_553_i8 : ∀ x ∈ required_553_i8, + (∃ j, x ∈ childrenC_553_i8 j) ∨ ∀ j, x ∈ childrenD_553_i8 j := by decide +kernel +theorem required_exact_553_i8 : required_553_i8 = + ((Finset.univ.biUnion childrenC_553_i8) ∪ commonEnvelope childrenD_553_i8).erase (4, 3) := by + exact required_eq_combination childrenC_553_i8 childrenD_553_i8 (4, 3) required_553_i8 + (by decide +kernel) child_required_sub_553_i8 common_sub_553_i8 required_origin_553_i8 +theorem envelope_origin_553_i8 : ∀ x ∈ envelope_553_i8, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_553_i8 j := by decide +kernel +theorem envelope_exact_553_i8 : envelope_553_i8 = + insert (4, 3) (Finset.univ.biUnion childrenD_553_i8) := by + exact envelope_eq_combination childrenD_553_i8 (4, 3) envelope_553_i8 + pivot_mem_553_i8 child_envelope_sub_553_i8 envelope_origin_553_i8 +def checked_553_i8 : CheckedCard where + required := required_553_i8 + envelope := envelope_553_i8 + height := height_553_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_553_i8 +def height_553_i7 : ℕ := 5 +def childrenH_553_i7 : Fin 2 → ℕ := ![height_3, height_553_i8] +theorem height_exact_553_i7 : height_553_i7 = 1 + Finset.univ.sup childrenH_553_i7 := by decide +kernel +theorem required_origin_553_i7 : ∀ x ∈ required_553_i7, + (∃ j, x ∈ childrenC_553_i7 j) ∨ ∀ j, x ∈ childrenD_553_i7 j := by decide +kernel +theorem required_exact_553_i7 : required_553_i7 = + ((Finset.univ.biUnion childrenC_553_i7) ∪ commonEnvelope childrenD_553_i7).erase (5, 6) := by + exact required_eq_combination childrenC_553_i7 childrenD_553_i7 (5, 6) required_553_i7 + (by decide +kernel) child_required_sub_553_i7 common_sub_553_i7 required_origin_553_i7 +theorem envelope_origin_553_i7 : ∀ x ∈ envelope_553_i7, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_553_i7 j := by decide +kernel +theorem envelope_exact_553_i7 : envelope_553_i7 = + insert (5, 6) (Finset.univ.biUnion childrenD_553_i7) := by + exact envelope_eq_combination childrenD_553_i7 (5, 6) envelope_553_i7 + pivot_mem_553_i7 child_envelope_sub_553_i7 envelope_origin_553_i7 +def checked_553_i7 : CheckedCard where + required := required_553_i7 + envelope := envelope_553_i7 + height := height_553_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_553_i7 +def height_553_i0 : ℕ := 9 +def childrenH_553_i0 : Fin 4 → ℕ := ![height_433, height_553_i1, height_553_i4, height_553_i7] +theorem height_exact_553_i0 : height_553_i0 = 1 + Finset.univ.sup childrenH_553_i0 := by decide +kernel +theorem required_origin_553_i0 : ∀ x ∈ required_553_i0, + (∃ j, x ∈ childrenC_553_i0 j) ∨ ∀ j, x ∈ childrenD_553_i0 j := by decide +kernel +theorem required_exact_553_i0 : required_553_i0 = + ((Finset.univ.biUnion childrenC_553_i0) ∪ commonEnvelope childrenD_553_i0).erase (5, 4) := by + exact required_eq_combination childrenC_553_i0 childrenD_553_i0 (5, 4) required_553_i0 + (by decide +kernel) child_required_sub_553_i0 common_sub_553_i0 required_origin_553_i0 +theorem envelope_origin_553_i0 : ∀ x ∈ envelope_553_i0, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_553_i0 j := by decide +kernel +theorem envelope_exact_553_i0 : envelope_553_i0 = + insert (5, 4) (Finset.univ.biUnion childrenD_553_i0) := by + exact envelope_eq_combination childrenD_553_i0 (5, 4) envelope_553_i0 + pivot_mem_553_i0 child_envelope_sub_553_i0 envelope_origin_553_i0 +def checked_553_i0 : CheckedCard where + required := required_553_i0 + envelope := envelope_553_i0 + height := height_553_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_553_i0 +def height_553 : ℕ := 14 +def childrenH_553 : Fin 5 → ℕ := ![height_107, height_163, height_538, height_552, height_553_i0] +theorem height_exact_553 : height_553 = 1 + Finset.univ.sup childrenH_553 := by decide +kernel +theorem required_origin_553 : ∀ x ∈ required_553, + (∃ j, x ∈ childrenC_553 j) ∨ ∀ j, x ∈ childrenD_553 j := by decide +kernel +theorem required_exact_553 : required_553 = + ((Finset.univ.biUnion childrenC_553) ∪ commonEnvelope childrenD_553).erase (7, 6) := by + exact required_eq_combination childrenC_553 childrenD_553 (7, 6) required_553 + (by decide +kernel) child_required_sub_553 common_sub_553 required_origin_553 +theorem envelope_origin_553 : ∀ x ∈ envelope_553, + x = (7, 6) ∨ ∃ j, x ∈ childrenD_553 j := by decide +kernel +theorem envelope_exact_553 : envelope_553 = + insert (7, 6) (Finset.univ.biUnion childrenD_553) := by + exact envelope_eq_combination childrenD_553 (7, 6) envelope_553 + pivot_mem_553 child_envelope_sub_553 envelope_origin_553 +def checked_553 : CheckedCard where + required := required_553 + envelope := envelope_553 + height := height_553 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_553 +def height_557_i0 : ℕ := 5 +def childrenH_557_i0 : Fin 3 → ℕ := ![height_13, height_28, height_58] +theorem height_exact_557_i0 : height_557_i0 = 1 + Finset.univ.sup childrenH_557_i0 := by decide +kernel +theorem required_origin_557_i0 : ∀ x ∈ required_557_i0, + (∃ j, x ∈ childrenC_557_i0 j) ∨ ∀ j, x ∈ childrenD_557_i0 j := by decide +kernel +theorem required_exact_557_i0 : required_557_i0 = + ((Finset.univ.biUnion childrenC_557_i0) ∪ commonEnvelope childrenD_557_i0).erase (4, 7) := by + exact required_eq_combination childrenC_557_i0 childrenD_557_i0 (4, 7) required_557_i0 + (by decide +kernel) child_required_sub_557_i0 common_sub_557_i0 required_origin_557_i0 +theorem envelope_origin_557_i0 : ∀ x ∈ envelope_557_i0, + x = (4, 7) ∨ ∃ j, x ∈ childrenD_557_i0 j := by decide +kernel +theorem envelope_exact_557_i0 : envelope_557_i0 = + insert (4, 7) (Finset.univ.biUnion childrenD_557_i0) := by + exact envelope_eq_combination childrenD_557_i0 (4, 7) envelope_557_i0 + pivot_mem_557_i0 child_envelope_sub_557_i0 envelope_origin_557_i0 +def checked_557_i0 : CheckedCard where + required := required_557_i0 + envelope := envelope_557_i0 + height := height_557_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_557_i0 +def height_557_i4 : ℕ := 2 +def childrenH_557_i4 : Fin 2 → ℕ := ![height_2, height_5] +theorem height_exact_557_i4 : height_557_i4 = 1 + Finset.univ.sup childrenH_557_i4 := by decide +kernel +theorem required_origin_557_i4 : ∀ x ∈ required_557_i4, + (∃ j, x ∈ childrenC_557_i4 j) ∨ ∀ j, x ∈ childrenD_557_i4 j := by decide +kernel +theorem required_exact_557_i4 : required_557_i4 = + ((Finset.univ.biUnion childrenC_557_i4) ∪ commonEnvelope childrenD_557_i4).erase (1, 5) := by + exact required_eq_combination childrenC_557_i4 childrenD_557_i4 (1, 5) required_557_i4 + (by decide +kernel) child_required_sub_557_i4 common_sub_557_i4 required_origin_557_i4 +theorem envelope_origin_557_i4 : ∀ x ∈ envelope_557_i4, + x = (1, 5) ∨ ∃ j, x ∈ childrenD_557_i4 j := by decide +kernel +theorem envelope_exact_557_i4 : envelope_557_i4 = + insert (1, 5) (Finset.univ.biUnion childrenD_557_i4) := by + exact envelope_eq_combination childrenD_557_i4 (1, 5) envelope_557_i4 + pivot_mem_557_i4 child_envelope_sub_557_i4 envelope_origin_557_i4 +def checked_557_i4 : CheckedCard where + required := required_557_i4 + envelope := envelope_557_i4 + height := height_557_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_557_i4 +def height_557_i6 : ℕ := 7 +def childrenH_557_i6 : Fin 2 → ℕ := ![height_1, height_392] +theorem height_exact_557_i6 : height_557_i6 = 1 + Finset.univ.sup childrenH_557_i6 := by decide +kernel +theorem required_origin_557_i6 : ∀ x ∈ required_557_i6, + (∃ j, x ∈ childrenC_557_i6 j) ∨ ∀ j, x ∈ childrenD_557_i6 j := by decide +kernel +theorem required_exact_557_i6 : required_557_i6 = + ((Finset.univ.biUnion childrenC_557_i6) ∪ commonEnvelope childrenD_557_i6).erase (3, 4) := by + exact required_eq_combination childrenC_557_i6 childrenD_557_i6 (3, 4) required_557_i6 + (by decide +kernel) child_required_sub_557_i6 common_sub_557_i6 required_origin_557_i6 +theorem envelope_origin_557_i6 : ∀ x ∈ envelope_557_i6, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_557_i6 j := by decide +kernel +theorem envelope_exact_557_i6 : envelope_557_i6 = + insert (3, 4) (Finset.univ.biUnion childrenD_557_i6) := by + exact envelope_eq_combination childrenD_557_i6 (3, 4) envelope_557_i6 + pivot_mem_557_i6 child_envelope_sub_557_i6 envelope_origin_557_i6 +def checked_557_i6 : CheckedCard where + required := required_557_i6 + envelope := envelope_557_i6 + height := height_557_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_557_i6 +def height_557_i5 : ℕ := 8 +def childrenH_557_i5 : Fin 3 → ℕ := ![height_11, height_41, height_557_i6] +theorem height_exact_557_i5 : height_557_i5 = 1 + Finset.univ.sup childrenH_557_i5 := by decide +kernel +theorem required_origin_557_i5 : ∀ x ∈ required_557_i5, + (∃ j, x ∈ childrenC_557_i5 j) ∨ ∀ j, x ∈ childrenD_557_i5 j := by decide +kernel +theorem required_exact_557_i5 : required_557_i5 = + ((Finset.univ.biUnion childrenC_557_i5) ∪ commonEnvelope childrenD_557_i5).erase (3, 3) := by + exact required_eq_combination childrenC_557_i5 childrenD_557_i5 (3, 3) required_557_i5 + (by decide +kernel) child_required_sub_557_i5 common_sub_557_i5 required_origin_557_i5 +theorem envelope_origin_557_i5 : ∀ x ∈ envelope_557_i5, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_557_i5 j := by decide +kernel +theorem envelope_exact_557_i5 : envelope_557_i5 = + insert (3, 3) (Finset.univ.biUnion childrenD_557_i5) := by + exact envelope_eq_combination childrenD_557_i5 (3, 3) envelope_557_i5 + pivot_mem_557_i5 child_envelope_sub_557_i5 envelope_origin_557_i5 +def checked_557_i5 : CheckedCard where + required := required_557_i5 + envelope := envelope_557_i5 + height := height_557_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_557_i5 +def height_557_i3 : ℕ := 9 +def childrenH_557_i3 : Fin 2 → ℕ := ![height_557_i4, height_557_i5] +theorem height_exact_557_i3 : height_557_i3 = 1 + Finset.univ.sup childrenH_557_i3 := by decide +kernel +theorem required_origin_557_i3 : ∀ x ∈ required_557_i3, + (∃ j, x ∈ childrenC_557_i3 j) ∨ ∀ j, x ∈ childrenD_557_i3 j := by decide +kernel +theorem required_exact_557_i3 : required_557_i3 = + ((Finset.univ.biUnion childrenC_557_i3) ∪ commonEnvelope childrenD_557_i3).erase (2, 2) := by + exact required_eq_combination childrenC_557_i3 childrenD_557_i3 (2, 2) required_557_i3 + (by decide +kernel) child_required_sub_557_i3 common_sub_557_i3 required_origin_557_i3 +theorem envelope_origin_557_i3 : ∀ x ∈ envelope_557_i3, + x = (2, 2) ∨ ∃ j, x ∈ childrenD_557_i3 j := by decide +kernel +theorem envelope_exact_557_i3 : envelope_557_i3 = + insert (2, 2) (Finset.univ.biUnion childrenD_557_i3) := by + exact envelope_eq_combination childrenD_557_i3 (2, 2) envelope_557_i3 + pivot_mem_557_i3 child_envelope_sub_557_i3 envelope_origin_557_i3 +def checked_557_i3 : CheckedCard where + required := required_557_i3 + envelope := envelope_557_i3 + height := height_557_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_557_i3 +def height_557_i2 : ℕ := 10 +def childrenH_557_i2 : Fin 3 → ℕ := ![height_42, height_152, height_557_i3] +theorem height_exact_557_i2 : height_557_i2 = 1 + Finset.univ.sup childrenH_557_i2 := by decide +kernel +theorem required_origin_557_i2 : ∀ x ∈ required_557_i2, + (∃ j, x ∈ childrenC_557_i2 j) ∨ ∀ j, x ∈ childrenD_557_i2 j := by decide +kernel +theorem required_exact_557_i2 : required_557_i2 = + ((Finset.univ.biUnion childrenC_557_i2) ∪ commonEnvelope childrenD_557_i2).erase (4, 3) := by + exact required_eq_combination childrenC_557_i2 childrenD_557_i2 (4, 3) required_557_i2 + (by decide +kernel) child_required_sub_557_i2 common_sub_557_i2 required_origin_557_i2 +theorem envelope_origin_557_i2 : ∀ x ∈ envelope_557_i2, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_557_i2 j := by decide +kernel +theorem envelope_exact_557_i2 : envelope_557_i2 = + insert (4, 3) (Finset.univ.biUnion childrenD_557_i2) := by + exact envelope_eq_combination childrenD_557_i2 (4, 3) envelope_557_i2 + pivot_mem_557_i2 child_envelope_sub_557_i2 envelope_origin_557_i2 +def checked_557_i2 : CheckedCard where + required := required_557_i2 + envelope := envelope_557_i2 + height := height_557_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_557_i2 +def height_557_i1 : ℕ := 11 +def childrenH_557_i1 : Fin 2 → ℕ := ![height_5, height_557_i2] +theorem height_exact_557_i1 : height_557_i1 = 1 + Finset.univ.sup childrenH_557_i1 := by decide +kernel +theorem required_origin_557_i1 : ∀ x ∈ required_557_i1, + (∃ j, x ∈ childrenC_557_i1 j) ∨ ∀ j, x ∈ childrenD_557_i1 j := by decide +kernel +theorem required_exact_557_i1 : required_557_i1 = + ((Finset.univ.biUnion childrenC_557_i1) ∪ commonEnvelope childrenD_557_i1).erase (3, 6) := by + exact required_eq_combination childrenC_557_i1 childrenD_557_i1 (3, 6) required_557_i1 + (by decide +kernel) child_required_sub_557_i1 common_sub_557_i1 required_origin_557_i1 +theorem envelope_origin_557_i1 : ∀ x ∈ envelope_557_i1, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_557_i1 j := by decide +kernel +theorem envelope_exact_557_i1 : envelope_557_i1 = + insert (3, 6) (Finset.univ.biUnion childrenD_557_i1) := by + exact envelope_eq_combination childrenD_557_i1 (3, 6) envelope_557_i1 + pivot_mem_557_i1 child_envelope_sub_557_i1 envelope_origin_557_i1 +def checked_557_i1 : CheckedCard where + required := required_557_i1 + envelope := envelope_557_i1 + height := height_557_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_557_i1 +def height_557 : ℕ := 14 +def childrenH_557 : Fin 7 → ℕ := ![height_110, height_119, height_430, height_461, height_555, height_557_i0, height_557_i1] +theorem height_exact_557 : height_557 = 1 + Finset.univ.sup childrenH_557 := by decide +kernel +theorem required_origin_557 : ∀ x ∈ required_557, + (∃ j, x ∈ childrenC_557 j) ∨ ∀ j, x ∈ childrenD_557 j := by decide +kernel +theorem required_exact_557 : required_557 = + ((Finset.univ.biUnion childrenC_557) ∪ commonEnvelope childrenD_557).erase (4, 6) := by + exact required_eq_combination childrenC_557 childrenD_557 (4, 6) required_557 + (by decide +kernel) child_required_sub_557 common_sub_557 required_origin_557 +theorem envelope_origin_557 : ∀ x ∈ envelope_557, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_557 j := by decide +kernel +theorem envelope_exact_557 : envelope_557 = + insert (4, 6) (Finset.univ.biUnion childrenD_557) := by + exact envelope_eq_combination childrenD_557 (4, 6) envelope_557 + pivot_mem_557 child_envelope_sub_557 envelope_origin_557 +def checked_557 : CheckedCard where + required := required_557 + envelope := envelope_557 + height := height_557 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_557 +def height_582_i1 : ℕ := 4 +def childrenH_582_i1 : Fin 2 → ℕ := ![height_5, height_160] +theorem height_exact_582_i1 : height_582_i1 = 1 + Finset.univ.sup childrenH_582_i1 := by decide +kernel +theorem required_origin_582_i1 : ∀ x ∈ required_582_i1, + (∃ j, x ∈ childrenC_582_i1 j) ∨ ∀ j, x ∈ childrenD_582_i1 j := by decide +kernel +theorem required_exact_582_i1 : required_582_i1 = + ((Finset.univ.biUnion childrenC_582_i1) ∪ commonEnvelope childrenD_582_i1).erase (5, 6) := by + exact required_eq_combination childrenC_582_i1 childrenD_582_i1 (5, 6) required_582_i1 + (by decide +kernel) child_required_sub_582_i1 common_sub_582_i1 required_origin_582_i1 +theorem envelope_origin_582_i1 : ∀ x ∈ envelope_582_i1, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_582_i1 j := by decide +kernel +theorem envelope_exact_582_i1 : envelope_582_i1 = + insert (5, 6) (Finset.univ.biUnion childrenD_582_i1) := by + exact envelope_eq_combination childrenD_582_i1 (5, 6) envelope_582_i1 + pivot_mem_582_i1 child_envelope_sub_582_i1 envelope_origin_582_i1 +def checked_582_i1 : CheckedCard where + required := required_582_i1 + envelope := envelope_582_i1 + height := height_582_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_582_i1 +def height_582_i0 : ℕ := 6 +def childrenH_582_i0 : Fin 2 → ℕ := ![height_133, height_582_i1] +theorem height_exact_582_i0 : height_582_i0 = 1 + Finset.univ.sup childrenH_582_i0 := by decide +kernel +theorem required_origin_582_i0 : ∀ x ∈ required_582_i0, + (∃ j, x ∈ childrenC_582_i0 j) ∨ ∀ j, x ∈ childrenD_582_i0 j := by decide +kernel +theorem required_exact_582_i0 : required_582_i0 = + ((Finset.univ.biUnion childrenC_582_i0) ∪ commonEnvelope childrenD_582_i0).erase (4, 5) := by + exact required_eq_combination childrenC_582_i0 childrenD_582_i0 (4, 5) required_582_i0 + (by decide +kernel) child_required_sub_582_i0 common_sub_582_i0 required_origin_582_i0 +theorem envelope_origin_582_i0 : ∀ x ∈ envelope_582_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_582_i0 j := by decide +kernel +theorem envelope_exact_582_i0 : envelope_582_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_582_i0) := by + exact envelope_eq_combination childrenD_582_i0 (4, 5) envelope_582_i0 + pivot_mem_582_i0 child_envelope_sub_582_i0 envelope_origin_582_i0 +def checked_582_i0 : CheckedCard where + required := required_582_i0 + envelope := envelope_582_i0 + height := height_582_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_582_i0 +def height_582_i2 : ℕ := 5 +def childrenH_582_i2 : Fin 4 → ℕ := ![height_12, height_14, height_109, height_424] +theorem height_exact_582_i2 : height_582_i2 = 1 + Finset.univ.sup childrenH_582_i2 := by decide +kernel +theorem required_origin_582_i2 : ∀ x ∈ required_582_i2, + (∃ j, x ∈ childrenC_582_i2 j) ∨ ∀ j, x ∈ childrenD_582_i2 j := by decide +kernel +theorem required_exact_582_i2 : required_582_i2 = + ((Finset.univ.biUnion childrenC_582_i2) ∪ commonEnvelope childrenD_582_i2).erase (3, 6) := by + exact required_eq_combination childrenC_582_i2 childrenD_582_i2 (3, 6) required_582_i2 + (by decide +kernel) child_required_sub_582_i2 common_sub_582_i2 required_origin_582_i2 +theorem envelope_origin_582_i2 : ∀ x ∈ envelope_582_i2, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_582_i2 j := by decide +kernel +theorem envelope_exact_582_i2 : envelope_582_i2 = + insert (3, 6) (Finset.univ.biUnion childrenD_582_i2) := by + exact envelope_eq_combination childrenD_582_i2 (3, 6) envelope_582_i2 + pivot_mem_582_i2 child_envelope_sub_582_i2 envelope_origin_582_i2 +def checked_582_i2 : CheckedCard where + required := required_582_i2 + envelope := envelope_582_i2 + height := height_582_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_582_i2 +def height_582_i3 : ℕ := 6 +def childrenH_582_i3 : Fin 2 → ℕ := ![height_383, height_432] +theorem height_exact_582_i3 : height_582_i3 = 1 + Finset.univ.sup childrenH_582_i3 := by decide +kernel +theorem required_origin_582_i3 : ∀ x ∈ required_582_i3, + (∃ j, x ∈ childrenC_582_i3 j) ∨ ∀ j, x ∈ childrenD_582_i3 j := by decide +kernel +theorem required_exact_582_i3 : required_582_i3 = + ((Finset.univ.biUnion childrenC_582_i3) ∪ commonEnvelope childrenD_582_i3).erase (4, 5) := by + exact required_eq_combination childrenC_582_i3 childrenD_582_i3 (4, 5) required_582_i3 + (by decide +kernel) child_required_sub_582_i3 common_sub_582_i3 required_origin_582_i3 +theorem envelope_origin_582_i3 : ∀ x ∈ envelope_582_i3, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_582_i3 j := by decide +kernel +theorem envelope_exact_582_i3 : envelope_582_i3 = + insert (4, 5) (Finset.univ.biUnion childrenD_582_i3) := by + exact envelope_eq_combination childrenD_582_i3 (4, 5) envelope_582_i3 + pivot_mem_582_i3 child_envelope_sub_582_i3 envelope_origin_582_i3 +def checked_582_i3 : CheckedCard where + required := required_582_i3 + envelope := envelope_582_i3 + height := height_582_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_582_i3 +def height_582 : ℕ := 14 +def childrenH_582 : Fin 6 → ℕ := ![height_184, height_423, height_572, height_582_i0, height_582_i2, height_582_i3] +theorem height_exact_582 : height_582 = 1 + Finset.univ.sup childrenH_582 := by decide +kernel +theorem required_origin_582 : ∀ x ∈ required_582, + (∃ j, x ∈ childrenC_582 j) ∨ ∀ j, x ∈ childrenD_582 j := by decide +kernel +theorem required_exact_582 : required_582 = + ((Finset.univ.biUnion childrenC_582) ∪ commonEnvelope childrenD_582).erase (4, 6) := by + exact required_eq_combination childrenC_582 childrenD_582 (4, 6) required_582 + (by decide +kernel) child_required_sub_582 common_sub_582 required_origin_582 +theorem envelope_origin_582 : ∀ x ∈ envelope_582, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_582 j := by decide +kernel +theorem envelope_exact_582 : envelope_582 = + insert (4, 6) (Finset.univ.biUnion childrenD_582) := by + exact envelope_eq_combination childrenD_582 (4, 6) envelope_582 + pivot_mem_582 child_envelope_sub_582 envelope_origin_582 +def checked_582 : CheckedCard where + required := required_582 + envelope := envelope_582 + height := height_582 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_582 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part02.lean new file mode 100644 index 0000000..af5369a --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part02.lean @@ -0,0 +1,979 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_598_i2 : Finset Cell := ⟨(([(3, 5), (3, 6), (4, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_598_i2 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 5), (3, 6), (4, 5), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_598_i2 : Fin 2 → Finset Cell := ![(placed21 2 (6, 5) required_5), (placed21 2 (7, 3) required_133)] +def childrenD_598_i2 : Fin 2 → Finset Cell := ![(placed21 2 (6, 5) envelope_5), (placed21 2 (7, 3) envelope_133)] +theorem common_sub_598_i2 : commonEnvelope childrenD_598_i2 ⊆ insert (5, 5) required_598_i2 := by decide +kernel +theorem child_required_sub_598_i2 : ∀ j, childrenC_598_i2 j ⊆ insert (5, 5) required_598_i2 := by decide +kernel +theorem child_envelope_sub_598_i2 : ∀ j, childrenD_598_i2 j ⊆ envelope_598_i2 := by decide +kernel +theorem pivot_mem_598_i2 : (5, 5) ∈ envelope_598_i2 := by decide +kernel +theorem children_work_598_i2 : ∀ j, Template HasSnaky 5 (childrenC_598_i2 j) (childrenD_598_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (6, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_133 2 (7, 3)).mono (by decide +kernel) +theorem row_works_598_i2 : Template HasSnaky 6 required_598_i2 envelope_598_i2 := by + refine compose HasSnaky 5 childrenC_598_i2 childrenD_598_i2 children_work_598_i2 (5, 5) + required_598_i2 envelope_598_i2 pivot_mem_598_i2 child_required_sub_598_i2 child_envelope_sub_598_i2 ?_ + intro b hb + exact common_sub_598_i2 (mem_commonEnvelope childrenD_598_i2 b hb) +def required_598_i1 : Finset Cell := ⟨(([(3, 5), (3, 6), (3, 7), (4, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_598_i1 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_598_i1 : Fin 2 → Finset Cell := ![(placed21 3 (3, 8) required_0), required_598_i2] +def childrenD_598_i1 : Fin 2 → Finset Cell := ![(placed21 3 (3, 8) envelope_0), envelope_598_i2] +theorem common_sub_598_i1 : commonEnvelope childrenD_598_i1 ⊆ insert (4, 5) required_598_i1 := by decide +kernel +theorem child_required_sub_598_i1 : ∀ j, childrenC_598_i1 j ⊆ insert (4, 5) required_598_i1 := by decide +kernel +theorem child_envelope_sub_598_i1 : ∀ j, childrenD_598_i1 j ⊆ envelope_598_i1 := by decide +kernel +theorem pivot_mem_598_i1 : (4, 5) ∈ envelope_598_i1 := by decide +kernel +theorem children_work_598_i1 : ∀ j, Template HasSnaky 6 (childrenC_598_i1 j) (childrenD_598_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (3, 8)).mono (by decide +kernel) + · exact row_works_598_i2.mono (by decide +kernel) +theorem row_works_598_i1 : Template HasSnaky 7 required_598_i1 envelope_598_i1 := by + refine compose HasSnaky 6 childrenC_598_i1 childrenD_598_i1 children_work_598_i1 (4, 5) + required_598_i1 envelope_598_i1 pivot_mem_598_i1 child_required_sub_598_i1 child_envelope_sub_598_i1 ?_ + intro b hb + exact common_sub_598_i1 (mem_commonEnvelope childrenD_598_i1 b hb) +def required_598_i0 : Finset Cell := ⟨(([(3, 4), (3, 5), (3, 7), (4, 4), (4, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_598_i0 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 7), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_598_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 4) required_5), required_598_i1] +def childrenD_598_i0 : Fin 2 → Finset Cell := ![(placed21 1 (3, 4) envelope_5), envelope_598_i1] +theorem common_sub_598_i0 : commonEnvelope childrenD_598_i0 ⊆ insert (3, 6) required_598_i0 := by decide +kernel +theorem child_required_sub_598_i0 : ∀ j, childrenC_598_i0 j ⊆ insert (3, 6) required_598_i0 := by decide +kernel +theorem child_envelope_sub_598_i0 : ∀ j, childrenD_598_i0 j ⊆ envelope_598_i0 := by decide +kernel +theorem pivot_mem_598_i0 : (3, 6) ∈ envelope_598_i0 := by decide +kernel +theorem children_work_598_i0 : ∀ j, Template HasSnaky 7 (childrenC_598_i0 j) (childrenD_598_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 4)).mono (by decide +kernel) + · exact row_works_598_i1.mono (by decide +kernel) +theorem row_works_598_i0 : Template HasSnaky 8 required_598_i0 envelope_598_i0 := by + refine compose HasSnaky 7 childrenC_598_i0 childrenD_598_i0 children_work_598_i0 (3, 6) + required_598_i0 envelope_598_i0 pivot_mem_598_i0 child_required_sub_598_i0 child_envelope_sub_598_i0 ?_ + intro b hb + exact common_sub_598_i0 (mem_commonEnvelope childrenD_598_i0 b hb) +def required_598_i5 : Finset Cell := ⟨(([(3, 5), (3, 6), (4, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_598_i5 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 5), (3, 6), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_598_i5 : Fin 2 → Finset Cell := ![(placed21 2 (6, 5) required_5), (placed21 6 (7, 7) required_133)] +def childrenD_598_i5 : Fin 2 → Finset Cell := ![(placed21 2 (6, 5) envelope_5), (placed21 6 (7, 7) envelope_133)] +theorem common_sub_598_i5 : commonEnvelope childrenD_598_i5 ⊆ insert (5, 5) required_598_i5 := by decide +kernel +theorem child_required_sub_598_i5 : ∀ j, childrenC_598_i5 j ⊆ insert (5, 5) required_598_i5 := by decide +kernel +theorem child_envelope_sub_598_i5 : ∀ j, childrenD_598_i5 j ⊆ envelope_598_i5 := by decide +kernel +theorem pivot_mem_598_i5 : (5, 5) ∈ envelope_598_i5 := by decide +kernel +theorem children_work_598_i5 : ∀ j, Template HasSnaky 5 (childrenC_598_i5 j) (childrenD_598_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (6, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_133 6 (7, 7)).mono (by decide +kernel) +theorem row_works_598_i5 : Template HasSnaky 6 required_598_i5 envelope_598_i5 := by + refine compose HasSnaky 5 childrenC_598_i5 childrenD_598_i5 children_work_598_i5 (5, 5) + required_598_i5 envelope_598_i5 pivot_mem_598_i5 child_required_sub_598_i5 child_envelope_sub_598_i5 ?_ + intro b hb + exact common_sub_598_i5 (mem_commonEnvelope childrenD_598_i5 b hb) +def required_598_i4 : Finset Cell := ⟨(([(3, 5), (3, 6), (3, 7), (4, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_598_i4 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_598_i4 : Fin 2 → Finset Cell := ![(placed21 3 (3, 8) required_0), required_598_i5] +def childrenD_598_i4 : Fin 2 → Finset Cell := ![(placed21 3 (3, 8) envelope_0), envelope_598_i5] +theorem common_sub_598_i4 : commonEnvelope childrenD_598_i4 ⊆ insert (4, 5) required_598_i4 := by decide +kernel +theorem child_required_sub_598_i4 : ∀ j, childrenC_598_i4 j ⊆ insert (4, 5) required_598_i4 := by decide +kernel +theorem child_envelope_sub_598_i4 : ∀ j, childrenD_598_i4 j ⊆ envelope_598_i4 := by decide +kernel +theorem pivot_mem_598_i4 : (4, 5) ∈ envelope_598_i4 := by decide +kernel +theorem children_work_598_i4 : ∀ j, Template HasSnaky 6 (childrenC_598_i4 j) (childrenD_598_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (3, 8)).mono (by decide +kernel) + · exact row_works_598_i5.mono (by decide +kernel) +theorem row_works_598_i4 : Template HasSnaky 7 required_598_i4 envelope_598_i4 := by + refine compose HasSnaky 6 childrenC_598_i4 childrenD_598_i4 children_work_598_i4 (4, 5) + required_598_i4 envelope_598_i4 pivot_mem_598_i4 child_required_sub_598_i4 child_envelope_sub_598_i4 ?_ + intro b hb + exact common_sub_598_i4 (mem_commonEnvelope childrenD_598_i4 b hb) +def required_598_i3 : Finset Cell := ⟨(([(3, 4), (3, 5), (3, 7), (4, 4), (4, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_598_i3 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_598_i3 : Fin 2 → Finset Cell := ![(placed21 1 (3, 4) required_5), required_598_i4] +def childrenD_598_i3 : Fin 2 → Finset Cell := ![(placed21 1 (3, 4) envelope_5), envelope_598_i4] +theorem common_sub_598_i3 : commonEnvelope childrenD_598_i3 ⊆ insert (3, 6) required_598_i3 := by decide +kernel +theorem child_required_sub_598_i3 : ∀ j, childrenC_598_i3 j ⊆ insert (3, 6) required_598_i3 := by decide +kernel +theorem child_envelope_sub_598_i3 : ∀ j, childrenD_598_i3 j ⊆ envelope_598_i3 := by decide +kernel +theorem pivot_mem_598_i3 : (3, 6) ∈ envelope_598_i3 := by decide +kernel +theorem children_work_598_i3 : ∀ j, Template HasSnaky 7 (childrenC_598_i3 j) (childrenD_598_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 4)).mono (by decide +kernel) + · exact row_works_598_i4.mono (by decide +kernel) +theorem row_works_598_i3 : Template HasSnaky 8 required_598_i3 envelope_598_i3 := by + refine compose HasSnaky 7 childrenC_598_i3 childrenD_598_i3 children_work_598_i3 (3, 6) + required_598_i3 envelope_598_i3 pivot_mem_598_i3 child_required_sub_598_i3 child_envelope_sub_598_i3 ?_ + intro b hb + exact common_sub_598_i3 (mem_commonEnvelope childrenD_598_i3 b hb) +def required_598_i8 : Finset Cell := ⟨(([(3, 4), (3, 5), (3, 6), (4, 4), (4, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_598_i8 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_598_i8 : Fin 2 → Finset Cell := ![(placed21 2 (6, 5) required_5), (placed21 3 (2, 6) required_413)] +def childrenD_598_i8 : Fin 2 → Finset Cell := ![(placed21 2 (6, 5) envelope_5), (placed21 3 (2, 6) envelope_413)] +theorem common_sub_598_i8 : commonEnvelope childrenD_598_i8 ⊆ insert (5, 5) required_598_i8 := by decide +kernel +theorem child_required_sub_598_i8 : ∀ j, childrenC_598_i8 j ⊆ insert (5, 5) required_598_i8 := by decide +kernel +theorem child_envelope_sub_598_i8 : ∀ j, childrenD_598_i8 j ⊆ envelope_598_i8 := by decide +kernel +theorem pivot_mem_598_i8 : (5, 5) ∈ envelope_598_i8 := by decide +kernel +theorem children_work_598_i8 : ∀ j, Template HasSnaky 5 (childrenC_598_i8 j) (childrenD_598_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 2 (6, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_413 3 (2, 6)).mono (by decide +kernel) +theorem row_works_598_i8 : Template HasSnaky 6 required_598_i8 envelope_598_i8 := by + refine compose HasSnaky 5 childrenC_598_i8 childrenD_598_i8 children_work_598_i8 (5, 5) + required_598_i8 envelope_598_i8 pivot_mem_598_i8 child_required_sub_598_i8 child_envelope_sub_598_i8 ?_ + intro b hb + exact common_sub_598_i8 (mem_commonEnvelope childrenD_598_i8 b hb) +def required_598_i7 : Finset Cell := ⟨(([(3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_598_i7 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_598_i7 : Fin 2 → Finset Cell := ![(placed21 3 (3, 8) required_0), required_598_i8] +def childrenD_598_i7 : Fin 2 → Finset Cell := ![(placed21 3 (3, 8) envelope_0), envelope_598_i8] +theorem common_sub_598_i7 : commonEnvelope childrenD_598_i7 ⊆ insert (4, 5) required_598_i7 := by decide +kernel +theorem child_required_sub_598_i7 : ∀ j, childrenC_598_i7 j ⊆ insert (4, 5) required_598_i7 := by decide +kernel +theorem child_envelope_sub_598_i7 : ∀ j, childrenD_598_i7 j ⊆ envelope_598_i7 := by decide +kernel +theorem pivot_mem_598_i7 : (4, 5) ∈ envelope_598_i7 := by decide +kernel +theorem children_work_598_i7 : ∀ j, Template HasSnaky 6 (childrenC_598_i7 j) (childrenD_598_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (3, 8)).mono (by decide +kernel) + · exact row_works_598_i8.mono (by decide +kernel) +theorem row_works_598_i7 : Template HasSnaky 7 required_598_i7 envelope_598_i7 := by + refine compose HasSnaky 6 childrenC_598_i7 childrenD_598_i7 children_work_598_i7 (4, 5) + required_598_i7 envelope_598_i7 pivot_mem_598_i7 child_required_sub_598_i7 child_envelope_sub_598_i7 ?_ + intro b hb + exact common_sub_598_i7 (mem_commonEnvelope childrenD_598_i7 b hb) +def required_598_i6 : Finset Cell := ⟨(([(3, 4), (3, 5), (3, 7), (4, 4), (4, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_598_i6 : Finset Cell := ⟨(([(2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 7), (4, 8), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_598_i6 : Fin 2 → Finset Cell := ![(placed21 1 (3, 4) required_5), required_598_i7] +def childrenD_598_i6 : Fin 2 → Finset Cell := ![(placed21 1 (3, 4) envelope_5), envelope_598_i7] +theorem common_sub_598_i6 : commonEnvelope childrenD_598_i6 ⊆ insert (3, 6) required_598_i6 := by decide +kernel +theorem child_required_sub_598_i6 : ∀ j, childrenC_598_i6 j ⊆ insert (3, 6) required_598_i6 := by decide +kernel +theorem child_envelope_sub_598_i6 : ∀ j, childrenD_598_i6 j ⊆ envelope_598_i6 := by decide +kernel +theorem pivot_mem_598_i6 : (3, 6) ∈ envelope_598_i6 := by decide +kernel +theorem children_work_598_i6 : ∀ j, Template HasSnaky 7 (childrenC_598_i6 j) (childrenD_598_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 4)).mono (by decide +kernel) + · exact row_works_598_i7.mono (by decide +kernel) +theorem row_works_598_i6 : Template HasSnaky 8 required_598_i6 envelope_598_i6 := by + refine compose HasSnaky 7 childrenC_598_i6 childrenD_598_i6 children_work_598_i6 (3, 6) + required_598_i6 envelope_598_i6 pivot_mem_598_i6 child_required_sub_598_i6 child_envelope_sub_598_i6 ?_ + intro b hb + exact common_sub_598_i6 (mem_commonEnvelope childrenD_598_i6 b hb) +def required_598 : Finset Cell := ⟨(([(3, 4), (3, 7), (4, 4), (4, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_598 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 9), (2, 1), (2, 2), (2, 3), (2, 5), (2, 6), (2, 8), (2, 9), (2, 10), (2, 11), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 2), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 9), (10, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_598 : Fin 7 → Finset Cell := ![required_598_i0, required_598_i3, (placed21 1 (2, 4) required_584), (placed21 4 (2, 10) required_591), (placed21 2 (8, 1) required_594), required_598_i6, (placed21 0 (1, 2) required_597)] +def childrenD_598 : Fin 7 → Finset Cell := ![envelope_598_i0, envelope_598_i3, (placed21 1 (2, 4) envelope_584), (placed21 4 (2, 10) envelope_591), (placed21 2 (8, 1) envelope_594), envelope_598_i6, (placed21 0 (1, 2) envelope_597)] +theorem common_sub_598 : commonEnvelope childrenD_598 ⊆ insert (3, 5) required_598 := by decide +kernel +theorem child_required_sub_598 : ∀ j, childrenC_598 j ⊆ insert (3, 5) required_598 := by decide +kernel +theorem child_envelope_sub_598 : ∀ j, childrenD_598 j ⊆ envelope_598 := by decide +kernel +theorem pivot_mem_598 : (3, 5) ∈ envelope_598 := by decide +kernel +theorem children_work_598 : ∀ j, Template HasSnaky 13 (childrenC_598 j) (childrenD_598 j) := by + intro j + fin_cases j + · exact row_works_598_i0.mono (by decide +kernel) + · exact row_works_598_i3.mono (by decide +kernel) + · exact (placed21_template row_works_584 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_591 4 (2, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_594 2 (8, 1)).mono (by decide +kernel) + · exact row_works_598_i6.mono (by decide +kernel) + · exact (placed21_template row_works_597 0 (1, 2)).mono (by decide +kernel) +theorem row_works_598 : Template HasSnaky 14 required_598 envelope_598 := by + refine compose HasSnaky 13 childrenC_598 childrenD_598 children_work_598 (3, 5) + required_598 envelope_598 pivot_mem_598 child_required_sub_598 child_envelope_sub_598 ?_ + intro b hb + exact common_sub_598 (mem_commonEnvelope childrenD_598 b hb) +def required_636_i1 : Finset Cell := ⟨(([(1, 5), (3, 4), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_636_i1 : Finset Cell := ⟨(([(0, 5), (1, 5), (2, 3), (2, 5), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_636_i1 : Fin 3 → Finset Cell := ![(placed21 7 (5, 5) required_22), (placed21 6 (5, 7) required_108), (placed21 0 (2, 1) required_512)] +def childrenD_636_i1 : Fin 3 → Finset Cell := ![(placed21 7 (5, 5) envelope_22), (placed21 6 (5, 7) envelope_108), (placed21 0 (2, 1) envelope_512)] +theorem common_sub_636_i1 : commonEnvelope childrenD_636_i1 ⊆ insert (3, 5) required_636_i1 := by decide +kernel +theorem child_required_sub_636_i1 : ∀ j, childrenC_636_i1 j ⊆ insert (3, 5) required_636_i1 := by decide +kernel +theorem child_envelope_sub_636_i1 : ∀ j, childrenD_636_i1 j ⊆ envelope_636_i1 := by decide +kernel +theorem pivot_mem_636_i1 : (3, 5) ∈ envelope_636_i1 := by decide +kernel +theorem children_work_636_i1 : ∀ j, Template HasSnaky 9 (childrenC_636_i1 j) (childrenD_636_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 7 (5, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_108 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_512 0 (2, 1)).mono (by decide +kernel) +theorem row_works_636_i1 : Template HasSnaky 10 required_636_i1 envelope_636_i1 := by + refine compose HasSnaky 9 childrenC_636_i1 childrenD_636_i1 children_work_636_i1 (3, 5) + required_636_i1 envelope_636_i1 pivot_mem_636_i1 child_required_sub_636_i1 child_envelope_sub_636_i1 ?_ + intro b hb + exact common_sub_636_i1 (mem_commonEnvelope childrenD_636_i1 b hb) +def required_636_i2 : Finset Cell := ⟨(([(3, 4), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_636_i2 : Finset Cell := ⟨(([(1, 5), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 5), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_636_i2 : Fin 4 → Finset Cell := ![(placed21 0 (3, 3) required_10), (placed21 6 (4, 7) required_44), (placed21 0 (3, 3) required_63), (placed21 3 (1, 7) required_117)] +def childrenD_636_i2 : Fin 4 → Finset Cell := ![(placed21 0 (3, 3) envelope_10), (placed21 6 (4, 7) envelope_44), (placed21 0 (3, 3) envelope_63), (placed21 3 (1, 7) envelope_117)] +theorem common_sub_636_i2 : commonEnvelope childrenD_636_i2 ⊆ insert (4, 6) required_636_i2 := by decide +kernel +theorem child_required_sub_636_i2 : ∀ j, childrenC_636_i2 j ⊆ insert (4, 6) required_636_i2 := by decide +kernel +theorem child_envelope_sub_636_i2 : ∀ j, childrenD_636_i2 j ⊆ envelope_636_i2 := by decide +kernel +theorem pivot_mem_636_i2 : (4, 6) ∈ envelope_636_i2 := by decide +kernel +theorem children_work_636_i2 : ∀ j, Template HasSnaky 7 (childrenC_636_i2 j) (childrenD_636_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_44 6 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_63 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_117 3 (1, 7)).mono (by decide +kernel) +theorem row_works_636_i2 : Template HasSnaky 8 required_636_i2 envelope_636_i2 := by + refine compose HasSnaky 7 childrenC_636_i2 childrenD_636_i2 children_work_636_i2 (4, 6) + required_636_i2 envelope_636_i2 pivot_mem_636_i2 child_required_sub_636_i2 child_envelope_sub_636_i2 ?_ + intro b hb + exact common_sub_636_i2 (mem_commonEnvelope childrenD_636_i2 b hb) +def required_636_i5 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 4), (4, 5), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_636_i5 : Finset Cell := ⟨(([(2, 6), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 5), (7, 6), (8, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_636_i5 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) required_85), (placed21 0 (3, 2) required_164), (placed21 4 (2, 7) required_262)] +def childrenD_636_i5 : Fin 3 → Finset Cell := ![(placed21 0 (3, 1) envelope_85), (placed21 0 (3, 2) envelope_164), (placed21 4 (2, 7) envelope_262)] +theorem common_sub_636_i5 : commonEnvelope childrenD_636_i5 ⊆ insert (5, 5) required_636_i5 := by decide +kernel +theorem child_required_sub_636_i5 : ∀ j, childrenC_636_i5 j ⊆ insert (5, 5) required_636_i5 := by decide +kernel +theorem child_envelope_sub_636_i5 : ∀ j, childrenD_636_i5 j ⊆ envelope_636_i5 := by decide +kernel +theorem pivot_mem_636_i5 : (5, 5) ∈ envelope_636_i5 := by decide +kernel +theorem children_work_636_i5 : ∀ j, Template HasSnaky 6 (childrenC_636_i5 j) (childrenD_636_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_85 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_164 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_262 4 (2, 7)).mono (by decide +kernel) +theorem row_works_636_i5 : Template HasSnaky 7 required_636_i5 envelope_636_i5 := by + refine compose HasSnaky 6 childrenC_636_i5 childrenD_636_i5 children_work_636_i5 (5, 5) + required_636_i5 envelope_636_i5 pivot_mem_636_i5 child_required_sub_636_i5 child_envelope_sub_636_i5 ?_ + intro b hb + exact common_sub_636_i5 (mem_commonEnvelope childrenD_636_i5 b hb) +def required_636_i4 : Finset Cell := ⟨(([(1, 5), (3, 4), (4, 4), (4, 5), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_636_i4 : Finset Cell := ⟨(([(1, 5), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 5), (7, 6), (8, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_636_i4 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) required_1), required_636_i5] +def childrenD_636_i4 : Fin 2 → Finset Cell := ![(placed21 4 (1, 5) envelope_1), envelope_636_i5] +theorem common_sub_636_i4 : commonEnvelope childrenD_636_i4 ⊆ insert (3, 5) required_636_i4 := by decide +kernel +theorem child_required_sub_636_i4 : ∀ j, childrenC_636_i4 j ⊆ insert (3, 5) required_636_i4 := by decide +kernel +theorem child_envelope_sub_636_i4 : ∀ j, childrenD_636_i4 j ⊆ envelope_636_i4 := by decide +kernel +theorem pivot_mem_636_i4 : (3, 5) ∈ envelope_636_i4 := by decide +kernel +theorem children_work_636_i4 : ∀ j, Template HasSnaky 7 (childrenC_636_i4 j) (childrenD_636_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 4 (1, 5)).mono (by decide +kernel) + · exact row_works_636_i5.mono (by decide +kernel) +theorem row_works_636_i4 : Template HasSnaky 8 required_636_i4 envelope_636_i4 := by + refine compose HasSnaky 7 childrenC_636_i4 childrenD_636_i4 children_work_636_i4 (3, 5) + required_636_i4 envelope_636_i4 pivot_mem_636_i4 child_required_sub_636_i4 child_envelope_sub_636_i4 ?_ + intro b hb + exact common_sub_636_i4 (mem_commonEnvelope childrenD_636_i4 b hb) +def required_636_i6 : Finset Cell := ⟨(([(3, 4), (4, 4), (4, 5), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_636_i6 : Finset Cell := ⟨(([(2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 4), (6, 3), (6, 4), (7, 3), (7, 4), (8, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_636_i6 : Fin 3 → Finset Cell := ![(placed21 3 (2, 4) required_7), (placed21 1 (2, 4) required_11), (placed21 2 (6, 1) required_331)] +def childrenD_636_i6 : Fin 3 → Finset Cell := ![(placed21 3 (2, 4) envelope_7), (placed21 1 (2, 4) envelope_11), (placed21 2 (6, 1) envelope_331)] +theorem common_sub_636_i6 : commonEnvelope childrenD_636_i6 ⊆ insert (6, 4) required_636_i6 := by decide +kernel +theorem child_required_sub_636_i6 : ∀ j, childrenC_636_i6 j ⊆ insert (6, 4) required_636_i6 := by decide +kernel +theorem child_envelope_sub_636_i6 : ∀ j, childrenD_636_i6 j ⊆ envelope_636_i6 := by decide +kernel +theorem pivot_mem_636_i6 : (6, 4) ∈ envelope_636_i6 := by decide +kernel +theorem children_work_636_i6 : ∀ j, Template HasSnaky 6 (childrenC_636_i6 j) (childrenD_636_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 3 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_11 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_331 2 (6, 1)).mono (by decide +kernel) +theorem row_works_636_i6 : Template HasSnaky 7 required_636_i6 envelope_636_i6 := by + refine compose HasSnaky 6 childrenC_636_i6 childrenD_636_i6 children_work_636_i6 (6, 4) + required_636_i6 envelope_636_i6 pivot_mem_636_i6 child_required_sub_636_i6 child_envelope_sub_636_i6 ?_ + intro b hb + exact common_sub_636_i6 (mem_commonEnvelope childrenD_636_i6 b hb) +def required_636_i3 : Finset Cell := ⟨(([(1, 5), (3, 4), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_636_i3 : Finset Cell := ⟨(([(1, 5), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 3), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_636_i3 : Fin 5 → Finset Cell := ![(placed21 0 (2, 1) required_332), (placed21 4 (2, 6) required_474), (placed21 0 (2, 2) required_522), required_636_i4, required_636_i6] +def childrenD_636_i3 : Fin 5 → Finset Cell := ![(placed21 0 (2, 1) envelope_332), (placed21 4 (2, 6) envelope_474), (placed21 0 (2, 2) envelope_522), envelope_636_i4, envelope_636_i6] +theorem common_sub_636_i3 : commonEnvelope childrenD_636_i3 ⊆ insert (5, 4) required_636_i3 := by decide +kernel +theorem child_required_sub_636_i3 : ∀ j, childrenC_636_i3 j ⊆ insert (5, 4) required_636_i3 := by decide +kernel +theorem child_envelope_sub_636_i3 : ∀ j, childrenD_636_i3 j ⊆ envelope_636_i3 := by decide +kernel +theorem pivot_mem_636_i3 : (5, 4) ∈ envelope_636_i3 := by decide +kernel +theorem children_work_636_i3 : ∀ j, Template HasSnaky 9 (childrenC_636_i3 j) (childrenD_636_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_332 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_474 4 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_522 0 (2, 2)).mono (by decide +kernel) + · exact row_works_636_i4.mono (by decide +kernel) + · exact row_works_636_i6.mono (by decide +kernel) +theorem row_works_636_i3 : Template HasSnaky 10 required_636_i3 envelope_636_i3 := by + refine compose HasSnaky 9 childrenC_636_i3 childrenD_636_i3 children_work_636_i3 (5, 4) + required_636_i3 envelope_636_i3 pivot_mem_636_i3 child_required_sub_636_i3 child_envelope_sub_636_i3 ?_ + intro b hb + exact common_sub_636_i3 (mem_commonEnvelope childrenD_636_i3 b hb) +def required_636_i0 : Finset Cell := ⟨(([(1, 5), (3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_636_i0 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 7), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_636_i0 : Fin 9 → Finset Cell := ![(placed21 4 (2, 8) required_399), (placed21 0 (3, 1) required_408), (placed21 4 (2, 8) required_475), (placed21 1 (1, 2) required_509), (placed21 0 (2, 1) required_587), required_636_i1, (placed21 4 (2, 9) required_635), required_636_i2, required_636_i3] +def childrenD_636_i0 : Fin 9 → Finset Cell := ![(placed21 4 (2, 8) envelope_399), (placed21 0 (3, 1) envelope_408), (placed21 4 (2, 8) envelope_475), (placed21 1 (1, 2) envelope_509), (placed21 0 (2, 1) envelope_587), envelope_636_i1, (placed21 4 (2, 9) envelope_635), envelope_636_i2, envelope_636_i3] +theorem common_sub_636_i0 : commonEnvelope childrenD_636_i0 ⊆ insert (4, 5) required_636_i0 := by decide +kernel +theorem child_required_sub_636_i0 : ∀ j, childrenC_636_i0 j ⊆ insert (4, 5) required_636_i0 := by decide +kernel +theorem child_envelope_sub_636_i0 : ∀ j, childrenD_636_i0 j ⊆ envelope_636_i0 := by decide +kernel +theorem pivot_mem_636_i0 : (4, 5) ∈ envelope_636_i0 := by decide +kernel +theorem children_work_636_i0 : ∀ j, Template HasSnaky 12 (childrenC_636_i0 j) (childrenD_636_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_399 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_408 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_475 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_509 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_587 0 (2, 1)).mono (by decide +kernel) + · exact row_works_636_i1.mono (by decide +kernel) + · exact (placed21_template row_works_635 4 (2, 9)).mono (by decide +kernel) + · exact row_works_636_i2.mono (by decide +kernel) + · exact row_works_636_i3.mono (by decide +kernel) +theorem row_works_636_i0 : Template HasSnaky 13 required_636_i0 envelope_636_i0 := by + refine compose HasSnaky 12 childrenC_636_i0 childrenD_636_i0 children_work_636_i0 (4, 5) + required_636_i0 envelope_636_i0 pivot_mem_636_i0 child_required_sub_636_i0 child_envelope_sub_636_i0 ?_ + intro b hb + exact common_sub_636_i0 (mem_commonEnvelope childrenD_636_i0 b hb) +def required_636_i7 : Finset Cell := ⟨(([(3, 4), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_636_i7 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 3), (8, 4), (8, 5), (8, 6), (9, 3), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_636_i7 : Fin 6 → Finset Cell := ![(placed21 0 (2, 1) required_118), (placed21 1 (1, 2) required_188), (placed21 3 (1, 6) required_188), (placed21 1 (1, 3) required_192), (placed21 1 (1, 3) required_193), (placed21 5 (8, 2) required_396)] +def childrenD_636_i7 : Fin 6 → Finset Cell := ![(placed21 0 (2, 1) envelope_118), (placed21 1 (1, 2) envelope_188), (placed21 3 (1, 6) envelope_188), (placed21 1 (1, 3) envelope_192), (placed21 1 (1, 3) envelope_193), (placed21 5 (8, 2) envelope_396)] +theorem common_sub_636_i7 : commonEnvelope childrenD_636_i7 ⊆ insert (5, 4) required_636_i7 := by decide +kernel +theorem child_required_sub_636_i7 : ∀ j, childrenC_636_i7 j ⊆ insert (5, 4) required_636_i7 := by decide +kernel +theorem child_envelope_sub_636_i7 : ∀ j, childrenD_636_i7 j ⊆ envelope_636_i7 := by decide +kernel +theorem pivot_mem_636_i7 : (5, 4) ∈ envelope_636_i7 := by decide +kernel +theorem children_work_636_i7 : ∀ j, Template HasSnaky 9 (childrenC_636_i7 j) (childrenD_636_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_118 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_188 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_188 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_192 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_193 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_396 5 (8, 2)).mono (by decide +kernel) +theorem row_works_636_i7 : Template HasSnaky 10 required_636_i7 envelope_636_i7 := by + refine compose HasSnaky 9 childrenC_636_i7 childrenD_636_i7 children_work_636_i7 (5, 4) + required_636_i7 envelope_636_i7 pivot_mem_636_i7 child_required_sub_636_i7 child_envelope_sub_636_i7 ?_ + intro b hb + exact common_sub_636_i7 (mem_commonEnvelope childrenD_636_i7 b hb) +def required_636 : Finset Cell := ⟨(([(1, 4), (1, 5), (4, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_636 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 4), (1, 5), (1, 7), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (9, 3), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_636 : Fin 4 → Finset Cell := ![(placed21 3 (0, 5) required_125), (placed21 5 (5, 3) required_454), required_636_i0, required_636_i7] +def childrenD_636 : Fin 4 → Finset Cell := ![(placed21 3 (0, 5) envelope_125), (placed21 5 (5, 3) envelope_454), envelope_636_i0, envelope_636_i7] +theorem common_sub_636 : commonEnvelope childrenD_636 ⊆ insert (3, 4) required_636 := by decide +kernel +theorem child_required_sub_636 : ∀ j, childrenC_636 j ⊆ insert (3, 4) required_636 := by decide +kernel +theorem child_envelope_sub_636 : ∀ j, childrenD_636 j ⊆ envelope_636 := by decide +kernel +theorem pivot_mem_636 : (3, 4) ∈ envelope_636 := by decide +kernel +theorem children_work_636 : ∀ j, Template HasSnaky 13 (childrenC_636 j) (childrenD_636 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_125 3 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_454 5 (5, 3)).mono (by decide +kernel) + · exact row_works_636_i0.mono (by decide +kernel) + · exact row_works_636_i7.mono (by decide +kernel) +theorem row_works_636 : Template HasSnaky 14 required_636 envelope_636 := by + refine compose HasSnaky 13 childrenC_636 childrenD_636 children_work_636 (3, 4) + required_636 envelope_636 pivot_mem_636 child_required_sub_636 child_envelope_sub_636 ?_ + intro b hb + exact common_sub_636 (mem_commonEnvelope childrenD_636 b hb) +def required_644_i1 : Finset Cell := ⟨(([(4, 4), (4, 5), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_644_i1 : Finset Cell := ⟨(([(1, 4), (1, 6), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 4), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 6), (9, 1), (9, 2), (9, 3), (9, 6), (10, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_644_i1 : Fin 3 → Finset Cell := ![(placed21 5 (7, 4) required_10), (placed21 0 (3, 1) required_317), (placed21 4 (2, 8) required_640)] +def childrenD_644_i1 : Fin 3 → Finset Cell := ![(placed21 5 (7, 4) envelope_10), (placed21 0 (3, 1) envelope_317), (placed21 4 (2, 8) envelope_640)] +theorem common_sub_644_i1 : commonEnvelope childrenD_644_i1 ⊆ insert (5, 5) required_644_i1 := by decide +kernel +theorem child_required_sub_644_i1 : ∀ j, childrenC_644_i1 j ⊆ insert (5, 5) required_644_i1 := by decide +kernel +theorem child_envelope_sub_644_i1 : ∀ j, childrenD_644_i1 j ⊆ envelope_644_i1 := by decide +kernel +theorem pivot_mem_644_i1 : (5, 5) ∈ envelope_644_i1 := by decide +kernel +theorem children_work_644_i1 : ∀ j, Template HasSnaky 9 (childrenC_644_i1 j) (childrenD_644_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_317 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_640 4 (2, 8)).mono (by decide +kernel) +theorem row_works_644_i1 : Template HasSnaky 10 required_644_i1 envelope_644_i1 := by + refine compose HasSnaky 9 childrenC_644_i1 childrenD_644_i1 children_work_644_i1 (5, 5) + required_644_i1 envelope_644_i1 pivot_mem_644_i1 child_required_sub_644_i1 child_envelope_sub_644_i1 ?_ + intro b hb + exact common_sub_644_i1 (mem_commonEnvelope childrenD_644_i1 b hb) +def required_644_i0 : Finset Cell := ⟨(([(4, 4), (4, 5), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_644_i0 : Finset Cell := ⟨(([(1, 4), (1, 6), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 1)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_644_i0 : Fin 6 → Finset Cell := ![(placed21 1 (1, 4) required_104), (placed21 1 (1, 4) required_359), (placed21 0 (1, 1) required_452), (placed21 4 (3, 8) required_476), (placed21 0 (3, 1) required_479), required_644_i1] +def childrenD_644_i0 : Fin 6 → Finset Cell := ![(placed21 1 (1, 4) envelope_104), (placed21 1 (1, 4) envelope_359), (placed21 0 (1, 1) envelope_452), (placed21 4 (3, 8) envelope_476), (placed21 0 (3, 1) envelope_479), envelope_644_i1] +theorem common_sub_644_i0 : commonEnvelope childrenD_644_i0 ⊆ insert (6, 5) required_644_i0 := by decide +kernel +theorem child_required_sub_644_i0 : ∀ j, childrenC_644_i0 j ⊆ insert (6, 5) required_644_i0 := by decide +kernel +theorem child_envelope_sub_644_i0 : ∀ j, childrenD_644_i0 j ⊆ envelope_644_i0 := by decide +kernel +theorem pivot_mem_644_i0 : (6, 5) ∈ envelope_644_i0 := by decide +kernel +theorem children_work_644_i0 : ∀ j, Template HasSnaky 10 (childrenC_644_i0 j) (childrenD_644_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_104 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_359 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_452 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_476 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_479 0 (3, 1)).mono (by decide +kernel) + · exact row_works_644_i1.mono (by decide +kernel) +theorem row_works_644_i0 : Template HasSnaky 11 required_644_i0 envelope_644_i0 := by + refine compose HasSnaky 10 childrenC_644_i0 childrenD_644_i0 children_work_644_i0 (6, 5) + required_644_i0 envelope_644_i0 pivot_mem_644_i0 child_required_sub_644_i0 child_envelope_sub_644_i0 ?_ + intro b hb + exact common_sub_644_i0 (mem_commonEnvelope childrenD_644_i0 b hb) +def required_644 : Finset Cell := ⟨(([(4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_644 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 1), (10, 3), (10, 4), (10, 5), (11, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_644 : Fin 9 → Finset Cell := ![(placed21 6 (7, 7) required_120), (placed21 3 (1, 6) required_338), (placed21 3 (1, 7) required_437), (placed21 3 (0, 6) required_611), (placed21 1 (1, 3) required_613), (placed21 0 (1, 0) required_634), required_644_i0, (placed21 0 (3, 0) required_642), (placed21 0 (3, 0) required_643)] +def childrenD_644 : Fin 9 → Finset Cell := ![(placed21 6 (7, 7) envelope_120), (placed21 3 (1, 6) envelope_338), (placed21 3 (1, 7) envelope_437), (placed21 3 (0, 6) envelope_611), (placed21 1 (1, 3) envelope_613), (placed21 0 (1, 0) envelope_634), envelope_644_i0, (placed21 0 (3, 0) envelope_642), (placed21 0 (3, 0) envelope_643)] +theorem common_sub_644 : commonEnvelope childrenD_644 ⊆ insert (6, 4) required_644 := by decide +kernel +theorem child_required_sub_644 : ∀ j, childrenC_644 j ⊆ insert (6, 4) required_644 := by decide +kernel +theorem child_envelope_sub_644 : ∀ j, childrenD_644 j ⊆ envelope_644 := by decide +kernel +theorem pivot_mem_644 : (6, 4) ∈ envelope_644 := by decide +kernel +theorem children_work_644 : ∀ j, Template HasSnaky 13 (childrenC_644 j) (childrenD_644 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_120 6 (7, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_338 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_437 3 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_611 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_613 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_634 0 (1, 0)).mono (by decide +kernel) + · exact row_works_644_i0.mono (by decide +kernel) + · exact (placed21_template row_works_642 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_643 0 (3, 0)).mono (by decide +kernel) +theorem row_works_644 : Template HasSnaky 14 required_644 envelope_644 := by + refine compose HasSnaky 13 childrenC_644 childrenD_644 children_work_644 (6, 4) + required_644 envelope_644 pivot_mem_644 child_required_sub_644 child_envelope_sub_644 ?_ + intro b hb + exact common_sub_644 (mem_commonEnvelope childrenD_644 b hb) +def height_598_i2 : ℕ := 6 +def childrenH_598_i2 : Fin 2 → ℕ := ![height_5, height_133] +theorem height_exact_598_i2 : height_598_i2 = 1 + Finset.univ.sup childrenH_598_i2 := by decide +kernel +theorem required_origin_598_i2 : ∀ x ∈ required_598_i2, + (∃ j, x ∈ childrenC_598_i2 j) ∨ ∀ j, x ∈ childrenD_598_i2 j := by decide +kernel +theorem required_exact_598_i2 : required_598_i2 = + ((Finset.univ.biUnion childrenC_598_i2) ∪ commonEnvelope childrenD_598_i2).erase (5, 5) := by + exact required_eq_combination childrenC_598_i2 childrenD_598_i2 (5, 5) required_598_i2 + (by decide +kernel) child_required_sub_598_i2 common_sub_598_i2 required_origin_598_i2 +theorem envelope_origin_598_i2 : ∀ x ∈ envelope_598_i2, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_598_i2 j := by decide +kernel +theorem envelope_exact_598_i2 : envelope_598_i2 = + insert (5, 5) (Finset.univ.biUnion childrenD_598_i2) := by + exact envelope_eq_combination childrenD_598_i2 (5, 5) envelope_598_i2 + pivot_mem_598_i2 child_envelope_sub_598_i2 envelope_origin_598_i2 +def checked_598_i2 : CheckedCard where + required := required_598_i2 + envelope := envelope_598_i2 + height := height_598_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_598_i2 +def height_598_i1 : ℕ := 7 +def childrenH_598_i1 : Fin 2 → ℕ := ![height_0, height_598_i2] +theorem height_exact_598_i1 : height_598_i1 = 1 + Finset.univ.sup childrenH_598_i1 := by decide +kernel +theorem required_origin_598_i1 : ∀ x ∈ required_598_i1, + (∃ j, x ∈ childrenC_598_i1 j) ∨ ∀ j, x ∈ childrenD_598_i1 j := by decide +kernel +theorem required_exact_598_i1 : required_598_i1 = + ((Finset.univ.biUnion childrenC_598_i1) ∪ commonEnvelope childrenD_598_i1).erase (4, 5) := by + exact required_eq_combination childrenC_598_i1 childrenD_598_i1 (4, 5) required_598_i1 + (by decide +kernel) child_required_sub_598_i1 common_sub_598_i1 required_origin_598_i1 +theorem envelope_origin_598_i1 : ∀ x ∈ envelope_598_i1, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_598_i1 j := by decide +kernel +theorem envelope_exact_598_i1 : envelope_598_i1 = + insert (4, 5) (Finset.univ.biUnion childrenD_598_i1) := by + exact envelope_eq_combination childrenD_598_i1 (4, 5) envelope_598_i1 + pivot_mem_598_i1 child_envelope_sub_598_i1 envelope_origin_598_i1 +def checked_598_i1 : CheckedCard where + required := required_598_i1 + envelope := envelope_598_i1 + height := height_598_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_598_i1 +def height_598_i0 : ℕ := 8 +def childrenH_598_i0 : Fin 2 → ℕ := ![height_5, height_598_i1] +theorem height_exact_598_i0 : height_598_i0 = 1 + Finset.univ.sup childrenH_598_i0 := by decide +kernel +theorem required_origin_598_i0 : ∀ x ∈ required_598_i0, + (∃ j, x ∈ childrenC_598_i0 j) ∨ ∀ j, x ∈ childrenD_598_i0 j := by decide +kernel +theorem required_exact_598_i0 : required_598_i0 = + ((Finset.univ.biUnion childrenC_598_i0) ∪ commonEnvelope childrenD_598_i0).erase (3, 6) := by + exact required_eq_combination childrenC_598_i0 childrenD_598_i0 (3, 6) required_598_i0 + (by decide +kernel) child_required_sub_598_i0 common_sub_598_i0 required_origin_598_i0 +theorem envelope_origin_598_i0 : ∀ x ∈ envelope_598_i0, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_598_i0 j := by decide +kernel +theorem envelope_exact_598_i0 : envelope_598_i0 = + insert (3, 6) (Finset.univ.biUnion childrenD_598_i0) := by + exact envelope_eq_combination childrenD_598_i0 (3, 6) envelope_598_i0 + pivot_mem_598_i0 child_envelope_sub_598_i0 envelope_origin_598_i0 +def checked_598_i0 : CheckedCard where + required := required_598_i0 + envelope := envelope_598_i0 + height := height_598_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_598_i0 +def height_598_i5 : ℕ := 6 +def childrenH_598_i5 : Fin 2 → ℕ := ![height_5, height_133] +theorem height_exact_598_i5 : height_598_i5 = 1 + Finset.univ.sup childrenH_598_i5 := by decide +kernel +theorem required_origin_598_i5 : ∀ x ∈ required_598_i5, + (∃ j, x ∈ childrenC_598_i5 j) ∨ ∀ j, x ∈ childrenD_598_i5 j := by decide +kernel +theorem required_exact_598_i5 : required_598_i5 = + ((Finset.univ.biUnion childrenC_598_i5) ∪ commonEnvelope childrenD_598_i5).erase (5, 5) := by + exact required_eq_combination childrenC_598_i5 childrenD_598_i5 (5, 5) required_598_i5 + (by decide +kernel) child_required_sub_598_i5 common_sub_598_i5 required_origin_598_i5 +theorem envelope_origin_598_i5 : ∀ x ∈ envelope_598_i5, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_598_i5 j := by decide +kernel +theorem envelope_exact_598_i5 : envelope_598_i5 = + insert (5, 5) (Finset.univ.biUnion childrenD_598_i5) := by + exact envelope_eq_combination childrenD_598_i5 (5, 5) envelope_598_i5 + pivot_mem_598_i5 child_envelope_sub_598_i5 envelope_origin_598_i5 +def checked_598_i5 : CheckedCard where + required := required_598_i5 + envelope := envelope_598_i5 + height := height_598_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_598_i5 +def height_598_i4 : ℕ := 7 +def childrenH_598_i4 : Fin 2 → ℕ := ![height_0, height_598_i5] +theorem height_exact_598_i4 : height_598_i4 = 1 + Finset.univ.sup childrenH_598_i4 := by decide +kernel +theorem required_origin_598_i4 : ∀ x ∈ required_598_i4, + (∃ j, x ∈ childrenC_598_i4 j) ∨ ∀ j, x ∈ childrenD_598_i4 j := by decide +kernel +theorem required_exact_598_i4 : required_598_i4 = + ((Finset.univ.biUnion childrenC_598_i4) ∪ commonEnvelope childrenD_598_i4).erase (4, 5) := by + exact required_eq_combination childrenC_598_i4 childrenD_598_i4 (4, 5) required_598_i4 + (by decide +kernel) child_required_sub_598_i4 common_sub_598_i4 required_origin_598_i4 +theorem envelope_origin_598_i4 : ∀ x ∈ envelope_598_i4, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_598_i4 j := by decide +kernel +theorem envelope_exact_598_i4 : envelope_598_i4 = + insert (4, 5) (Finset.univ.biUnion childrenD_598_i4) := by + exact envelope_eq_combination childrenD_598_i4 (4, 5) envelope_598_i4 + pivot_mem_598_i4 child_envelope_sub_598_i4 envelope_origin_598_i4 +def checked_598_i4 : CheckedCard where + required := required_598_i4 + envelope := envelope_598_i4 + height := height_598_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_598_i4 +def height_598_i3 : ℕ := 8 +def childrenH_598_i3 : Fin 2 → ℕ := ![height_5, height_598_i4] +theorem height_exact_598_i3 : height_598_i3 = 1 + Finset.univ.sup childrenH_598_i3 := by decide +kernel +theorem required_origin_598_i3 : ∀ x ∈ required_598_i3, + (∃ j, x ∈ childrenC_598_i3 j) ∨ ∀ j, x ∈ childrenD_598_i3 j := by decide +kernel +theorem required_exact_598_i3 : required_598_i3 = + ((Finset.univ.biUnion childrenC_598_i3) ∪ commonEnvelope childrenD_598_i3).erase (3, 6) := by + exact required_eq_combination childrenC_598_i3 childrenD_598_i3 (3, 6) required_598_i3 + (by decide +kernel) child_required_sub_598_i3 common_sub_598_i3 required_origin_598_i3 +theorem envelope_origin_598_i3 : ∀ x ∈ envelope_598_i3, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_598_i3 j := by decide +kernel +theorem envelope_exact_598_i3 : envelope_598_i3 = + insert (3, 6) (Finset.univ.biUnion childrenD_598_i3) := by + exact envelope_eq_combination childrenD_598_i3 (3, 6) envelope_598_i3 + pivot_mem_598_i3 child_envelope_sub_598_i3 envelope_origin_598_i3 +def checked_598_i3 : CheckedCard where + required := required_598_i3 + envelope := envelope_598_i3 + height := height_598_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_598_i3 +def height_598_i8 : ℕ := 6 +def childrenH_598_i8 : Fin 2 → ℕ := ![height_5, height_413] +theorem height_exact_598_i8 : height_598_i8 = 1 + Finset.univ.sup childrenH_598_i8 := by decide +kernel +theorem required_origin_598_i8 : ∀ x ∈ required_598_i8, + (∃ j, x ∈ childrenC_598_i8 j) ∨ ∀ j, x ∈ childrenD_598_i8 j := by decide +kernel +theorem required_exact_598_i8 : required_598_i8 = + ((Finset.univ.biUnion childrenC_598_i8) ∪ commonEnvelope childrenD_598_i8).erase (5, 5) := by + exact required_eq_combination childrenC_598_i8 childrenD_598_i8 (5, 5) required_598_i8 + (by decide +kernel) child_required_sub_598_i8 common_sub_598_i8 required_origin_598_i8 +theorem envelope_origin_598_i8 : ∀ x ∈ envelope_598_i8, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_598_i8 j := by decide +kernel +theorem envelope_exact_598_i8 : envelope_598_i8 = + insert (5, 5) (Finset.univ.biUnion childrenD_598_i8) := by + exact envelope_eq_combination childrenD_598_i8 (5, 5) envelope_598_i8 + pivot_mem_598_i8 child_envelope_sub_598_i8 envelope_origin_598_i8 +def checked_598_i8 : CheckedCard where + required := required_598_i8 + envelope := envelope_598_i8 + height := height_598_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_598_i8 +def height_598_i7 : ℕ := 7 +def childrenH_598_i7 : Fin 2 → ℕ := ![height_0, height_598_i8] +theorem height_exact_598_i7 : height_598_i7 = 1 + Finset.univ.sup childrenH_598_i7 := by decide +kernel +theorem required_origin_598_i7 : ∀ x ∈ required_598_i7, + (∃ j, x ∈ childrenC_598_i7 j) ∨ ∀ j, x ∈ childrenD_598_i7 j := by decide +kernel +theorem required_exact_598_i7 : required_598_i7 = + ((Finset.univ.biUnion childrenC_598_i7) ∪ commonEnvelope childrenD_598_i7).erase (4, 5) := by + exact required_eq_combination childrenC_598_i7 childrenD_598_i7 (4, 5) required_598_i7 + (by decide +kernel) child_required_sub_598_i7 common_sub_598_i7 required_origin_598_i7 +theorem envelope_origin_598_i7 : ∀ x ∈ envelope_598_i7, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_598_i7 j := by decide +kernel +theorem envelope_exact_598_i7 : envelope_598_i7 = + insert (4, 5) (Finset.univ.biUnion childrenD_598_i7) := by + exact envelope_eq_combination childrenD_598_i7 (4, 5) envelope_598_i7 + pivot_mem_598_i7 child_envelope_sub_598_i7 envelope_origin_598_i7 +def checked_598_i7 : CheckedCard where + required := required_598_i7 + envelope := envelope_598_i7 + height := height_598_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_598_i7 +def height_598_i6 : ℕ := 8 +def childrenH_598_i6 : Fin 2 → ℕ := ![height_5, height_598_i7] +theorem height_exact_598_i6 : height_598_i6 = 1 + Finset.univ.sup childrenH_598_i6 := by decide +kernel +theorem required_origin_598_i6 : ∀ x ∈ required_598_i6, + (∃ j, x ∈ childrenC_598_i6 j) ∨ ∀ j, x ∈ childrenD_598_i6 j := by decide +kernel +theorem required_exact_598_i6 : required_598_i6 = + ((Finset.univ.biUnion childrenC_598_i6) ∪ commonEnvelope childrenD_598_i6).erase (3, 6) := by + exact required_eq_combination childrenC_598_i6 childrenD_598_i6 (3, 6) required_598_i6 + (by decide +kernel) child_required_sub_598_i6 common_sub_598_i6 required_origin_598_i6 +theorem envelope_origin_598_i6 : ∀ x ∈ envelope_598_i6, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_598_i6 j := by decide +kernel +theorem envelope_exact_598_i6 : envelope_598_i6 = + insert (3, 6) (Finset.univ.biUnion childrenD_598_i6) := by + exact envelope_eq_combination childrenD_598_i6 (3, 6) envelope_598_i6 + pivot_mem_598_i6 child_envelope_sub_598_i6 envelope_origin_598_i6 +def checked_598_i6 : CheckedCard where + required := required_598_i6 + envelope := envelope_598_i6 + height := height_598_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_598_i6 +def height_598 : ℕ := 14 +def childrenH_598 : Fin 7 → ℕ := ![height_598_i0, height_598_i3, height_584, height_591, height_594, height_598_i6, height_597] +theorem height_exact_598 : height_598 = 1 + Finset.univ.sup childrenH_598 := by decide +kernel +theorem required_origin_598 : ∀ x ∈ required_598, + (∃ j, x ∈ childrenC_598 j) ∨ ∀ j, x ∈ childrenD_598 j := by decide +kernel +theorem required_exact_598 : required_598 = + ((Finset.univ.biUnion childrenC_598) ∪ commonEnvelope childrenD_598).erase (3, 5) := by + exact required_eq_combination childrenC_598 childrenD_598 (3, 5) required_598 + (by decide +kernel) child_required_sub_598 common_sub_598 required_origin_598 +theorem envelope_origin_598 : ∀ x ∈ envelope_598, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_598 j := by decide +kernel +theorem envelope_exact_598 : envelope_598 = + insert (3, 5) (Finset.univ.biUnion childrenD_598) := by + exact envelope_eq_combination childrenD_598 (3, 5) envelope_598 + pivot_mem_598 child_envelope_sub_598 envelope_origin_598 +def checked_598 : CheckedCard where + required := required_598 + envelope := envelope_598 + height := height_598 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_598 +def height_636_i1 : ℕ := 10 +def childrenH_636_i1 : Fin 3 → ℕ := ![height_22, height_108, height_512] +theorem height_exact_636_i1 : height_636_i1 = 1 + Finset.univ.sup childrenH_636_i1 := by decide +kernel +theorem required_origin_636_i1 : ∀ x ∈ required_636_i1, + (∃ j, x ∈ childrenC_636_i1 j) ∨ ∀ j, x ∈ childrenD_636_i1 j := by decide +kernel +theorem required_exact_636_i1 : required_636_i1 = + ((Finset.univ.biUnion childrenC_636_i1) ∪ commonEnvelope childrenD_636_i1).erase (3, 5) := by + exact required_eq_combination childrenC_636_i1 childrenD_636_i1 (3, 5) required_636_i1 + (by decide +kernel) child_required_sub_636_i1 common_sub_636_i1 required_origin_636_i1 +theorem envelope_origin_636_i1 : ∀ x ∈ envelope_636_i1, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_636_i1 j := by decide +kernel +theorem envelope_exact_636_i1 : envelope_636_i1 = + insert (3, 5) (Finset.univ.biUnion childrenD_636_i1) := by + exact envelope_eq_combination childrenD_636_i1 (3, 5) envelope_636_i1 + pivot_mem_636_i1 child_envelope_sub_636_i1 envelope_origin_636_i1 +def checked_636_i1 : CheckedCard where + required := required_636_i1 + envelope := envelope_636_i1 + height := height_636_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_636_i1 +def height_636_i2 : ℕ := 8 +def childrenH_636_i2 : Fin 4 → ℕ := ![height_10, height_44, height_63, height_117] +theorem height_exact_636_i2 : height_636_i2 = 1 + Finset.univ.sup childrenH_636_i2 := by decide +kernel +theorem required_origin_636_i2 : ∀ x ∈ required_636_i2, + (∃ j, x ∈ childrenC_636_i2 j) ∨ ∀ j, x ∈ childrenD_636_i2 j := by decide +kernel +theorem required_exact_636_i2 : required_636_i2 = + ((Finset.univ.biUnion childrenC_636_i2) ∪ commonEnvelope childrenD_636_i2).erase (4, 6) := by + exact required_eq_combination childrenC_636_i2 childrenD_636_i2 (4, 6) required_636_i2 + (by decide +kernel) child_required_sub_636_i2 common_sub_636_i2 required_origin_636_i2 +theorem envelope_origin_636_i2 : ∀ x ∈ envelope_636_i2, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_636_i2 j := by decide +kernel +theorem envelope_exact_636_i2 : envelope_636_i2 = + insert (4, 6) (Finset.univ.biUnion childrenD_636_i2) := by + exact envelope_eq_combination childrenD_636_i2 (4, 6) envelope_636_i2 + pivot_mem_636_i2 child_envelope_sub_636_i2 envelope_origin_636_i2 +def checked_636_i2 : CheckedCard where + required := required_636_i2 + envelope := envelope_636_i2 + height := height_636_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_636_i2 +def height_636_i5 : ℕ := 7 +def childrenH_636_i5 : Fin 3 → ℕ := ![height_85, height_164, height_262] +theorem height_exact_636_i5 : height_636_i5 = 1 + Finset.univ.sup childrenH_636_i5 := by decide +kernel +theorem required_origin_636_i5 : ∀ x ∈ required_636_i5, + (∃ j, x ∈ childrenC_636_i5 j) ∨ ∀ j, x ∈ childrenD_636_i5 j := by decide +kernel +theorem required_exact_636_i5 : required_636_i5 = + ((Finset.univ.biUnion childrenC_636_i5) ∪ commonEnvelope childrenD_636_i5).erase (5, 5) := by + exact required_eq_combination childrenC_636_i5 childrenD_636_i5 (5, 5) required_636_i5 + (by decide +kernel) child_required_sub_636_i5 common_sub_636_i5 required_origin_636_i5 +theorem envelope_origin_636_i5 : ∀ x ∈ envelope_636_i5, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_636_i5 j := by decide +kernel +theorem envelope_exact_636_i5 : envelope_636_i5 = + insert (5, 5) (Finset.univ.biUnion childrenD_636_i5) := by + exact envelope_eq_combination childrenD_636_i5 (5, 5) envelope_636_i5 + pivot_mem_636_i5 child_envelope_sub_636_i5 envelope_origin_636_i5 +def checked_636_i5 : CheckedCard where + required := required_636_i5 + envelope := envelope_636_i5 + height := height_636_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_636_i5 +def height_636_i4 : ℕ := 8 +def childrenH_636_i4 : Fin 2 → ℕ := ![height_1, height_636_i5] +theorem height_exact_636_i4 : height_636_i4 = 1 + Finset.univ.sup childrenH_636_i4 := by decide +kernel +theorem required_origin_636_i4 : ∀ x ∈ required_636_i4, + (∃ j, x ∈ childrenC_636_i4 j) ∨ ∀ j, x ∈ childrenD_636_i4 j := by decide +kernel +theorem required_exact_636_i4 : required_636_i4 = + ((Finset.univ.biUnion childrenC_636_i4) ∪ commonEnvelope childrenD_636_i4).erase (3, 5) := by + exact required_eq_combination childrenC_636_i4 childrenD_636_i4 (3, 5) required_636_i4 + (by decide +kernel) child_required_sub_636_i4 common_sub_636_i4 required_origin_636_i4 +theorem envelope_origin_636_i4 : ∀ x ∈ envelope_636_i4, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_636_i4 j := by decide +kernel +theorem envelope_exact_636_i4 : envelope_636_i4 = + insert (3, 5) (Finset.univ.biUnion childrenD_636_i4) := by + exact envelope_eq_combination childrenD_636_i4 (3, 5) envelope_636_i4 + pivot_mem_636_i4 child_envelope_sub_636_i4 envelope_origin_636_i4 +def checked_636_i4 : CheckedCard where + required := required_636_i4 + envelope := envelope_636_i4 + height := height_636_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_636_i4 +def height_636_i6 : ℕ := 7 +def childrenH_636_i6 : Fin 3 → ℕ := ![height_7, height_11, height_331] +theorem height_exact_636_i6 : height_636_i6 = 1 + Finset.univ.sup childrenH_636_i6 := by decide +kernel +theorem required_origin_636_i6 : ∀ x ∈ required_636_i6, + (∃ j, x ∈ childrenC_636_i6 j) ∨ ∀ j, x ∈ childrenD_636_i6 j := by decide +kernel +theorem required_exact_636_i6 : required_636_i6 = + ((Finset.univ.biUnion childrenC_636_i6) ∪ commonEnvelope childrenD_636_i6).erase (6, 4) := by + exact required_eq_combination childrenC_636_i6 childrenD_636_i6 (6, 4) required_636_i6 + (by decide +kernel) child_required_sub_636_i6 common_sub_636_i6 required_origin_636_i6 +theorem envelope_origin_636_i6 : ∀ x ∈ envelope_636_i6, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_636_i6 j := by decide +kernel +theorem envelope_exact_636_i6 : envelope_636_i6 = + insert (6, 4) (Finset.univ.biUnion childrenD_636_i6) := by + exact envelope_eq_combination childrenD_636_i6 (6, 4) envelope_636_i6 + pivot_mem_636_i6 child_envelope_sub_636_i6 envelope_origin_636_i6 +def checked_636_i6 : CheckedCard where + required := required_636_i6 + envelope := envelope_636_i6 + height := height_636_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_636_i6 +def height_636_i3 : ℕ := 10 +def childrenH_636_i3 : Fin 5 → ℕ := ![height_332, height_474, height_522, height_636_i4, height_636_i6] +theorem height_exact_636_i3 : height_636_i3 = 1 + Finset.univ.sup childrenH_636_i3 := by decide +kernel +theorem required_origin_636_i3 : ∀ x ∈ required_636_i3, + (∃ j, x ∈ childrenC_636_i3 j) ∨ ∀ j, x ∈ childrenD_636_i3 j := by decide +kernel +theorem required_exact_636_i3 : required_636_i3 = + ((Finset.univ.biUnion childrenC_636_i3) ∪ commonEnvelope childrenD_636_i3).erase (5, 4) := by + exact required_eq_combination childrenC_636_i3 childrenD_636_i3 (5, 4) required_636_i3 + (by decide +kernel) child_required_sub_636_i3 common_sub_636_i3 required_origin_636_i3 +theorem envelope_origin_636_i3 : ∀ x ∈ envelope_636_i3, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_636_i3 j := by decide +kernel +theorem envelope_exact_636_i3 : envelope_636_i3 = + insert (5, 4) (Finset.univ.biUnion childrenD_636_i3) := by + exact envelope_eq_combination childrenD_636_i3 (5, 4) envelope_636_i3 + pivot_mem_636_i3 child_envelope_sub_636_i3 envelope_origin_636_i3 +def checked_636_i3 : CheckedCard where + required := required_636_i3 + envelope := envelope_636_i3 + height := height_636_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_636_i3 +def height_636_i0 : ℕ := 13 +def childrenH_636_i0 : Fin 9 → ℕ := ![height_399, height_408, height_475, height_509, height_587, height_636_i1, height_635, height_636_i2, height_636_i3] +theorem height_exact_636_i0 : height_636_i0 = 1 + Finset.univ.sup childrenH_636_i0 := by decide +kernel +theorem required_origin_636_i0 : ∀ x ∈ required_636_i0, + (∃ j, x ∈ childrenC_636_i0 j) ∨ ∀ j, x ∈ childrenD_636_i0 j := by decide +kernel +theorem required_exact_636_i0 : required_636_i0 = + ((Finset.univ.biUnion childrenC_636_i0) ∪ commonEnvelope childrenD_636_i0).erase (4, 5) := by + exact required_eq_combination childrenC_636_i0 childrenD_636_i0 (4, 5) required_636_i0 + (by decide +kernel) child_required_sub_636_i0 common_sub_636_i0 required_origin_636_i0 +theorem envelope_origin_636_i0 : ∀ x ∈ envelope_636_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_636_i0 j := by decide +kernel +theorem envelope_exact_636_i0 : envelope_636_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_636_i0) := by + exact envelope_eq_combination childrenD_636_i0 (4, 5) envelope_636_i0 + pivot_mem_636_i0 child_envelope_sub_636_i0 envelope_origin_636_i0 +def checked_636_i0 : CheckedCard where + required := required_636_i0 + envelope := envelope_636_i0 + height := height_636_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_636_i0 +def height_636_i7 : ℕ := 10 +def childrenH_636_i7 : Fin 6 → ℕ := ![height_118, height_188, height_188, height_192, height_193, height_396] +theorem height_exact_636_i7 : height_636_i7 = 1 + Finset.univ.sup childrenH_636_i7 := by decide +kernel +theorem required_origin_636_i7 : ∀ x ∈ required_636_i7, + (∃ j, x ∈ childrenC_636_i7 j) ∨ ∀ j, x ∈ childrenD_636_i7 j := by decide +kernel +theorem required_exact_636_i7 : required_636_i7 = + ((Finset.univ.biUnion childrenC_636_i7) ∪ commonEnvelope childrenD_636_i7).erase (5, 4) := by + exact required_eq_combination childrenC_636_i7 childrenD_636_i7 (5, 4) required_636_i7 + (by decide +kernel) child_required_sub_636_i7 common_sub_636_i7 required_origin_636_i7 +theorem envelope_origin_636_i7 : ∀ x ∈ envelope_636_i7, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_636_i7 j := by decide +kernel +theorem envelope_exact_636_i7 : envelope_636_i7 = + insert (5, 4) (Finset.univ.biUnion childrenD_636_i7) := by + exact envelope_eq_combination childrenD_636_i7 (5, 4) envelope_636_i7 + pivot_mem_636_i7 child_envelope_sub_636_i7 envelope_origin_636_i7 +def checked_636_i7 : CheckedCard where + required := required_636_i7 + envelope := envelope_636_i7 + height := height_636_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_636_i7 +def height_636 : ℕ := 14 +def childrenH_636 : Fin 4 → ℕ := ![height_125, height_454, height_636_i0, height_636_i7] +theorem height_exact_636 : height_636 = 1 + Finset.univ.sup childrenH_636 := by decide +kernel +theorem required_origin_636 : ∀ x ∈ required_636, + (∃ j, x ∈ childrenC_636 j) ∨ ∀ j, x ∈ childrenD_636 j := by decide +kernel +theorem required_exact_636 : required_636 = + ((Finset.univ.biUnion childrenC_636) ∪ commonEnvelope childrenD_636).erase (3, 4) := by + exact required_eq_combination childrenC_636 childrenD_636 (3, 4) required_636 + (by decide +kernel) child_required_sub_636 common_sub_636 required_origin_636 +theorem envelope_origin_636 : ∀ x ∈ envelope_636, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_636 j := by decide +kernel +theorem envelope_exact_636 : envelope_636 = + insert (3, 4) (Finset.univ.biUnion childrenD_636) := by + exact envelope_eq_combination childrenD_636 (3, 4) envelope_636 + pivot_mem_636 child_envelope_sub_636 envelope_origin_636 +def checked_636 : CheckedCard where + required := required_636 + envelope := envelope_636 + height := height_636 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_636 +def height_644_i1 : ℕ := 10 +def childrenH_644_i1 : Fin 3 → ℕ := ![height_10, height_317, height_640] +theorem height_exact_644_i1 : height_644_i1 = 1 + Finset.univ.sup childrenH_644_i1 := by decide +kernel +theorem required_origin_644_i1 : ∀ x ∈ required_644_i1, + (∃ j, x ∈ childrenC_644_i1 j) ∨ ∀ j, x ∈ childrenD_644_i1 j := by decide +kernel +theorem required_exact_644_i1 : required_644_i1 = + ((Finset.univ.biUnion childrenC_644_i1) ∪ commonEnvelope childrenD_644_i1).erase (5, 5) := by + exact required_eq_combination childrenC_644_i1 childrenD_644_i1 (5, 5) required_644_i1 + (by decide +kernel) child_required_sub_644_i1 common_sub_644_i1 required_origin_644_i1 +theorem envelope_origin_644_i1 : ∀ x ∈ envelope_644_i1, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_644_i1 j := by decide +kernel +theorem envelope_exact_644_i1 : envelope_644_i1 = + insert (5, 5) (Finset.univ.biUnion childrenD_644_i1) := by + exact envelope_eq_combination childrenD_644_i1 (5, 5) envelope_644_i1 + pivot_mem_644_i1 child_envelope_sub_644_i1 envelope_origin_644_i1 +def checked_644_i1 : CheckedCard where + required := required_644_i1 + envelope := envelope_644_i1 + height := height_644_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_644_i1 +def height_644_i0 : ℕ := 11 +def childrenH_644_i0 : Fin 6 → ℕ := ![height_104, height_359, height_452, height_476, height_479, height_644_i1] +theorem height_exact_644_i0 : height_644_i0 = 1 + Finset.univ.sup childrenH_644_i0 := by decide +kernel +theorem required_origin_644_i0 : ∀ x ∈ required_644_i0, + (∃ j, x ∈ childrenC_644_i0 j) ∨ ∀ j, x ∈ childrenD_644_i0 j := by decide +kernel +theorem required_exact_644_i0 : required_644_i0 = + ((Finset.univ.biUnion childrenC_644_i0) ∪ commonEnvelope childrenD_644_i0).erase (6, 5) := by + exact required_eq_combination childrenC_644_i0 childrenD_644_i0 (6, 5) required_644_i0 + (by decide +kernel) child_required_sub_644_i0 common_sub_644_i0 required_origin_644_i0 +theorem envelope_origin_644_i0 : ∀ x ∈ envelope_644_i0, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_644_i0 j := by decide +kernel +theorem envelope_exact_644_i0 : envelope_644_i0 = + insert (6, 5) (Finset.univ.biUnion childrenD_644_i0) := by + exact envelope_eq_combination childrenD_644_i0 (6, 5) envelope_644_i0 + pivot_mem_644_i0 child_envelope_sub_644_i0 envelope_origin_644_i0 +def checked_644_i0 : CheckedCard where + required := required_644_i0 + envelope := envelope_644_i0 + height := height_644_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_644_i0 +def height_644 : ℕ := 14 +def childrenH_644 : Fin 9 → ℕ := ![height_120, height_338, height_437, height_611, height_613, height_634, height_644_i0, height_642, height_643] +theorem height_exact_644 : height_644 = 1 + Finset.univ.sup childrenH_644 := by decide +kernel +theorem required_origin_644 : ∀ x ∈ required_644, + (∃ j, x ∈ childrenC_644 j) ∨ ∀ j, x ∈ childrenD_644 j := by decide +kernel +theorem required_exact_644 : required_644 = + ((Finset.univ.biUnion childrenC_644) ∪ commonEnvelope childrenD_644).erase (6, 4) := by + exact required_eq_combination childrenC_644 childrenD_644 (6, 4) required_644 + (by decide +kernel) child_required_sub_644 common_sub_644 required_origin_644 +theorem envelope_origin_644 : ∀ x ∈ envelope_644, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_644 j := by decide +kernel +theorem envelope_exact_644 : envelope_644 = + insert (6, 4) (Finset.univ.biUnion childrenD_644) := by + exact envelope_eq_combination childrenD_644 (6, 4) envelope_644 + pivot_mem_644 child_envelope_sub_644 envelope_origin_644 +def checked_644 : CheckedCard where + required := required_644 + envelope := envelope_644 + height := height_644 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_644 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part03.lean new file mode 100644 index 0000000..4e9ae54 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part03.lean @@ -0,0 +1,881 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_645_i0 : Finset Cell := ⟨(([(4, 4), (4, 5), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_645_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 3), (4, 4), (4, 5), (4, 6), (5, 3), (5, 4), (5, 5), (6, 4), (6, 5), (7, 4), (7, 5), (8, 4), (8, 5), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_645_i0 : Fin 4 → Finset Cell := ![(placed21 5 (7, 4) required_44), (placed21 5 (7, 4) required_52), (placed21 3 (2, 5) required_128), (placed21 6 (6, 6) required_144)] +def childrenD_645_i0 : Fin 4 → Finset Cell := ![(placed21 5 (7, 4) envelope_44), (placed21 5 (7, 4) envelope_52), (placed21 3 (2, 5) envelope_128), (placed21 6 (6, 6) envelope_144)] +theorem common_sub_645_i0 : commonEnvelope childrenD_645_i0 ⊆ insert (5, 4) required_645_i0 := by decide +kernel +theorem child_required_sub_645_i0 : ∀ j, childrenC_645_i0 j ⊆ insert (5, 4) required_645_i0 := by decide +kernel +theorem child_envelope_sub_645_i0 : ∀ j, childrenD_645_i0 j ⊆ envelope_645_i0 := by decide +kernel +theorem pivot_mem_645_i0 : (5, 4) ∈ envelope_645_i0 := by decide +kernel +theorem children_work_645_i0 : ∀ j, Template HasSnaky 5 (childrenC_645_i0 j) (childrenD_645_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_52 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_128 3 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_144 6 (6, 6)).mono (by decide +kernel) +theorem row_works_645_i0 : Template HasSnaky 6 required_645_i0 envelope_645_i0 := by + refine compose HasSnaky 5 childrenC_645_i0 childrenD_645_i0 children_work_645_i0 (5, 4) + required_645_i0 envelope_645_i0 pivot_mem_645_i0 child_required_sub_645_i0 child_envelope_sub_645_i0 ?_ + intro b hb + exact common_sub_645_i0 (mem_commonEnvelope childrenD_645_i0 b hb) +def required_645_i1 : Finset Cell := ⟨(([(4, 4), (4, 5), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_645_i1 : Finset Cell := ⟨(([(1, 4), (1, 6), (2, 4), (2, 5), (2, 6), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 2), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_645_i1 : Fin 6 → Finset Cell := ![(placed21 1 (1, 4) required_104), (placed21 1 (1, 4) required_359), (placed21 4 (1, 8) required_438), (placed21 0 (1, 1) required_452), (placed21 4 (3, 8) required_476), (placed21 0 (3, 1) required_479)] +def childrenD_645_i1 : Fin 6 → Finset Cell := ![(placed21 1 (1, 4) envelope_104), (placed21 1 (1, 4) envelope_359), (placed21 4 (1, 8) envelope_438), (placed21 0 (1, 1) envelope_452), (placed21 4 (3, 8) envelope_476), (placed21 0 (3, 1) envelope_479)] +theorem common_sub_645_i1 : commonEnvelope childrenD_645_i1 ⊆ insert (6, 5) required_645_i1 := by decide +kernel +theorem child_required_sub_645_i1 : ∀ j, childrenC_645_i1 j ⊆ insert (6, 5) required_645_i1 := by decide +kernel +theorem child_envelope_sub_645_i1 : ∀ j, childrenD_645_i1 j ⊆ envelope_645_i1 := by decide +kernel +theorem pivot_mem_645_i1 : (6, 5) ∈ envelope_645_i1 := by decide +kernel +theorem children_work_645_i1 : ∀ j, Template HasSnaky 10 (childrenC_645_i1 j) (childrenD_645_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_104 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_359 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_438 4 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_452 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_476 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_479 0 (3, 1)).mono (by decide +kernel) +theorem row_works_645_i1 : Template HasSnaky 11 required_645_i1 envelope_645_i1 := by + refine compose HasSnaky 10 childrenC_645_i1 childrenD_645_i1 children_work_645_i1 (6, 5) + required_645_i1 envelope_645_i1 pivot_mem_645_i1 child_required_sub_645_i1 child_envelope_sub_645_i1 ?_ + intro b hb + exact common_sub_645_i1 (mem_commonEnvelope childrenD_645_i1 b hb) +def required_645 : Finset Cell := ⟨(([(4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_645 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (1, 6), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 3), (10, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_645 : Fin 10 → Finset Cell := ![(placed21 6 (7, 7) required_120), (placed21 3 (1, 6) required_276), (placed21 3 (1, 6) required_338), (placed21 3 (1, 7) required_437), (placed21 3 (0, 6) required_611), (placed21 0 (1, 0) required_634), (placed21 0 (3, 0) required_642), (placed21 0 (3, 0) required_643), required_645_i0, required_645_i1] +def childrenD_645 : Fin 10 → Finset Cell := ![(placed21 6 (7, 7) envelope_120), (placed21 3 (1, 6) envelope_276), (placed21 3 (1, 6) envelope_338), (placed21 3 (1, 7) envelope_437), (placed21 3 (0, 6) envelope_611), (placed21 0 (1, 0) envelope_634), (placed21 0 (3, 0) envelope_642), (placed21 0 (3, 0) envelope_643), envelope_645_i0, envelope_645_i1] +theorem common_sub_645 : commonEnvelope childrenD_645 ⊆ insert (6, 4) required_645 := by decide +kernel +theorem child_required_sub_645 : ∀ j, childrenC_645 j ⊆ insert (6, 4) required_645 := by decide +kernel +theorem child_envelope_sub_645 : ∀ j, childrenD_645 j ⊆ envelope_645 := by decide +kernel +theorem pivot_mem_645 : (6, 4) ∈ envelope_645 := by decide +kernel +theorem children_work_645 : ∀ j, Template HasSnaky 13 (childrenC_645 j) (childrenD_645 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_120 6 (7, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_276 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_338 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_437 3 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_611 3 (0, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_634 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_642 0 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_643 0 (3, 0)).mono (by decide +kernel) + · exact row_works_645_i0.mono (by decide +kernel) + · exact row_works_645_i1.mono (by decide +kernel) +theorem row_works_645 : Template HasSnaky 14 required_645 envelope_645 := by + refine compose HasSnaky 13 childrenC_645 childrenD_645 children_work_645 (6, 4) + required_645 envelope_645 pivot_mem_645 child_required_sub_645 child_envelope_sub_645 ?_ + intro b hb + exact common_sub_645 (mem_commonEnvelope childrenD_645 b hb) +def required_669_i5 : Finset Cell := ⟨(([(3, 5), (4, 5), (4, 6), (5, 7), (6, 5), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_669_i5 : Finset Cell := ⟨(([(2, 6), (3, 5), (3, 6), (4, 5), (4, 6), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_669_i5 : Fin 2 → Finset Cell := ![(placed21 6 (7, 6) required_0), (placed21 7 (7, 7) required_66)] +def childrenD_669_i5 : Fin 2 → Finset Cell := ![(placed21 6 (7, 6) envelope_0), (placed21 7 (7, 7) envelope_66)] +theorem common_sub_669_i5 : commonEnvelope childrenD_669_i5 ⊆ insert (5, 6) required_669_i5 := by decide +kernel +theorem child_required_sub_669_i5 : ∀ j, childrenC_669_i5 j ⊆ insert (5, 6) required_669_i5 := by decide +kernel +theorem child_envelope_sub_669_i5 : ∀ j, childrenD_669_i5 j ⊆ envelope_669_i5 := by decide +kernel +theorem pivot_mem_669_i5 : (5, 6) ∈ envelope_669_i5 := by decide +kernel +theorem children_work_669_i5 : ∀ j, Template HasSnaky 2 (childrenC_669_i5 j) (childrenD_669_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_66 7 (7, 7)).mono (by decide +kernel) +theorem row_works_669_i5 : Template HasSnaky 3 required_669_i5 envelope_669_i5 := by + refine compose HasSnaky 2 childrenC_669_i5 childrenD_669_i5 children_work_669_i5 (5, 6) + required_669_i5 envelope_669_i5 pivot_mem_669_i5 child_required_sub_669_i5 child_envelope_sub_669_i5 ?_ + intro b hb + exact common_sub_669_i5 (mem_commonEnvelope childrenD_669_i5 b hb) +def required_669_i4 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 5), (4, 7), (5, 7), (6, 5), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_669_i4 : Finset Cell := ⟨(([(2, 6), (3, 4), (3, 5), (3, 6), (4, 5), (4, 6), (4, 7), (4, 8), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_669_i4 : Fin 2 → Finset Cell := ![(placed21 7 (4, 8) required_0), required_669_i5] +def childrenD_669_i4 : Fin 2 → Finset Cell := ![(placed21 7 (4, 8) envelope_0), envelope_669_i5] +theorem common_sub_669_i4 : commonEnvelope childrenD_669_i4 ⊆ insert (4, 6) required_669_i4 := by decide +kernel +theorem child_required_sub_669_i4 : ∀ j, childrenC_669_i4 j ⊆ insert (4, 6) required_669_i4 := by decide +kernel +theorem child_envelope_sub_669_i4 : ∀ j, childrenD_669_i4 j ⊆ envelope_669_i4 := by decide +kernel +theorem pivot_mem_669_i4 : (4, 6) ∈ envelope_669_i4 := by decide +kernel +theorem children_work_669_i4 : ∀ j, Template HasSnaky 3 (childrenC_669_i4 j) (childrenD_669_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (4, 8)).mono (by decide +kernel) + · exact row_works_669_i5.mono (by decide +kernel) +theorem row_works_669_i4 : Template HasSnaky 4 required_669_i4 envelope_669_i4 := by + refine compose HasSnaky 3 childrenC_669_i4 childrenD_669_i4 children_work_669_i4 (4, 6) + required_669_i4 envelope_669_i4 pivot_mem_669_i4 child_required_sub_669_i4 child_envelope_sub_669_i4 ?_ + intro b hb + exact common_sub_669_i4 (mem_commonEnvelope childrenD_669_i4 b hb) +def required_669_i6 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 5), (4, 7), (5, 7), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_669_i6 : Finset Cell := ⟨(([(3, 4), (3, 5), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (4, 8), (5, 7), (6, 6), (6, 7), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_669_i6 : Fin 2 → Finset Cell := ![(placed21 4 (3, 7) required_5), (placed21 0 (3, 4) required_36)] +def childrenD_669_i6 : Fin 2 → Finset Cell := ![(placed21 4 (3, 7) envelope_5), (placed21 0 (3, 4) envelope_36)] +theorem common_sub_669_i6 : commonEnvelope childrenD_669_i6 ⊆ insert (3, 7) required_669_i6 := by decide +kernel +theorem child_required_sub_669_i6 : ∀ j, childrenC_669_i6 j ⊆ insert (3, 7) required_669_i6 := by decide +kernel +theorem child_envelope_sub_669_i6 : ∀ j, childrenD_669_i6 j ⊆ envelope_669_i6 := by decide +kernel +theorem pivot_mem_669_i6 : (3, 7) ∈ envelope_669_i6 := by decide +kernel +theorem children_work_669_i6 : ∀ j, Template HasSnaky 2 (childrenC_669_i6 j) (childrenD_669_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_36 0 (3, 4)).mono (by decide +kernel) +theorem row_works_669_i6 : Template HasSnaky 3 required_669_i6 envelope_669_i6 := by + refine compose HasSnaky 2 childrenC_669_i6 childrenD_669_i6 children_work_669_i6 (3, 7) + required_669_i6 envelope_669_i6 pivot_mem_669_i6 child_required_sub_669_i6 child_envelope_sub_669_i6 ?_ + intro b hb + exact common_sub_669_i6 (mem_commonEnvelope childrenD_669_i6 b hb) +def required_669_i7 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 5), (4, 7), (5, 7), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_669_i7 : Finset Cell := ⟨(([(1, 8), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8), (5, 6), (5, 7), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_669_i7 : Fin 2 → Finset Cell := ![(placed21 2 (6, 6) required_24), (placed21 0 (3, 4) required_36)] +def childrenD_669_i7 : Fin 2 → Finset Cell := ![(placed21 2 (6, 6) envelope_24), (placed21 0 (3, 4) envelope_36)] +theorem common_sub_669_i7 : commonEnvelope childrenD_669_i7 ⊆ insert (3, 7) required_669_i7 := by decide +kernel +theorem child_required_sub_669_i7 : ∀ j, childrenC_669_i7 j ⊆ insert (3, 7) required_669_i7 := by decide +kernel +theorem child_envelope_sub_669_i7 : ∀ j, childrenD_669_i7 j ⊆ envelope_669_i7 := by decide +kernel +theorem pivot_mem_669_i7 : (3, 7) ∈ envelope_669_i7 := by decide +kernel +theorem children_work_669_i7 : ∀ j, Template HasSnaky 3 (childrenC_669_i7 j) (childrenD_669_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_24 2 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_36 0 (3, 4)).mono (by decide +kernel) +theorem row_works_669_i7 : Template HasSnaky 4 required_669_i7 envelope_669_i7 := by + refine compose HasSnaky 3 childrenC_669_i7 childrenD_669_i7 children_work_669_i7 (3, 7) + required_669_i7 envelope_669_i7 pivot_mem_669_i7 child_required_sub_669_i7 child_envelope_sub_669_i7 ?_ + intro b hb + exact common_sub_669_i7 (mem_commonEnvelope childrenD_669_i7 b hb) +def required_669_i3 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 5), (5, 7), (6, 5), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_669_i3 : Finset Cell := ⟨(([(1, 8), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_669_i3 : Fin 4 → Finset Cell := ![(placed21 5 (7, 6) required_48), required_669_i4, required_669_i6, required_669_i7] +def childrenD_669_i3 : Fin 4 → Finset Cell := ![(placed21 5 (7, 6) envelope_48), envelope_669_i4, envelope_669_i6, envelope_669_i7] +theorem common_sub_669_i3 : commonEnvelope childrenD_669_i3 ⊆ insert (4, 7) required_669_i3 := by decide +kernel +theorem child_required_sub_669_i3 : ∀ j, childrenC_669_i3 j ⊆ insert (4, 7) required_669_i3 := by decide +kernel +theorem child_envelope_sub_669_i3 : ∀ j, childrenD_669_i3 j ⊆ envelope_669_i3 := by decide +kernel +theorem pivot_mem_669_i3 : (4, 7) ∈ envelope_669_i3 := by decide +kernel +theorem children_work_669_i3 : ∀ j, Template HasSnaky 4 (childrenC_669_i3 j) (childrenD_669_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_48 5 (7, 6)).mono (by decide +kernel) + · exact row_works_669_i4.mono (by decide +kernel) + · exact row_works_669_i6.mono (by decide +kernel) + · exact row_works_669_i7.mono (by decide +kernel) +theorem row_works_669_i3 : Template HasSnaky 5 required_669_i3 envelope_669_i3 := by + refine compose HasSnaky 4 childrenC_669_i3 childrenD_669_i3 children_work_669_i3 (4, 7) + required_669_i3 envelope_669_i3 pivot_mem_669_i3 child_required_sub_669_i3 child_envelope_sub_669_i3 ?_ + intro b hb + exact common_sub_669_i3 (mem_commonEnvelope childrenD_669_i3 b hb) +def required_669_i2 : Finset Cell := ⟨(([(3, 4), (3, 5), (4, 5), (6, 4), (6, 5), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_669_i2 : Finset Cell := ⟨(([(1, 8), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_669_i2 : Fin 2 → Finset Cell := ![(placed21 5 (6, 4) required_5), required_669_i3] +def childrenD_669_i2 : Fin 2 → Finset Cell := ![(placed21 5 (6, 4) envelope_5), envelope_669_i3] +theorem common_sub_669_i2 : commonEnvelope childrenD_669_i2 ⊆ insert (5, 7) required_669_i2 := by decide +kernel +theorem child_required_sub_669_i2 : ∀ j, childrenC_669_i2 j ⊆ insert (5, 7) required_669_i2 := by decide +kernel +theorem child_envelope_sub_669_i2 : ∀ j, childrenD_669_i2 j ⊆ envelope_669_i2 := by decide +kernel +theorem pivot_mem_669_i2 : (5, 7) ∈ envelope_669_i2 := by decide +kernel +theorem children_work_669_i2 : ∀ j, Template HasSnaky 5 (childrenC_669_i2 j) (childrenD_669_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (6, 4)).mono (by decide +kernel) + · exact row_works_669_i3.mono (by decide +kernel) +theorem row_works_669_i2 : Template HasSnaky 6 required_669_i2 envelope_669_i2 := by + refine compose HasSnaky 5 childrenC_669_i2 childrenD_669_i2 children_work_669_i2 (5, 7) + required_669_i2 envelope_669_i2 pivot_mem_669_i2 child_required_sub_669_i2 child_envelope_sub_669_i2 ?_ + intro b hb + exact common_sub_669_i2 (mem_commonEnvelope childrenD_669_i2 b hb) +def required_669_i1 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 4), (6, 5), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_669_i1 : Finset Cell := ⟨(([(1, 8), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8), (6, 4), (6, 5), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_669_i1 : Fin 2 → Finset Cell := ![(placed21 7 (7, 7) required_25), required_669_i2] +def childrenD_669_i1 : Fin 2 → Finset Cell := ![(placed21 7 (7, 7) envelope_25), envelope_669_i2] +theorem common_sub_669_i1 : commonEnvelope childrenD_669_i1 ⊆ insert (4, 5) required_669_i1 := by decide +kernel +theorem child_required_sub_669_i1 : ∀ j, childrenC_669_i1 j ⊆ insert (4, 5) required_669_i1 := by decide +kernel +theorem child_envelope_sub_669_i1 : ∀ j, childrenD_669_i1 j ⊆ envelope_669_i1 := by decide +kernel +theorem pivot_mem_669_i1 : (4, 5) ∈ envelope_669_i1 := by decide +kernel +theorem children_work_669_i1 : ∀ j, Template HasSnaky 6 (childrenC_669_i1 j) (childrenD_669_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_25 7 (7, 7)).mono (by decide +kernel) + · exact row_works_669_i2.mono (by decide +kernel) +theorem row_works_669_i1 : Template HasSnaky 7 required_669_i1 envelope_669_i1 := by + refine compose HasSnaky 6 childrenC_669_i1 childrenD_669_i1 children_work_669_i1 (4, 5) + required_669_i1 envelope_669_i1 pivot_mem_669_i1 child_required_sub_669_i1 child_envelope_sub_669_i1 ?_ + intro b hb + exact common_sub_669_i1 (mem_commonEnvelope childrenD_669_i1 b hb) +def required_669_i0 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_669_i0 : Finset Cell := ⟨(([(1, 8), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 5), (4, 6), (4, 7), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 5), (7, 6), (7, 8), (7, 9), (7, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_669_i0 : Fin 4 → Finset Cell := ![(placed21 2 (7, 3) required_19), (placed21 1 (5, 4) required_197), (placed21 2 (7, 3) required_225), required_669_i1] +def childrenD_669_i0 : Fin 4 → Finset Cell := ![(placed21 2 (7, 3) envelope_19), (placed21 1 (5, 4) envelope_197), (placed21 2 (7, 3) envelope_225), envelope_669_i1] +theorem common_sub_669_i0 : commonEnvelope childrenD_669_i0 ⊆ insert (6, 7) required_669_i0 := by decide +kernel +theorem child_required_sub_669_i0 : ∀ j, childrenC_669_i0 j ⊆ insert (6, 7) required_669_i0 := by decide +kernel +theorem child_envelope_sub_669_i0 : ∀ j, childrenD_669_i0 j ⊆ envelope_669_i0 := by decide +kernel +theorem pivot_mem_669_i0 : (6, 7) ∈ envelope_669_i0 := by decide +kernel +theorem children_work_669_i0 : ∀ j, Template HasSnaky 7 (childrenC_669_i0 j) (childrenD_669_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_197 1 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_225 2 (7, 3)).mono (by decide +kernel) + · exact row_works_669_i1.mono (by decide +kernel) +theorem row_works_669_i0 : Template HasSnaky 8 required_669_i0 envelope_669_i0 := by + refine compose HasSnaky 7 childrenC_669_i0 childrenD_669_i0 children_work_669_i0 (6, 7) + required_669_i0 envelope_669_i0 pivot_mem_669_i0 child_required_sub_669_i0 child_envelope_sub_669_i0 ?_ + intro b hb + exact common_sub_669_i0 (mem_commonEnvelope childrenD_669_i0 b hb) +def required_669 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_669 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (2, 9), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 8), (7, 9), (7, 10), (8, 2), (8, 3), (8, 4), (9, 2), (9, 3), (9, 4), (10, 2), (10, 3), (10, 4), (11, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_669 : Fin 4 → Finset Cell := ![(placed21 4 (4, 8) required_188), (placed21 2 (7, 3) required_590), (placed21 4 (3, 7) required_668), required_669_i0] +def childrenD_669 : Fin 4 → Finset Cell := ![(placed21 4 (4, 8) envelope_188), (placed21 2 (7, 3) envelope_590), (placed21 4 (3, 7) envelope_668), envelope_669_i0] +theorem common_sub_669 : commonEnvelope childrenD_669 ⊆ insert (6, 4) required_669 := by decide +kernel +theorem child_required_sub_669 : ∀ j, childrenC_669 j ⊆ insert (6, 4) required_669 := by decide +kernel +theorem child_envelope_sub_669 : ∀ j, childrenD_669 j ⊆ envelope_669 := by decide +kernel +theorem pivot_mem_669 : (6, 4) ∈ envelope_669 := by decide +kernel +theorem children_work_669 : ∀ j, Template HasSnaky 13 (childrenC_669 j) (childrenD_669 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_188 4 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_590 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_668 4 (3, 7)).mono (by decide +kernel) + · exact row_works_669_i0.mono (by decide +kernel) +theorem row_works_669 : Template HasSnaky 14 required_669 envelope_669 := by + refine compose HasSnaky 13 childrenC_669 childrenD_669 children_work_669 (6, 4) + required_669 envelope_669 pivot_mem_669 child_required_sub_669 child_envelope_sub_669 ?_ + intro b hb + exact common_sub_669 (mem_commonEnvelope childrenD_669 b hb) +def required_693_i1 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 7), (6, 5), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_693_i1 : Finset Cell := ⟨(([(2, 7), (2, 9), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (6, 10), (7, 8), (7, 9), (8, 8), (8, 9), (9, 8), (9, 9), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_693_i1 : Fin 2 → Finset Cell := ![(placed21 0 (4, 4) required_28), (placed21 1 (2, 7) required_409)] +def childrenD_693_i1 : Fin 2 → Finset Cell := ![(placed21 0 (4, 4) envelope_28), (placed21 1 (2, 7) envelope_409)] +theorem common_sub_693_i1 : commonEnvelope childrenD_693_i1 ⊆ insert (5, 8) required_693_i1 := by decide +kernel +theorem child_required_sub_693_i1 : ∀ j, childrenC_693_i1 j ⊆ insert (5, 8) required_693_i1 := by decide +kernel +theorem child_envelope_sub_693_i1 : ∀ j, childrenD_693_i1 j ⊆ envelope_693_i1 := by decide +kernel +theorem pivot_mem_693_i1 : (5, 8) ∈ envelope_693_i1 := by decide +kernel +theorem children_work_693_i1 : ∀ j, Template HasSnaky 10 (childrenC_693_i1 j) (childrenD_693_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_28 0 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_409 1 (2, 7)).mono (by decide +kernel) +theorem row_works_693_i1 : Template HasSnaky 11 required_693_i1 envelope_693_i1 := by + refine compose HasSnaky 10 childrenC_693_i1 childrenD_693_i1 children_work_693_i1 (5, 8) + required_693_i1 envelope_693_i1 pivot_mem_693_i1 child_required_sub_693_i1 child_envelope_sub_693_i1 ?_ + intro b hb + exact common_sub_693_i1 (mem_commonEnvelope childrenD_693_i1 b hb) +def required_693_i2 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 7), (6, 5), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_693_i2 : Finset Cell := ⟨(([(1, 7), (2, 6), (2, 7), (2, 8), (2, 9), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 8), (7, 9), (8, 7), (8, 8), (8, 9), (9, 7), (9, 8), (9, 9), (10, 7), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_693_i2 : Fin 3 → Finset Cell := ![(placed21 5 (7, 4) required_168), (placed21 1 (2, 7) required_409), (placed21 1 (1, 6) required_611)] +def childrenD_693_i2 : Fin 3 → Finset Cell := ![(placed21 5 (7, 4) envelope_168), (placed21 1 (2, 7) envelope_409), (placed21 1 (1, 6) envelope_611)] +theorem common_sub_693_i2 : commonEnvelope childrenD_693_i2 ⊆ insert (5, 8) required_693_i2 := by decide +kernel +theorem child_required_sub_693_i2 : ∀ j, childrenC_693_i2 j ⊆ insert (5, 8) required_693_i2 := by decide +kernel +theorem child_envelope_sub_693_i2 : ∀ j, childrenD_693_i2 j ⊆ envelope_693_i2 := by decide +kernel +theorem pivot_mem_693_i2 : (5, 8) ∈ envelope_693_i2 := by decide +kernel +theorem children_work_693_i2 : ∀ j, Template HasSnaky 10 (childrenC_693_i2 j) (childrenD_693_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_168 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_409 1 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_611 1 (1, 6)).mono (by decide +kernel) +theorem row_works_693_i2 : Template HasSnaky 11 required_693_i2 envelope_693_i2 := by + refine compose HasSnaky 10 childrenC_693_i2 childrenD_693_i2 children_work_693_i2 (5, 8) + required_693_i2 envelope_693_i2 pivot_mem_693_i2 child_required_sub_693_i2 child_envelope_sub_693_i2 ?_ + intro b hb + exact common_sub_693_i2 (mem_commonEnvelope childrenD_693_i2 b hb) +def required_693_i4 : Finset Cell := ⟨(([(3, 5), (4, 5), (5, 5), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_693_i4 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_693_i4 : Fin 2 → Finset Cell := ![(placed21 5 (6, 4) required_10), (placed21 4 (4, 8) required_308)] +def childrenD_693_i4 : Fin 2 → Finset Cell := ![(placed21 5 (6, 4) envelope_10), (placed21 4 (4, 8) envelope_308)] +theorem common_sub_693_i4 : commonEnvelope childrenD_693_i4 ⊆ insert (5, 4) required_693_i4 := by decide +kernel +theorem child_required_sub_693_i4 : ∀ j, childrenC_693_i4 j ⊆ insert (5, 4) required_693_i4 := by decide +kernel +theorem child_envelope_sub_693_i4 : ∀ j, childrenD_693_i4 j ⊆ envelope_693_i4 := by decide +kernel +theorem pivot_mem_693_i4 : (5, 4) ∈ envelope_693_i4 := by decide +kernel +theorem children_work_693_i4 : ∀ j, Template HasSnaky 5 (childrenC_693_i4 j) (childrenD_693_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 5 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_308 4 (4, 8)).mono (by decide +kernel) +theorem row_works_693_i4 : Template HasSnaky 6 required_693_i4 envelope_693_i4 := by + refine compose HasSnaky 5 childrenC_693_i4 childrenD_693_i4 children_work_693_i4 (5, 4) + required_693_i4 envelope_693_i4 pivot_mem_693_i4 child_required_sub_693_i4 child_envelope_sub_693_i4 ?_ + intro b hb + exact common_sub_693_i4 (mem_commonEnvelope childrenD_693_i4 b hb) +def required_693_i3 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 7), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_693_i3 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_693_i3 : Fin 4 → Finset Cell := ![(placed21 5 (7, 5) required_6), (placed21 2 (6, 4) required_26), (placed21 2 (7, 2) required_214), required_693_i4] +def childrenD_693_i3 : Fin 4 → Finset Cell := ![(placed21 5 (7, 5) envelope_6), (placed21 2 (6, 4) envelope_26), (placed21 2 (7, 2) envelope_214), envelope_693_i4] +theorem common_sub_693_i3 : commonEnvelope childrenD_693_i3 ⊆ insert (3, 5) required_693_i3 := by decide +kernel +theorem child_required_sub_693_i3 : ∀ j, childrenC_693_i3 j ⊆ insert (3, 5) required_693_i3 := by decide +kernel +theorem child_envelope_sub_693_i3 : ∀ j, childrenD_693_i3 j ⊆ envelope_693_i3 := by decide +kernel +theorem pivot_mem_693_i3 : (3, 5) ∈ envelope_693_i3 := by decide +kernel +theorem children_work_693_i3 : ∀ j, Template HasSnaky 6 (childrenC_693_i3 j) (childrenD_693_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 5 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_26 2 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_214 2 (7, 2)).mono (by decide +kernel) + · exact row_works_693_i4.mono (by decide +kernel) +theorem row_works_693_i3 : Template HasSnaky 7 required_693_i3 envelope_693_i3 := by + refine compose HasSnaky 6 childrenC_693_i3 childrenD_693_i3 children_work_693_i3 (3, 5) + required_693_i3 envelope_693_i3 pivot_mem_693_i3 child_required_sub_693_i3 child_envelope_sub_693_i3 ?_ + intro b hb + exact common_sub_693_i3 (mem_commonEnvelope childrenD_693_i3 b hb) +def required_693_i6 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 6), (5, 7), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_693_i6 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_693_i6 : Fin 3 → Finset Cell := ![(placed21 2 (7, 4) required_233), (placed21 7 (6, 7) required_314), (placed21 3 (4, 7) required_314)] +def childrenD_693_i6 : Fin 3 → Finset Cell := ![(placed21 2 (7, 4) envelope_233), (placed21 7 (6, 7) envelope_314), (placed21 3 (4, 7) envelope_314)] +theorem common_sub_693_i6 : commonEnvelope childrenD_693_i6 ⊆ insert (5, 4) required_693_i6 := by decide +kernel +theorem child_required_sub_693_i6 : ∀ j, childrenC_693_i6 j ⊆ insert (5, 4) required_693_i6 := by decide +kernel +theorem child_envelope_sub_693_i6 : ∀ j, childrenD_693_i6 j ⊆ envelope_693_i6 := by decide +kernel +theorem pivot_mem_693_i6 : (5, 4) ∈ envelope_693_i6 := by decide +kernel +theorem children_work_693_i6 : ∀ j, Template HasSnaky 5 (childrenC_693_i6 j) (childrenD_693_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_233 2 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_314 7 (6, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_314 3 (4, 7)).mono (by decide +kernel) +theorem row_works_693_i6 : Template HasSnaky 6 required_693_i6 envelope_693_i6 := by + refine compose HasSnaky 5 childrenC_693_i6 childrenD_693_i6 children_work_693_i6 (5, 4) + required_693_i6 envelope_693_i6 pivot_mem_693_i6 child_required_sub_693_i6 child_envelope_sub_693_i6 ?_ + intro b hb + exact common_sub_693_i6 (mem_commonEnvelope childrenD_693_i6 b hb) +def required_693_i5 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 7), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_693_i5 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 5), (2, 4), (2, 5), (2, 6), (3, 5), (3, 6), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_693_i5 : Fin 3 → Finset Cell := ![(placed21 6 (5, 8) required_44), (placed21 4 (5, 8) required_52), required_693_i6] +def childrenD_693_i5 : Fin 3 → Finset Cell := ![(placed21 6 (5, 8) envelope_44), (placed21 4 (5, 8) envelope_52), envelope_693_i6] +theorem common_sub_693_i5 : commonEnvelope childrenD_693_i5 ⊆ insert (5, 6) required_693_i5 := by decide +kernel +theorem child_required_sub_693_i5 : ∀ j, childrenC_693_i5 j ⊆ insert (5, 6) required_693_i5 := by decide +kernel +theorem child_envelope_sub_693_i5 : ∀ j, childrenD_693_i5 j ⊆ envelope_693_i5 := by decide +kernel +theorem pivot_mem_693_i5 : (5, 6) ∈ envelope_693_i5 := by decide +kernel +theorem children_work_693_i5 : ∀ j, Template HasSnaky 6 (childrenC_693_i5 j) (childrenD_693_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 6 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_52 4 (5, 8)).mono (by decide +kernel) + · exact row_works_693_i6.mono (by decide +kernel) +theorem row_works_693_i5 : Template HasSnaky 7 required_693_i5 envelope_693_i5 := by + refine compose HasSnaky 6 childrenC_693_i5 childrenD_693_i5 children_work_693_i5 (5, 6) + required_693_i5 envelope_693_i5 pivot_mem_693_i5 child_required_sub_693_i5 child_envelope_sub_693_i5 ?_ + intro b hb + exact common_sub_693_i5 (mem_commonEnvelope childrenD_693_i5 b hb) +def required_693_i0 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 5), (7, 5), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_693_i0 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 5), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 8), (7, 9), (8, 7), (8, 8), (8, 9), (9, 7), (9, 8), (9, 9), (10, 7), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_693_i0 : Fin 5 → Finset Cell := ![(placed21 6 (7, 10) required_319), required_693_i1, required_693_i2, required_693_i3, required_693_i5] +def childrenD_693_i0 : Fin 5 → Finset Cell := ![(placed21 6 (7, 10) envelope_319), envelope_693_i1, envelope_693_i2, envelope_693_i3, envelope_693_i5] +theorem common_sub_693_i0 : commonEnvelope childrenD_693_i0 ⊆ insert (5, 7) required_693_i0 := by decide +kernel +theorem child_required_sub_693_i0 : ∀ j, childrenC_693_i0 j ⊆ insert (5, 7) required_693_i0 := by decide +kernel +theorem child_envelope_sub_693_i0 : ∀ j, childrenD_693_i0 j ⊆ envelope_693_i0 := by decide +kernel +theorem pivot_mem_693_i0 : (5, 7) ∈ envelope_693_i0 := by decide +kernel +theorem children_work_693_i0 : ∀ j, Template HasSnaky 11 (childrenC_693_i0 j) (childrenD_693_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_319 6 (7, 10)).mono (by decide +kernel) + · exact row_works_693_i1.mono (by decide +kernel) + · exact row_works_693_i2.mono (by decide +kernel) + · exact row_works_693_i3.mono (by decide +kernel) + · exact row_works_693_i5.mono (by decide +kernel) +theorem row_works_693_i0 : Template HasSnaky 12 required_693_i0 envelope_693_i0 := by + refine compose HasSnaky 11 childrenC_693_i0 childrenD_693_i0 children_work_693_i0 (5, 7) + required_693_i0 envelope_693_i0 pivot_mem_693_i0 child_required_sub_693_i0 child_envelope_sub_693_i0 ?_ + intro b hb + exact common_sub_693_i0 (mem_commonEnvelope childrenD_693_i0 b hb) +def required_693 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_693 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 5), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 1), (3, 2), (3, 3), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (11, 7), (11, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_693 : Fin 4 → Finset Cell := ![(placed21 0 (4, 4) required_147), (placed21 7 (8, 8) required_339), (placed21 1 (2, 5) required_692), required_693_i0] +def childrenD_693 : Fin 4 → Finset Cell := ![(placed21 0 (4, 4) envelope_147), (placed21 7 (8, 8) envelope_339), (placed21 1 (2, 5) envelope_692), envelope_693_i0] +theorem common_sub_693 : commonEnvelope childrenD_693 ⊆ insert (7, 8) required_693 := by decide +kernel +theorem child_required_sub_693 : ∀ j, childrenC_693 j ⊆ insert (7, 8) required_693 := by decide +kernel +theorem child_envelope_sub_693 : ∀ j, childrenD_693 j ⊆ envelope_693 := by decide +kernel +theorem pivot_mem_693 : (7, 8) ∈ envelope_693 := by decide +kernel +theorem children_work_693 : ∀ j, Template HasSnaky 13 (childrenC_693 j) (childrenD_693 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_147 0 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_339 7 (8, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_692 1 (2, 5)).mono (by decide +kernel) + · exact row_works_693_i0.mono (by decide +kernel) +theorem row_works_693 : Template HasSnaky 14 required_693 envelope_693 := by + refine compose HasSnaky 13 childrenC_693 childrenD_693 children_work_693 (7, 8) + required_693 envelope_693 pivot_mem_693 child_required_sub_693 child_envelope_sub_693 ?_ + intro b hb + exact common_sub_693 (mem_commonEnvelope childrenD_693 b hb) +def height_645_i0 : ℕ := 6 +def childrenH_645_i0 : Fin 4 → ℕ := ![height_44, height_52, height_128, height_144] +theorem height_exact_645_i0 : height_645_i0 = 1 + Finset.univ.sup childrenH_645_i0 := by decide +kernel +theorem required_origin_645_i0 : ∀ x ∈ required_645_i0, + (∃ j, x ∈ childrenC_645_i0 j) ∨ ∀ j, x ∈ childrenD_645_i0 j := by decide +kernel +theorem required_exact_645_i0 : required_645_i0 = + ((Finset.univ.biUnion childrenC_645_i0) ∪ commonEnvelope childrenD_645_i0).erase (5, 4) := by + exact required_eq_combination childrenC_645_i0 childrenD_645_i0 (5, 4) required_645_i0 + (by decide +kernel) child_required_sub_645_i0 common_sub_645_i0 required_origin_645_i0 +theorem envelope_origin_645_i0 : ∀ x ∈ envelope_645_i0, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_645_i0 j := by decide +kernel +theorem envelope_exact_645_i0 : envelope_645_i0 = + insert (5, 4) (Finset.univ.biUnion childrenD_645_i0) := by + exact envelope_eq_combination childrenD_645_i0 (5, 4) envelope_645_i0 + pivot_mem_645_i0 child_envelope_sub_645_i0 envelope_origin_645_i0 +def checked_645_i0 : CheckedCard where + required := required_645_i0 + envelope := envelope_645_i0 + height := height_645_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_645_i0 +def height_645_i1 : ℕ := 11 +def childrenH_645_i1 : Fin 6 → ℕ := ![height_104, height_359, height_438, height_452, height_476, height_479] +theorem height_exact_645_i1 : height_645_i1 = 1 + Finset.univ.sup childrenH_645_i1 := by decide +kernel +theorem required_origin_645_i1 : ∀ x ∈ required_645_i1, + (∃ j, x ∈ childrenC_645_i1 j) ∨ ∀ j, x ∈ childrenD_645_i1 j := by decide +kernel +theorem required_exact_645_i1 : required_645_i1 = + ((Finset.univ.biUnion childrenC_645_i1) ∪ commonEnvelope childrenD_645_i1).erase (6, 5) := by + exact required_eq_combination childrenC_645_i1 childrenD_645_i1 (6, 5) required_645_i1 + (by decide +kernel) child_required_sub_645_i1 common_sub_645_i1 required_origin_645_i1 +theorem envelope_origin_645_i1 : ∀ x ∈ envelope_645_i1, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_645_i1 j := by decide +kernel +theorem envelope_exact_645_i1 : envelope_645_i1 = + insert (6, 5) (Finset.univ.biUnion childrenD_645_i1) := by + exact envelope_eq_combination childrenD_645_i1 (6, 5) envelope_645_i1 + pivot_mem_645_i1 child_envelope_sub_645_i1 envelope_origin_645_i1 +def checked_645_i1 : CheckedCard where + required := required_645_i1 + envelope := envelope_645_i1 + height := height_645_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_645_i1 +def height_645 : ℕ := 14 +def childrenH_645 : Fin 10 → ℕ := ![height_120, height_276, height_338, height_437, height_611, height_634, height_642, height_643, height_645_i0, height_645_i1] +theorem height_exact_645 : height_645 = 1 + Finset.univ.sup childrenH_645 := by decide +kernel +theorem required_origin_645 : ∀ x ∈ required_645, + (∃ j, x ∈ childrenC_645 j) ∨ ∀ j, x ∈ childrenD_645 j := by decide +kernel +theorem required_exact_645 : required_645 = + ((Finset.univ.biUnion childrenC_645) ∪ commonEnvelope childrenD_645).erase (6, 4) := by + exact required_eq_combination childrenC_645 childrenD_645 (6, 4) required_645 + (by decide +kernel) child_required_sub_645 common_sub_645 required_origin_645 +theorem envelope_origin_645 : ∀ x ∈ envelope_645, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_645 j := by decide +kernel +theorem envelope_exact_645 : envelope_645 = + insert (6, 4) (Finset.univ.biUnion childrenD_645) := by + exact envelope_eq_combination childrenD_645 (6, 4) envelope_645 + pivot_mem_645 child_envelope_sub_645 envelope_origin_645 +def checked_645 : CheckedCard where + required := required_645 + envelope := envelope_645 + height := height_645 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_645 +def height_669_i5 : ℕ := 3 +def childrenH_669_i5 : Fin 2 → ℕ := ![height_0, height_66] +theorem height_exact_669_i5 : height_669_i5 = 1 + Finset.univ.sup childrenH_669_i5 := by decide +kernel +theorem required_origin_669_i5 : ∀ x ∈ required_669_i5, + (∃ j, x ∈ childrenC_669_i5 j) ∨ ∀ j, x ∈ childrenD_669_i5 j := by decide +kernel +theorem required_exact_669_i5 : required_669_i5 = + ((Finset.univ.biUnion childrenC_669_i5) ∪ commonEnvelope childrenD_669_i5).erase (5, 6) := by + exact required_eq_combination childrenC_669_i5 childrenD_669_i5 (5, 6) required_669_i5 + (by decide +kernel) child_required_sub_669_i5 common_sub_669_i5 required_origin_669_i5 +theorem envelope_origin_669_i5 : ∀ x ∈ envelope_669_i5, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_669_i5 j := by decide +kernel +theorem envelope_exact_669_i5 : envelope_669_i5 = + insert (5, 6) (Finset.univ.biUnion childrenD_669_i5) := by + exact envelope_eq_combination childrenD_669_i5 (5, 6) envelope_669_i5 + pivot_mem_669_i5 child_envelope_sub_669_i5 envelope_origin_669_i5 +def checked_669_i5 : CheckedCard where + required := required_669_i5 + envelope := envelope_669_i5 + height := height_669_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_669_i5 +def height_669_i4 : ℕ := 4 +def childrenH_669_i4 : Fin 2 → ℕ := ![height_0, height_669_i5] +theorem height_exact_669_i4 : height_669_i4 = 1 + Finset.univ.sup childrenH_669_i4 := by decide +kernel +theorem required_origin_669_i4 : ∀ x ∈ required_669_i4, + (∃ j, x ∈ childrenC_669_i4 j) ∨ ∀ j, x ∈ childrenD_669_i4 j := by decide +kernel +theorem required_exact_669_i4 : required_669_i4 = + ((Finset.univ.biUnion childrenC_669_i4) ∪ commonEnvelope childrenD_669_i4).erase (4, 6) := by + exact required_eq_combination childrenC_669_i4 childrenD_669_i4 (4, 6) required_669_i4 + (by decide +kernel) child_required_sub_669_i4 common_sub_669_i4 required_origin_669_i4 +theorem envelope_origin_669_i4 : ∀ x ∈ envelope_669_i4, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_669_i4 j := by decide +kernel +theorem envelope_exact_669_i4 : envelope_669_i4 = + insert (4, 6) (Finset.univ.biUnion childrenD_669_i4) := by + exact envelope_eq_combination childrenD_669_i4 (4, 6) envelope_669_i4 + pivot_mem_669_i4 child_envelope_sub_669_i4 envelope_origin_669_i4 +def checked_669_i4 : CheckedCard where + required := required_669_i4 + envelope := envelope_669_i4 + height := height_669_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_669_i4 +def height_669_i6 : ℕ := 3 +def childrenH_669_i6 : Fin 2 → ℕ := ![height_5, height_36] +theorem height_exact_669_i6 : height_669_i6 = 1 + Finset.univ.sup childrenH_669_i6 := by decide +kernel +theorem required_origin_669_i6 : ∀ x ∈ required_669_i6, + (∃ j, x ∈ childrenC_669_i6 j) ∨ ∀ j, x ∈ childrenD_669_i6 j := by decide +kernel +theorem required_exact_669_i6 : required_669_i6 = + ((Finset.univ.biUnion childrenC_669_i6) ∪ commonEnvelope childrenD_669_i6).erase (3, 7) := by + exact required_eq_combination childrenC_669_i6 childrenD_669_i6 (3, 7) required_669_i6 + (by decide +kernel) child_required_sub_669_i6 common_sub_669_i6 required_origin_669_i6 +theorem envelope_origin_669_i6 : ∀ x ∈ envelope_669_i6, + x = (3, 7) ∨ ∃ j, x ∈ childrenD_669_i6 j := by decide +kernel +theorem envelope_exact_669_i6 : envelope_669_i6 = + insert (3, 7) (Finset.univ.biUnion childrenD_669_i6) := by + exact envelope_eq_combination childrenD_669_i6 (3, 7) envelope_669_i6 + pivot_mem_669_i6 child_envelope_sub_669_i6 envelope_origin_669_i6 +def checked_669_i6 : CheckedCard where + required := required_669_i6 + envelope := envelope_669_i6 + height := height_669_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_669_i6 +def height_669_i7 : ℕ := 4 +def childrenH_669_i7 : Fin 2 → ℕ := ![height_24, height_36] +theorem height_exact_669_i7 : height_669_i7 = 1 + Finset.univ.sup childrenH_669_i7 := by decide +kernel +theorem required_origin_669_i7 : ∀ x ∈ required_669_i7, + (∃ j, x ∈ childrenC_669_i7 j) ∨ ∀ j, x ∈ childrenD_669_i7 j := by decide +kernel +theorem required_exact_669_i7 : required_669_i7 = + ((Finset.univ.biUnion childrenC_669_i7) ∪ commonEnvelope childrenD_669_i7).erase (3, 7) := by + exact required_eq_combination childrenC_669_i7 childrenD_669_i7 (3, 7) required_669_i7 + (by decide +kernel) child_required_sub_669_i7 common_sub_669_i7 required_origin_669_i7 +theorem envelope_origin_669_i7 : ∀ x ∈ envelope_669_i7, + x = (3, 7) ∨ ∃ j, x ∈ childrenD_669_i7 j := by decide +kernel +theorem envelope_exact_669_i7 : envelope_669_i7 = + insert (3, 7) (Finset.univ.biUnion childrenD_669_i7) := by + exact envelope_eq_combination childrenD_669_i7 (3, 7) envelope_669_i7 + pivot_mem_669_i7 child_envelope_sub_669_i7 envelope_origin_669_i7 +def checked_669_i7 : CheckedCard where + required := required_669_i7 + envelope := envelope_669_i7 + height := height_669_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_669_i7 +def height_669_i3 : ℕ := 5 +def childrenH_669_i3 : Fin 4 → ℕ := ![height_48, height_669_i4, height_669_i6, height_669_i7] +theorem height_exact_669_i3 : height_669_i3 = 1 + Finset.univ.sup childrenH_669_i3 := by decide +kernel +theorem required_origin_669_i3 : ∀ x ∈ required_669_i3, + (∃ j, x ∈ childrenC_669_i3 j) ∨ ∀ j, x ∈ childrenD_669_i3 j := by decide +kernel +theorem required_exact_669_i3 : required_669_i3 = + ((Finset.univ.biUnion childrenC_669_i3) ∪ commonEnvelope childrenD_669_i3).erase (4, 7) := by + exact required_eq_combination childrenC_669_i3 childrenD_669_i3 (4, 7) required_669_i3 + (by decide +kernel) child_required_sub_669_i3 common_sub_669_i3 required_origin_669_i3 +theorem envelope_origin_669_i3 : ∀ x ∈ envelope_669_i3, + x = (4, 7) ∨ ∃ j, x ∈ childrenD_669_i3 j := by decide +kernel +theorem envelope_exact_669_i3 : envelope_669_i3 = + insert (4, 7) (Finset.univ.biUnion childrenD_669_i3) := by + exact envelope_eq_combination childrenD_669_i3 (4, 7) envelope_669_i3 + pivot_mem_669_i3 child_envelope_sub_669_i3 envelope_origin_669_i3 +def checked_669_i3 : CheckedCard where + required := required_669_i3 + envelope := envelope_669_i3 + height := height_669_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_669_i3 +def height_669_i2 : ℕ := 6 +def childrenH_669_i2 : Fin 2 → ℕ := ![height_5, height_669_i3] +theorem height_exact_669_i2 : height_669_i2 = 1 + Finset.univ.sup childrenH_669_i2 := by decide +kernel +theorem required_origin_669_i2 : ∀ x ∈ required_669_i2, + (∃ j, x ∈ childrenC_669_i2 j) ∨ ∀ j, x ∈ childrenD_669_i2 j := by decide +kernel +theorem required_exact_669_i2 : required_669_i2 = + ((Finset.univ.biUnion childrenC_669_i2) ∪ commonEnvelope childrenD_669_i2).erase (5, 7) := by + exact required_eq_combination childrenC_669_i2 childrenD_669_i2 (5, 7) required_669_i2 + (by decide +kernel) child_required_sub_669_i2 common_sub_669_i2 required_origin_669_i2 +theorem envelope_origin_669_i2 : ∀ x ∈ envelope_669_i2, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_669_i2 j := by decide +kernel +theorem envelope_exact_669_i2 : envelope_669_i2 = + insert (5, 7) (Finset.univ.biUnion childrenD_669_i2) := by + exact envelope_eq_combination childrenD_669_i2 (5, 7) envelope_669_i2 + pivot_mem_669_i2 child_envelope_sub_669_i2 envelope_origin_669_i2 +def checked_669_i2 : CheckedCard where + required := required_669_i2 + envelope := envelope_669_i2 + height := height_669_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_669_i2 +def height_669_i1 : ℕ := 7 +def childrenH_669_i1 : Fin 2 → ℕ := ![height_25, height_669_i2] +theorem height_exact_669_i1 : height_669_i1 = 1 + Finset.univ.sup childrenH_669_i1 := by decide +kernel +theorem required_origin_669_i1 : ∀ x ∈ required_669_i1, + (∃ j, x ∈ childrenC_669_i1 j) ∨ ∀ j, x ∈ childrenD_669_i1 j := by decide +kernel +theorem required_exact_669_i1 : required_669_i1 = + ((Finset.univ.biUnion childrenC_669_i1) ∪ commonEnvelope childrenD_669_i1).erase (4, 5) := by + exact required_eq_combination childrenC_669_i1 childrenD_669_i1 (4, 5) required_669_i1 + (by decide +kernel) child_required_sub_669_i1 common_sub_669_i1 required_origin_669_i1 +theorem envelope_origin_669_i1 : ∀ x ∈ envelope_669_i1, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_669_i1 j := by decide +kernel +theorem envelope_exact_669_i1 : envelope_669_i1 = + insert (4, 5) (Finset.univ.biUnion childrenD_669_i1) := by + exact envelope_eq_combination childrenD_669_i1 (4, 5) envelope_669_i1 + pivot_mem_669_i1 child_envelope_sub_669_i1 envelope_origin_669_i1 +def checked_669_i1 : CheckedCard where + required := required_669_i1 + envelope := envelope_669_i1 + height := height_669_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_669_i1 +def height_669_i0 : ℕ := 8 +def childrenH_669_i0 : Fin 4 → ℕ := ![height_19, height_197, height_225, height_669_i1] +theorem height_exact_669_i0 : height_669_i0 = 1 + Finset.univ.sup childrenH_669_i0 := by decide +kernel +theorem required_origin_669_i0 : ∀ x ∈ required_669_i0, + (∃ j, x ∈ childrenC_669_i0 j) ∨ ∀ j, x ∈ childrenD_669_i0 j := by decide +kernel +theorem required_exact_669_i0 : required_669_i0 = + ((Finset.univ.biUnion childrenC_669_i0) ∪ commonEnvelope childrenD_669_i0).erase (6, 7) := by + exact required_eq_combination childrenC_669_i0 childrenD_669_i0 (6, 7) required_669_i0 + (by decide +kernel) child_required_sub_669_i0 common_sub_669_i0 required_origin_669_i0 +theorem envelope_origin_669_i0 : ∀ x ∈ envelope_669_i0, + x = (6, 7) ∨ ∃ j, x ∈ childrenD_669_i0 j := by decide +kernel +theorem envelope_exact_669_i0 : envelope_669_i0 = + insert (6, 7) (Finset.univ.biUnion childrenD_669_i0) := by + exact envelope_eq_combination childrenD_669_i0 (6, 7) envelope_669_i0 + pivot_mem_669_i0 child_envelope_sub_669_i0 envelope_origin_669_i0 +def checked_669_i0 : CheckedCard where + required := required_669_i0 + envelope := envelope_669_i0 + height := height_669_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_669_i0 +def height_669 : ℕ := 14 +def childrenH_669 : Fin 4 → ℕ := ![height_188, height_590, height_668, height_669_i0] +theorem height_exact_669 : height_669 = 1 + Finset.univ.sup childrenH_669 := by decide +kernel +theorem required_origin_669 : ∀ x ∈ required_669, + (∃ j, x ∈ childrenC_669 j) ∨ ∀ j, x ∈ childrenD_669 j := by decide +kernel +theorem required_exact_669 : required_669 = + ((Finset.univ.biUnion childrenC_669) ∪ commonEnvelope childrenD_669).erase (6, 4) := by + exact required_eq_combination childrenC_669 childrenD_669 (6, 4) required_669 + (by decide +kernel) child_required_sub_669 common_sub_669 required_origin_669 +theorem envelope_origin_669 : ∀ x ∈ envelope_669, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_669 j := by decide +kernel +theorem envelope_exact_669 : envelope_669 = + insert (6, 4) (Finset.univ.biUnion childrenD_669) := by + exact envelope_eq_combination childrenD_669 (6, 4) envelope_669 + pivot_mem_669 child_envelope_sub_669 envelope_origin_669 +def checked_669 : CheckedCard where + required := required_669 + envelope := envelope_669 + height := height_669 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_669 +def height_693_i1 : ℕ := 11 +def childrenH_693_i1 : Fin 2 → ℕ := ![height_28, height_409] +theorem height_exact_693_i1 : height_693_i1 = 1 + Finset.univ.sup childrenH_693_i1 := by decide +kernel +theorem required_origin_693_i1 : ∀ x ∈ required_693_i1, + (∃ j, x ∈ childrenC_693_i1 j) ∨ ∀ j, x ∈ childrenD_693_i1 j := by decide +kernel +theorem required_exact_693_i1 : required_693_i1 = + ((Finset.univ.biUnion childrenC_693_i1) ∪ commonEnvelope childrenD_693_i1).erase (5, 8) := by + exact required_eq_combination childrenC_693_i1 childrenD_693_i1 (5, 8) required_693_i1 + (by decide +kernel) child_required_sub_693_i1 common_sub_693_i1 required_origin_693_i1 +theorem envelope_origin_693_i1 : ∀ x ∈ envelope_693_i1, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_693_i1 j := by decide +kernel +theorem envelope_exact_693_i1 : envelope_693_i1 = + insert (5, 8) (Finset.univ.biUnion childrenD_693_i1) := by + exact envelope_eq_combination childrenD_693_i1 (5, 8) envelope_693_i1 + pivot_mem_693_i1 child_envelope_sub_693_i1 envelope_origin_693_i1 +def checked_693_i1 : CheckedCard where + required := required_693_i1 + envelope := envelope_693_i1 + height := height_693_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_693_i1 +def height_693_i2 : ℕ := 11 +def childrenH_693_i2 : Fin 3 → ℕ := ![height_168, height_409, height_611] +theorem height_exact_693_i2 : height_693_i2 = 1 + Finset.univ.sup childrenH_693_i2 := by decide +kernel +theorem required_origin_693_i2 : ∀ x ∈ required_693_i2, + (∃ j, x ∈ childrenC_693_i2 j) ∨ ∀ j, x ∈ childrenD_693_i2 j := by decide +kernel +theorem required_exact_693_i2 : required_693_i2 = + ((Finset.univ.biUnion childrenC_693_i2) ∪ commonEnvelope childrenD_693_i2).erase (5, 8) := by + exact required_eq_combination childrenC_693_i2 childrenD_693_i2 (5, 8) required_693_i2 + (by decide +kernel) child_required_sub_693_i2 common_sub_693_i2 required_origin_693_i2 +theorem envelope_origin_693_i2 : ∀ x ∈ envelope_693_i2, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_693_i2 j := by decide +kernel +theorem envelope_exact_693_i2 : envelope_693_i2 = + insert (5, 8) (Finset.univ.biUnion childrenD_693_i2) := by + exact envelope_eq_combination childrenD_693_i2 (5, 8) envelope_693_i2 + pivot_mem_693_i2 child_envelope_sub_693_i2 envelope_origin_693_i2 +def checked_693_i2 : CheckedCard where + required := required_693_i2 + envelope := envelope_693_i2 + height := height_693_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_693_i2 +def height_693_i4 : ℕ := 6 +def childrenH_693_i4 : Fin 2 → ℕ := ![height_10, height_308] +theorem height_exact_693_i4 : height_693_i4 = 1 + Finset.univ.sup childrenH_693_i4 := by decide +kernel +theorem required_origin_693_i4 : ∀ x ∈ required_693_i4, + (∃ j, x ∈ childrenC_693_i4 j) ∨ ∀ j, x ∈ childrenD_693_i4 j := by decide +kernel +theorem required_exact_693_i4 : required_693_i4 = + ((Finset.univ.biUnion childrenC_693_i4) ∪ commonEnvelope childrenD_693_i4).erase (5, 4) := by + exact required_eq_combination childrenC_693_i4 childrenD_693_i4 (5, 4) required_693_i4 + (by decide +kernel) child_required_sub_693_i4 common_sub_693_i4 required_origin_693_i4 +theorem envelope_origin_693_i4 : ∀ x ∈ envelope_693_i4, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_693_i4 j := by decide +kernel +theorem envelope_exact_693_i4 : envelope_693_i4 = + insert (5, 4) (Finset.univ.biUnion childrenD_693_i4) := by + exact envelope_eq_combination childrenD_693_i4 (5, 4) envelope_693_i4 + pivot_mem_693_i4 child_envelope_sub_693_i4 envelope_origin_693_i4 +def checked_693_i4 : CheckedCard where + required := required_693_i4 + envelope := envelope_693_i4 + height := height_693_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_693_i4 +def height_693_i3 : ℕ := 7 +def childrenH_693_i3 : Fin 4 → ℕ := ![height_6, height_26, height_214, height_693_i4] +theorem height_exact_693_i3 : height_693_i3 = 1 + Finset.univ.sup childrenH_693_i3 := by decide +kernel +theorem required_origin_693_i3 : ∀ x ∈ required_693_i3, + (∃ j, x ∈ childrenC_693_i3 j) ∨ ∀ j, x ∈ childrenD_693_i3 j := by decide +kernel +theorem required_exact_693_i3 : required_693_i3 = + ((Finset.univ.biUnion childrenC_693_i3) ∪ commonEnvelope childrenD_693_i3).erase (3, 5) := by + exact required_eq_combination childrenC_693_i3 childrenD_693_i3 (3, 5) required_693_i3 + (by decide +kernel) child_required_sub_693_i3 common_sub_693_i3 required_origin_693_i3 +theorem envelope_origin_693_i3 : ∀ x ∈ envelope_693_i3, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_693_i3 j := by decide +kernel +theorem envelope_exact_693_i3 : envelope_693_i3 = + insert (3, 5) (Finset.univ.biUnion childrenD_693_i3) := by + exact envelope_eq_combination childrenD_693_i3 (3, 5) envelope_693_i3 + pivot_mem_693_i3 child_envelope_sub_693_i3 envelope_origin_693_i3 +def checked_693_i3 : CheckedCard where + required := required_693_i3 + envelope := envelope_693_i3 + height := height_693_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_693_i3 +def height_693_i6 : ℕ := 6 +def childrenH_693_i6 : Fin 3 → ℕ := ![height_233, height_314, height_314] +theorem height_exact_693_i6 : height_693_i6 = 1 + Finset.univ.sup childrenH_693_i6 := by decide +kernel +theorem required_origin_693_i6 : ∀ x ∈ required_693_i6, + (∃ j, x ∈ childrenC_693_i6 j) ∨ ∀ j, x ∈ childrenD_693_i6 j := by decide +kernel +theorem required_exact_693_i6 : required_693_i6 = + ((Finset.univ.biUnion childrenC_693_i6) ∪ commonEnvelope childrenD_693_i6).erase (5, 4) := by + exact required_eq_combination childrenC_693_i6 childrenD_693_i6 (5, 4) required_693_i6 + (by decide +kernel) child_required_sub_693_i6 common_sub_693_i6 required_origin_693_i6 +theorem envelope_origin_693_i6 : ∀ x ∈ envelope_693_i6, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_693_i6 j := by decide +kernel +theorem envelope_exact_693_i6 : envelope_693_i6 = + insert (5, 4) (Finset.univ.biUnion childrenD_693_i6) := by + exact envelope_eq_combination childrenD_693_i6 (5, 4) envelope_693_i6 + pivot_mem_693_i6 child_envelope_sub_693_i6 envelope_origin_693_i6 +def checked_693_i6 : CheckedCard where + required := required_693_i6 + envelope := envelope_693_i6 + height := height_693_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_693_i6 +def height_693_i5 : ℕ := 7 +def childrenH_693_i5 : Fin 3 → ℕ := ![height_44, height_52, height_693_i6] +theorem height_exact_693_i5 : height_693_i5 = 1 + Finset.univ.sup childrenH_693_i5 := by decide +kernel +theorem required_origin_693_i5 : ∀ x ∈ required_693_i5, + (∃ j, x ∈ childrenC_693_i5 j) ∨ ∀ j, x ∈ childrenD_693_i5 j := by decide +kernel +theorem required_exact_693_i5 : required_693_i5 = + ((Finset.univ.biUnion childrenC_693_i5) ∪ commonEnvelope childrenD_693_i5).erase (5, 6) := by + exact required_eq_combination childrenC_693_i5 childrenD_693_i5 (5, 6) required_693_i5 + (by decide +kernel) child_required_sub_693_i5 common_sub_693_i5 required_origin_693_i5 +theorem envelope_origin_693_i5 : ∀ x ∈ envelope_693_i5, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_693_i5 j := by decide +kernel +theorem envelope_exact_693_i5 : envelope_693_i5 = + insert (5, 6) (Finset.univ.biUnion childrenD_693_i5) := by + exact envelope_eq_combination childrenD_693_i5 (5, 6) envelope_693_i5 + pivot_mem_693_i5 child_envelope_sub_693_i5 envelope_origin_693_i5 +def checked_693_i5 : CheckedCard where + required := required_693_i5 + envelope := envelope_693_i5 + height := height_693_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_693_i5 +def height_693_i0 : ℕ := 12 +def childrenH_693_i0 : Fin 5 → ℕ := ![height_319, height_693_i1, height_693_i2, height_693_i3, height_693_i5] +theorem height_exact_693_i0 : height_693_i0 = 1 + Finset.univ.sup childrenH_693_i0 := by decide +kernel +theorem required_origin_693_i0 : ∀ x ∈ required_693_i0, + (∃ j, x ∈ childrenC_693_i0 j) ∨ ∀ j, x ∈ childrenD_693_i0 j := by decide +kernel +theorem required_exact_693_i0 : required_693_i0 = + ((Finset.univ.biUnion childrenC_693_i0) ∪ commonEnvelope childrenD_693_i0).erase (5, 7) := by + exact required_eq_combination childrenC_693_i0 childrenD_693_i0 (5, 7) required_693_i0 + (by decide +kernel) child_required_sub_693_i0 common_sub_693_i0 required_origin_693_i0 +theorem envelope_origin_693_i0 : ∀ x ∈ envelope_693_i0, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_693_i0 j := by decide +kernel +theorem envelope_exact_693_i0 : envelope_693_i0 = + insert (5, 7) (Finset.univ.biUnion childrenD_693_i0) := by + exact envelope_eq_combination childrenD_693_i0 (5, 7) envelope_693_i0 + pivot_mem_693_i0 child_envelope_sub_693_i0 envelope_origin_693_i0 +def checked_693_i0 : CheckedCard where + required := required_693_i0 + envelope := envelope_693_i0 + height := height_693_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_693_i0 +def height_693 : ℕ := 14 +def childrenH_693 : Fin 4 → ℕ := ![height_147, height_339, height_692, height_693_i0] +theorem height_exact_693 : height_693 = 1 + Finset.univ.sup childrenH_693 := by decide +kernel +theorem required_origin_693 : ∀ x ∈ required_693, + (∃ j, x ∈ childrenC_693 j) ∨ ∀ j, x ∈ childrenD_693 j := by decide +kernel +theorem required_exact_693 : required_693 = + ((Finset.univ.biUnion childrenC_693) ∪ commonEnvelope childrenD_693).erase (7, 8) := by + exact required_eq_combination childrenC_693 childrenD_693 (7, 8) required_693 + (by decide +kernel) child_required_sub_693 common_sub_693 required_origin_693 +theorem envelope_origin_693 : ∀ x ∈ envelope_693, + x = (7, 8) ∨ ∃ j, x ∈ childrenD_693 j := by decide +kernel +theorem envelope_exact_693 : envelope_693 = + insert (7, 8) (Finset.univ.biUnion childrenD_693) := by + exact envelope_eq_combination childrenD_693 (7, 8) envelope_693 + pivot_mem_693 child_envelope_sub_693 envelope_origin_693 +def checked_693 : CheckedCard where + required := required_693 + envelope := envelope_693 + height := height_693 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_693 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part04.lean new file mode 100644 index 0000000..ed3b984 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part04.lean @@ -0,0 +1,642 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part05 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_697_i4 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3), (5, 3), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_697_i4 : Finset Cell := ⟨(([(0, 2), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3), (4, 2), (4, 3), (5, 2), (5, 3), (5, 4), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_697_i4 : Fin 2 → Finset Cell := ![(placed21 7 (5, 3) required_16), (placed21 0 (2, 2) required_374)] +def childrenD_697_i4 : Fin 2 → Finset Cell := ![(placed21 7 (5, 3) envelope_16), (placed21 0 (2, 2) envelope_374)] +theorem common_sub_697_i4 : commonEnvelope childrenD_697_i4 ⊆ insert (5, 2) required_697_i4 := by decide +kernel +theorem child_required_sub_697_i4 : ∀ j, childrenC_697_i4 j ⊆ insert (5, 2) required_697_i4 := by decide +kernel +theorem child_envelope_sub_697_i4 : ∀ j, childrenD_697_i4 j ⊆ envelope_697_i4 := by decide +kernel +theorem pivot_mem_697_i4 : (5, 2) ∈ envelope_697_i4 := by decide +kernel +theorem children_work_697_i4 : ∀ j, Template HasSnaky 3 (childrenC_697_i4 j) (childrenD_697_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_16 7 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_374 0 (2, 2)).mono (by decide +kernel) +theorem row_works_697_i4 : Template HasSnaky 4 required_697_i4 envelope_697_i4 := by + refine compose HasSnaky 3 childrenC_697_i4 childrenD_697_i4 children_work_697_i4 (5, 2) + required_697_i4 envelope_697_i4 pivot_mem_697_i4 child_required_sub_697_i4 child_envelope_sub_697_i4 ?_ + intro b hb + exact common_sub_697_i4 (mem_commonEnvelope childrenD_697_i4 b hb) +def required_697_i3 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 6), (4, 3), (5, 3), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_697_i3 : Finset Cell := ⟨(([(0, 2), (0, 5), (0, 7), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 3), (3, 6), (3, 7), (4, 2), (4, 3), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 4), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_697_i3 : Fin 2 → Finset Cell := ![(placed21 7 (9, 7) required_95), required_697_i4] +def childrenD_697_i3 : Fin 2 → Finset Cell := ![(placed21 7 (9, 7) envelope_95), envelope_697_i4] +theorem common_sub_697_i3 : commonEnvelope childrenD_697_i3 ⊆ insert (6, 6) required_697_i3 := by decide +kernel +theorem child_required_sub_697_i3 : ∀ j, childrenC_697_i3 j ⊆ insert (6, 6) required_697_i3 := by decide +kernel +theorem child_envelope_sub_697_i3 : ∀ j, childrenD_697_i3 j ⊆ envelope_697_i3 := by decide +kernel +theorem pivot_mem_697_i3 : (6, 6) ∈ envelope_697_i3 := by decide +kernel +theorem children_work_697_i3 : ∀ j, Template HasSnaky 6 (childrenC_697_i3 j) (childrenD_697_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_95 7 (9, 7)).mono (by decide +kernel) + · exact row_works_697_i4.mono (by decide +kernel) +theorem row_works_697_i3 : Template HasSnaky 7 required_697_i3 envelope_697_i3 := by + refine compose HasSnaky 6 childrenC_697_i3 childrenD_697_i3 children_work_697_i3 (6, 6) + required_697_i3 envelope_697_i3 pivot_mem_697_i3 child_required_sub_697_i3 child_envelope_sub_697_i3 ?_ + intro b hb + exact common_sub_697_i3 (mem_commonEnvelope childrenD_697_i3 b hb) +def required_697_i2 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 6), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_697_i2 : Finset Cell := ⟨(([(0, 2), (0, 5), (0, 7), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 3), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_697_i2 : Fin 3 → Finset Cell := ![(placed21 7 (6, 6) required_151), (placed21 5 (8, 5) required_460), required_697_i3] +def childrenD_697_i2 : Fin 3 → Finset Cell := ![(placed21 7 (6, 6) envelope_151), (placed21 5 (8, 5) envelope_460), envelope_697_i3] +theorem common_sub_697_i2 : commonEnvelope childrenD_697_i2 ⊆ insert (5, 6) required_697_i2 := by decide +kernel +theorem child_required_sub_697_i2 : ∀ j, childrenC_697_i2 j ⊆ insert (5, 6) required_697_i2 := by decide +kernel +theorem child_envelope_sub_697_i2 : ∀ j, childrenD_697_i2 j ⊆ envelope_697_i2 := by decide +kernel +theorem pivot_mem_697_i2 : (5, 6) ∈ envelope_697_i2 := by decide +kernel +theorem children_work_697_i2 : ∀ j, Template HasSnaky 10 (childrenC_697_i2 j) (childrenD_697_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_151 7 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_460 5 (8, 5)).mono (by decide +kernel) + · exact row_works_697_i3.mono (by decide +kernel) +theorem row_works_697_i2 : Template HasSnaky 11 required_697_i2 envelope_697_i2 := by + refine compose HasSnaky 10 childrenC_697_i2 childrenD_697_i2 children_work_697_i2 (5, 6) + required_697_i2 envelope_697_i2 pivot_mem_697_i2 child_required_sub_697_i2 child_envelope_sub_697_i2 ?_ + intro b hb + exact common_sub_697_i2 (mem_commonEnvelope childrenD_697_i2 b hb) +def required_697_i1 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_697_i1 : Finset Cell := ⟨(([(0, 2), (0, 5), (0, 7), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_697_i1 : Fin 3 → Finset Cell := ![(placed21 2 (4, 2) required_39), (placed21 2 (5, 2) required_121), required_697_i2] +def childrenD_697_i1 : Fin 3 → Finset Cell := ![(placed21 2 (4, 2) envelope_39), (placed21 2 (5, 2) envelope_121), envelope_697_i2] +theorem common_sub_697_i1 : commonEnvelope childrenD_697_i1 ⊆ insert (3, 6) required_697_i1 := by decide +kernel +theorem child_required_sub_697_i1 : ∀ j, childrenC_697_i1 j ⊆ insert (3, 6) required_697_i1 := by decide +kernel +theorem child_envelope_sub_697_i1 : ∀ j, childrenD_697_i1 j ⊆ envelope_697_i1 := by decide +kernel +theorem pivot_mem_697_i1 : (3, 6) ∈ envelope_697_i1 := by decide +kernel +theorem children_work_697_i1 : ∀ j, Template HasSnaky 11 (childrenC_697_i1 j) (childrenD_697_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_39 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_121 2 (5, 2)).mono (by decide +kernel) + · exact row_works_697_i2.mono (by decide +kernel) +theorem row_works_697_i1 : Template HasSnaky 12 required_697_i1 envelope_697_i1 := by + refine compose HasSnaky 11 childrenC_697_i1 childrenD_697_i1 children_work_697_i1 (3, 6) + required_697_i1 envelope_697_i1 pivot_mem_697_i1 child_required_sub_697_i1 child_envelope_sub_697_i1 ?_ + intro b hb + exact common_sub_697_i1 (mem_commonEnvelope childrenD_697_i1 b hb) +def required_697_i0 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3), (5, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_697_i0 : Finset Cell := ⟨(([(0, 2), (0, 5), (0, 7), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_697_i0 : Fin 3 → Finset Cell := ![(placed21 1 (2, 3) required_21), (placed21 6 (5, 6) required_56), required_697_i1] +def childrenD_697_i0 : Fin 3 → Finset Cell := ![(placed21 1 (2, 3) envelope_21), (placed21 6 (5, 6) envelope_56), envelope_697_i1] +theorem common_sub_697_i0 : commonEnvelope childrenD_697_i0 ⊆ insert (3, 4) required_697_i0 := by decide +kernel +theorem child_required_sub_697_i0 : ∀ j, childrenC_697_i0 j ⊆ insert (3, 4) required_697_i0 := by decide +kernel +theorem child_envelope_sub_697_i0 : ∀ j, childrenD_697_i0 j ⊆ envelope_697_i0 := by decide +kernel +theorem pivot_mem_697_i0 : (3, 4) ∈ envelope_697_i0 := by decide +kernel +theorem children_work_697_i0 : ∀ j, Template HasSnaky 12 (childrenC_697_i0 j) (childrenD_697_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_56 6 (5, 6)).mono (by decide +kernel) + · exact row_works_697_i1.mono (by decide +kernel) +theorem row_works_697_i0 : Template HasSnaky 13 required_697_i0 envelope_697_i0 := by + refine compose HasSnaky 12 childrenC_697_i0 childrenD_697_i0 children_work_697_i0 (3, 4) + required_697_i0 envelope_697_i0 pivot_mem_697_i0 child_required_sub_697_i0 child_envelope_sub_697_i0 ?_ + intro b hb + exact common_sub_697_i0 (mem_commonEnvelope childrenD_697_i0 b hb) +def required_697 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_697 : Finset Cell := ⟨(([(0, 2), (0, 5), (0, 7), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 2), (8, 5), (8, 6), (8, 7), (9, 5), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_697 : Fin 4 → Finset Cell := ![(placed21 7 (6, 3) required_7), (placed21 0 (2, 2) required_8), required_690, required_697_i0] +def childrenD_697 : Fin 4 → Finset Cell := ![(placed21 7 (6, 3) envelope_7), (placed21 0 (2, 2) envelope_8), envelope_690, envelope_697_i0] +theorem common_sub_697 : commonEnvelope childrenD_697 ⊆ insert (5, 3) required_697 := by decide +kernel +theorem child_required_sub_697 : ∀ j, childrenC_697 j ⊆ insert (5, 3) required_697 := by decide +kernel +theorem child_envelope_sub_697 : ∀ j, childrenD_697 j ⊆ envelope_697 := by decide +kernel +theorem pivot_mem_697 : (5, 3) ∈ envelope_697 := by decide +kernel +theorem children_work_697 : ∀ j, Template HasSnaky 13 (childrenC_697 j) (childrenD_697 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 7 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_8 0 (2, 2)).mono (by decide +kernel) + · exact row_works_690.mono (by decide +kernel) + · exact row_works_697_i0.mono (by decide +kernel) +theorem row_works_697 : Template HasSnaky 14 required_697 envelope_697 := by + refine compose HasSnaky 13 childrenC_697 childrenD_697 children_work_697 (5, 3) + required_697 envelope_697 pivot_mem_697 child_required_sub_697 child_envelope_sub_697 ?_ + intro b hb + exact common_sub_697 (mem_commonEnvelope childrenD_697 b hb) +def required_705_i1 : Finset Cell := ⟨(([(2, 5), (3, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_705_i1 : Finset Cell := ⟨(([(2, 5), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (7, 8), (8, 6), (8, 7), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_705_i1 : Fin 6 → Finset Cell := ![(placed21 6 (6, 8) required_14), (placed21 4 (2, 7) required_79), (placed21 1 (3, 3) required_181), (placed21 2 (6, 2) required_189), (placed21 4 (4, 8) required_367), (placed21 1 (3, 3) required_474)] +def childrenD_705_i1 : Fin 6 → Finset Cell := ![(placed21 6 (6, 8) envelope_14), (placed21 4 (2, 7) envelope_79), (placed21 1 (3, 3) envelope_181), (placed21 2 (6, 2) envelope_189), (placed21 4 (4, 8) envelope_367), (placed21 1 (3, 3) envelope_474)] +theorem common_sub_705_i1 : commonEnvelope childrenD_705_i1 ⊆ insert (5, 6) required_705_i1 := by decide +kernel +theorem child_required_sub_705_i1 : ∀ j, childrenC_705_i1 j ⊆ insert (5, 6) required_705_i1 := by decide +kernel +theorem child_envelope_sub_705_i1 : ∀ j, childrenD_705_i1 j ⊆ envelope_705_i1 := by decide +kernel +theorem pivot_mem_705_i1 : (5, 6) ∈ envelope_705_i1 := by decide +kernel +theorem children_work_705_i1 : ∀ j, Template HasSnaky 9 (childrenC_705_i1 j) (childrenD_705_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 6 (6, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_79 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_181 1 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_189 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_367 4 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_474 1 (3, 3)).mono (by decide +kernel) +theorem row_works_705_i1 : Template HasSnaky 10 required_705_i1 envelope_705_i1 := by + refine compose HasSnaky 9 childrenC_705_i1 childrenD_705_i1 children_work_705_i1 (5, 6) + required_705_i1 envelope_705_i1 pivot_mem_705_i1 child_required_sub_705_i1 child_envelope_sub_705_i1 ?_ + intro b hb + exact common_sub_705_i1 (mem_commonEnvelope childrenD_705_i1 b hb) +def required_705_i0 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_705_i0 : Finset Cell := ⟨(([(1, 4), (2, 4), (2, 5), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (7, 8), (8, 6), (8, 7), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_705_i0 : Fin 4 → Finset Cell := ![(placed21 4 (2, 8) required_59), (placed21 3 (1, 5) required_105), (placed21 2 (6, 1) required_323), required_705_i1] +def childrenD_705_i0 : Fin 4 → Finset Cell := ![(placed21 4 (2, 8) envelope_59), (placed21 3 (1, 5) envelope_105), (placed21 2 (6, 1) envelope_323), envelope_705_i1] +theorem common_sub_705_i0 : commonEnvelope childrenD_705_i0 ⊆ insert (5, 5) required_705_i0 := by decide +kernel +theorem child_required_sub_705_i0 : ∀ j, childrenC_705_i0 j ⊆ insert (5, 5) required_705_i0 := by decide +kernel +theorem child_envelope_sub_705_i0 : ∀ j, childrenD_705_i0 j ⊆ envelope_705_i0 := by decide +kernel +theorem pivot_mem_705_i0 : (5, 5) ∈ envelope_705_i0 := by decide +kernel +theorem children_work_705_i0 : ∀ j, Template HasSnaky 10 (childrenC_705_i0 j) (childrenD_705_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_59 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_105 3 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_323 2 (6, 1)).mono (by decide +kernel) + · exact row_works_705_i1.mono (by decide +kernel) +theorem row_works_705_i0 : Template HasSnaky 11 required_705_i0 envelope_705_i0 := by + refine compose HasSnaky 10 childrenC_705_i0 childrenD_705_i0 children_work_705_i0 (5, 5) + required_705_i0 envelope_705_i0 pivot_mem_705_i0 child_required_sub_705_i0 child_envelope_sub_705_i0 ?_ + intro b hb + exact common_sub_705_i0 (mem_commonEnvelope childrenD_705_i0 b hb) +def required_705_i4 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_705_i4 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_705_i4 : Fin 2 → Finset Cell := ![(placed21 6 (5, 7) required_52), (placed21 2 (6, 2) required_242)] +def childrenD_705_i4 : Fin 2 → Finset Cell := ![(placed21 6 (5, 7) envelope_52), (placed21 2 (6, 2) envelope_242)] +theorem common_sub_705_i4 : commonEnvelope childrenD_705_i4 ⊆ insert (4, 4) required_705_i4 := by decide +kernel +theorem child_required_sub_705_i4 : ∀ j, childrenC_705_i4 j ⊆ insert (4, 4) required_705_i4 := by decide +kernel +theorem child_envelope_sub_705_i4 : ∀ j, childrenD_705_i4 j ⊆ envelope_705_i4 := by decide +kernel +theorem pivot_mem_705_i4 : (4, 4) ∈ envelope_705_i4 := by decide +kernel +theorem children_work_705_i4 : ∀ j, Template HasSnaky 4 (childrenC_705_i4 j) (childrenD_705_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 6 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_242 2 (6, 2)).mono (by decide +kernel) +theorem row_works_705_i4 : Template HasSnaky 5 required_705_i4 envelope_705_i4 := by + refine compose HasSnaky 4 childrenC_705_i4 childrenD_705_i4 children_work_705_i4 (4, 4) + required_705_i4 envelope_705_i4 pivot_mem_705_i4 child_required_sub_705_i4 child_envelope_sub_705_i4 ?_ + intro b hb + exact common_sub_705_i4 (mem_commonEnvelope childrenD_705_i4 b hb) +def required_705_i3 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_705_i3 : Finset Cell := ⟨(([(1, 3), (2, 2), (2, 3), (2, 4), (2, 5), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_705_i3 : Fin 4 → Finset Cell := ![(placed21 4 (2, 7) required_79), (placed21 2 (6, 2) required_243), (placed21 2 (8, 1) required_518), required_705_i4] +def childrenD_705_i3 : Fin 4 → Finset Cell := ![(placed21 4 (2, 7) envelope_79), (placed21 2 (6, 2) envelope_243), (placed21 2 (8, 1) envelope_518), envelope_705_i4] +theorem common_sub_705_i3 : commonEnvelope childrenD_705_i3 ⊆ insert (5, 6) required_705_i3 := by decide +kernel +theorem child_required_sub_705_i3 : ∀ j, childrenC_705_i3 j ⊆ insert (5, 6) required_705_i3 := by decide +kernel +theorem child_envelope_sub_705_i3 : ∀ j, childrenD_705_i3 j ⊆ envelope_705_i3 := by decide +kernel +theorem pivot_mem_705_i3 : (5, 6) ∈ envelope_705_i3 := by decide +kernel +theorem children_work_705_i3 : ∀ j, Template HasSnaky 8 (childrenC_705_i3 j) (childrenD_705_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_79 4 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_243 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_518 2 (8, 1)).mono (by decide +kernel) + · exact row_works_705_i4.mono (by decide +kernel) +theorem row_works_705_i3 : Template HasSnaky 9 required_705_i3 envelope_705_i3 := by + refine compose HasSnaky 8 childrenC_705_i3 childrenD_705_i3 children_work_705_i3 (5, 6) + required_705_i3 envelope_705_i3 pivot_mem_705_i3 child_required_sub_705_i3 child_envelope_sub_705_i3 ?_ + intro b hb + exact common_sub_705_i3 (mem_commonEnvelope childrenD_705_i3 b hb) +def required_705_i2 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_705_i2 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (2, 5), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_705_i2 : Fin 6 → Finset Cell := ![(placed21 2 (6, 1) required_323), (placed21 0 (2, 1) required_430), (placed21 0 (1, 2) required_431), (placed21 7 (6, 5) required_592), (placed21 4 (1, 9) required_681), required_705_i3] +def childrenD_705_i2 : Fin 6 → Finset Cell := ![(placed21 2 (6, 1) envelope_323), (placed21 0 (2, 1) envelope_430), (placed21 0 (1, 2) envelope_431), (placed21 7 (6, 5) envelope_592), (placed21 4 (1, 9) envelope_681), envelope_705_i3] +theorem common_sub_705_i2 : commonEnvelope childrenD_705_i2 ⊆ insert (5, 5) required_705_i2 := by decide +kernel +theorem child_required_sub_705_i2 : ∀ j, childrenC_705_i2 j ⊆ insert (5, 5) required_705_i2 := by decide +kernel +theorem child_envelope_sub_705_i2 : ∀ j, childrenD_705_i2 j ⊆ envelope_705_i2 := by decide +kernel +theorem pivot_mem_705_i2 : (5, 5) ∈ envelope_705_i2 := by decide +kernel +theorem children_work_705_i2 : ∀ j, Template HasSnaky 9 (childrenC_705_i2 j) (childrenD_705_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_323 2 (6, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_430 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_431 0 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_592 7 (6, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_681 4 (1, 9)).mono (by decide +kernel) + · exact row_works_705_i3.mono (by decide +kernel) +theorem row_works_705_i2 : Template HasSnaky 10 required_705_i2 envelope_705_i2 := by + refine compose HasSnaky 9 childrenC_705_i2 childrenD_705_i2 children_work_705_i2 (5, 5) + required_705_i2 envelope_705_i2 pivot_mem_705_i2 child_required_sub_705_i2 child_envelope_sub_705_i2 ?_ + intro b hb + exact common_sub_705_i2 (mem_commonEnvelope childrenD_705_i2 b hb) +def required_705 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_705 : Finset Cell := ⟨(([(0, 3), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_705 : Fin 7 → Finset Cell := ![(placed21 2 (6, 2) required_422), (placed21 4 (1, 8) required_450), (placed21 6 (6, 7) required_503), (placed21 0 (2, 0) required_642), (placed21 4 (1, 7) required_680), required_705_i0, required_705_i2] +def childrenD_705 : Fin 7 → Finset Cell := ![(placed21 2 (6, 2) envelope_422), (placed21 4 (1, 8) envelope_450), (placed21 6 (6, 7) envelope_503), (placed21 0 (2, 0) envelope_642), (placed21 4 (1, 7) envelope_680), envelope_705_i0, envelope_705_i2] +theorem common_sub_705 : commonEnvelope childrenD_705 ⊆ insert (5, 4) required_705 := by decide +kernel +theorem child_required_sub_705 : ∀ j, childrenC_705 j ⊆ insert (5, 4) required_705 := by decide +kernel +theorem child_envelope_sub_705 : ∀ j, childrenD_705 j ⊆ envelope_705 := by decide +kernel +theorem pivot_mem_705 : (5, 4) ∈ envelope_705 := by decide +kernel +theorem children_work_705 : ∀ j, Template HasSnaky 13 (childrenC_705 j) (childrenD_705 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_422 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_450 4 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_503 6 (6, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_642 0 (2, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_680 4 (1, 7)).mono (by decide +kernel) + · exact row_works_705_i0.mono (by decide +kernel) + · exact row_works_705_i2.mono (by decide +kernel) +theorem row_works_705 : Template HasSnaky 14 required_705 envelope_705 := by + refine compose HasSnaky 13 childrenC_705 childrenD_705 children_work_705 (5, 4) + required_705 envelope_705 pivot_mem_705 child_required_sub_705 child_envelope_sub_705 ?_ + intro b hb + exact common_sub_705 (mem_commonEnvelope childrenD_705 b hb) +def required_711_i0 : Finset Cell := ⟨(([(4, 5), (4, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_711_i0 : Finset Cell := ⟨(([(1, 4), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (3, 8), (4, 4), (4, 5), (4, 6), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_711_i0 : Fin 6 → Finset Cell := ![(placed21 3 (1, 6) required_104), (placed21 3 (1, 6) required_359), (placed21 4 (1, 9) required_452), (placed21 0 (3, 2) required_476), (placed21 4 (3, 9) required_479), (placed21 2 (9, 0) required_520)] +def childrenD_711_i0 : Fin 6 → Finset Cell := ![(placed21 3 (1, 6) envelope_104), (placed21 3 (1, 6) envelope_359), (placed21 4 (1, 9) envelope_452), (placed21 0 (3, 2) envelope_476), (placed21 4 (3, 9) envelope_479), (placed21 2 (9, 0) envelope_520)] +theorem common_sub_711_i0 : commonEnvelope childrenD_711_i0 ⊆ insert (6, 5) required_711_i0 := by decide +kernel +theorem child_required_sub_711_i0 : ∀ j, childrenC_711_i0 j ⊆ insert (6, 5) required_711_i0 := by decide +kernel +theorem child_envelope_sub_711_i0 : ∀ j, childrenD_711_i0 j ⊆ envelope_711_i0 := by decide +kernel +theorem pivot_mem_711_i0 : (6, 5) ∈ envelope_711_i0 := by decide +kernel +theorem children_work_711_i0 : ∀ j, Template HasSnaky 10 (childrenC_711_i0 j) (childrenD_711_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_104 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_359 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_452 4 (1, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_476 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_479 4 (3, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_520 2 (9, 0)).mono (by decide +kernel) +theorem row_works_711_i0 : Template HasSnaky 11 required_711_i0 envelope_711_i0 := by + refine compose HasSnaky 10 childrenC_711_i0 childrenD_711_i0 children_work_711_i0 (6, 5) + required_711_i0 envelope_711_i0 pivot_mem_711_i0 child_required_sub_711_i0 child_envelope_sub_711_i0 ?_ + intro b hb + exact common_sub_711_i0 (mem_commonEnvelope childrenD_711_i0 b hb) +def required_711 : Finset Cell := ⟨(([(4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_711 : Finset Cell := ⟨(([(0, 5), (1, 4), (1, 5), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 4), (4, 5), (4, 6), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 5), (10, 6), (10, 7), (11, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_711 : Fin 9 → Finset Cell := ![(placed21 2 (7, 3) required_120), (placed21 1 (1, 4) required_338), (placed21 1 (1, 3) required_437), (placed21 1 (0, 4) required_611), (placed21 3 (1, 7) required_613), (placed21 4 (1, 10) required_634), (placed21 4 (3, 10) required_642), (placed21 4 (3, 10) required_643), required_711_i0] +def childrenD_711 : Fin 9 → Finset Cell := ![(placed21 2 (7, 3) envelope_120), (placed21 1 (1, 4) envelope_338), (placed21 1 (1, 3) envelope_437), (placed21 1 (0, 4) envelope_611), (placed21 3 (1, 7) envelope_613), (placed21 4 (1, 10) envelope_634), (placed21 4 (3, 10) envelope_642), (placed21 4 (3, 10) envelope_643), envelope_711_i0] +theorem common_sub_711 : commonEnvelope childrenD_711 ⊆ insert (6, 6) required_711 := by decide +kernel +theorem child_required_sub_711 : ∀ j, childrenC_711 j ⊆ insert (6, 6) required_711 := by decide +kernel +theorem child_envelope_sub_711 : ∀ j, childrenD_711 j ⊆ envelope_711 := by decide +kernel +theorem pivot_mem_711 : (6, 6) ∈ envelope_711 := by decide +kernel +theorem children_work_711 : ∀ j, Template HasSnaky 13 (childrenC_711 j) (childrenD_711 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_120 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_338 1 (1, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_437 1 (1, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_611 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_613 3 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_634 4 (1, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_642 4 (3, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_643 4 (3, 10)).mono (by decide +kernel) + · exact row_works_711_i0.mono (by decide +kernel) +theorem row_works_711 : Template HasSnaky 14 required_711 envelope_711 := by + refine compose HasSnaky 13 childrenC_711 childrenD_711 children_work_711 (6, 6) + required_711 envelope_711 pivot_mem_711 child_required_sub_711 child_envelope_sub_711 ?_ + intro b hb + exact common_sub_711 (mem_commonEnvelope childrenD_711 b hb) +def height_697_i4 : ℕ := 4 +def childrenH_697_i4 : Fin 2 → ℕ := ![height_16, height_374] +theorem height_exact_697_i4 : height_697_i4 = 1 + Finset.univ.sup childrenH_697_i4 := by decide +kernel +theorem required_origin_697_i4 : ∀ x ∈ required_697_i4, + (∃ j, x ∈ childrenC_697_i4 j) ∨ ∀ j, x ∈ childrenD_697_i4 j := by decide +kernel +theorem required_exact_697_i4 : required_697_i4 = + ((Finset.univ.biUnion childrenC_697_i4) ∪ commonEnvelope childrenD_697_i4).erase (5, 2) := by + exact required_eq_combination childrenC_697_i4 childrenD_697_i4 (5, 2) required_697_i4 + (by decide +kernel) child_required_sub_697_i4 common_sub_697_i4 required_origin_697_i4 +theorem envelope_origin_697_i4 : ∀ x ∈ envelope_697_i4, + x = (5, 2) ∨ ∃ j, x ∈ childrenD_697_i4 j := by decide +kernel +theorem envelope_exact_697_i4 : envelope_697_i4 = + insert (5, 2) (Finset.univ.biUnion childrenD_697_i4) := by + exact envelope_eq_combination childrenD_697_i4 (5, 2) envelope_697_i4 + pivot_mem_697_i4 child_envelope_sub_697_i4 envelope_origin_697_i4 +def checked_697_i4 : CheckedCard where + required := required_697_i4 + envelope := envelope_697_i4 + height := height_697_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_697_i4 +def height_697_i3 : ℕ := 7 +def childrenH_697_i3 : Fin 2 → ℕ := ![height_95, height_697_i4] +theorem height_exact_697_i3 : height_697_i3 = 1 + Finset.univ.sup childrenH_697_i3 := by decide +kernel +theorem required_origin_697_i3 : ∀ x ∈ required_697_i3, + (∃ j, x ∈ childrenC_697_i3 j) ∨ ∀ j, x ∈ childrenD_697_i3 j := by decide +kernel +theorem required_exact_697_i3 : required_697_i3 = + ((Finset.univ.biUnion childrenC_697_i3) ∪ commonEnvelope childrenD_697_i3).erase (6, 6) := by + exact required_eq_combination childrenC_697_i3 childrenD_697_i3 (6, 6) required_697_i3 + (by decide +kernel) child_required_sub_697_i3 common_sub_697_i3 required_origin_697_i3 +theorem envelope_origin_697_i3 : ∀ x ∈ envelope_697_i3, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_697_i3 j := by decide +kernel +theorem envelope_exact_697_i3 : envelope_697_i3 = + insert (6, 6) (Finset.univ.biUnion childrenD_697_i3) := by + exact envelope_eq_combination childrenD_697_i3 (6, 6) envelope_697_i3 + pivot_mem_697_i3 child_envelope_sub_697_i3 envelope_origin_697_i3 +def checked_697_i3 : CheckedCard where + required := required_697_i3 + envelope := envelope_697_i3 + height := height_697_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_697_i3 +def height_697_i2 : ℕ := 11 +def childrenH_697_i2 : Fin 3 → ℕ := ![height_151, height_460, height_697_i3] +theorem height_exact_697_i2 : height_697_i2 = 1 + Finset.univ.sup childrenH_697_i2 := by decide +kernel +theorem required_origin_697_i2 : ∀ x ∈ required_697_i2, + (∃ j, x ∈ childrenC_697_i2 j) ∨ ∀ j, x ∈ childrenD_697_i2 j := by decide +kernel +theorem required_exact_697_i2 : required_697_i2 = + ((Finset.univ.biUnion childrenC_697_i2) ∪ commonEnvelope childrenD_697_i2).erase (5, 6) := by + exact required_eq_combination childrenC_697_i2 childrenD_697_i2 (5, 6) required_697_i2 + (by decide +kernel) child_required_sub_697_i2 common_sub_697_i2 required_origin_697_i2 +theorem envelope_origin_697_i2 : ∀ x ∈ envelope_697_i2, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_697_i2 j := by decide +kernel +theorem envelope_exact_697_i2 : envelope_697_i2 = + insert (5, 6) (Finset.univ.biUnion childrenD_697_i2) := by + exact envelope_eq_combination childrenD_697_i2 (5, 6) envelope_697_i2 + pivot_mem_697_i2 child_envelope_sub_697_i2 envelope_origin_697_i2 +def checked_697_i2 : CheckedCard where + required := required_697_i2 + envelope := envelope_697_i2 + height := height_697_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_697_i2 +def height_697_i1 : ℕ := 12 +def childrenH_697_i1 : Fin 3 → ℕ := ![height_39, height_121, height_697_i2] +theorem height_exact_697_i1 : height_697_i1 = 1 + Finset.univ.sup childrenH_697_i1 := by decide +kernel +theorem required_origin_697_i1 : ∀ x ∈ required_697_i1, + (∃ j, x ∈ childrenC_697_i1 j) ∨ ∀ j, x ∈ childrenD_697_i1 j := by decide +kernel +theorem required_exact_697_i1 : required_697_i1 = + ((Finset.univ.biUnion childrenC_697_i1) ∪ commonEnvelope childrenD_697_i1).erase (3, 6) := by + exact required_eq_combination childrenC_697_i1 childrenD_697_i1 (3, 6) required_697_i1 + (by decide +kernel) child_required_sub_697_i1 common_sub_697_i1 required_origin_697_i1 +theorem envelope_origin_697_i1 : ∀ x ∈ envelope_697_i1, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_697_i1 j := by decide +kernel +theorem envelope_exact_697_i1 : envelope_697_i1 = + insert (3, 6) (Finset.univ.biUnion childrenD_697_i1) := by + exact envelope_eq_combination childrenD_697_i1 (3, 6) envelope_697_i1 + pivot_mem_697_i1 child_envelope_sub_697_i1 envelope_origin_697_i1 +def checked_697_i1 : CheckedCard where + required := required_697_i1 + envelope := envelope_697_i1 + height := height_697_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_697_i1 +def height_697_i0 : ℕ := 13 +def childrenH_697_i0 : Fin 3 → ℕ := ![height_21, height_56, height_697_i1] +theorem height_exact_697_i0 : height_697_i0 = 1 + Finset.univ.sup childrenH_697_i0 := by decide +kernel +theorem required_origin_697_i0 : ∀ x ∈ required_697_i0, + (∃ j, x ∈ childrenC_697_i0 j) ∨ ∀ j, x ∈ childrenD_697_i0 j := by decide +kernel +theorem required_exact_697_i0 : required_697_i0 = + ((Finset.univ.biUnion childrenC_697_i0) ∪ commonEnvelope childrenD_697_i0).erase (3, 4) := by + exact required_eq_combination childrenC_697_i0 childrenD_697_i0 (3, 4) required_697_i0 + (by decide +kernel) child_required_sub_697_i0 common_sub_697_i0 required_origin_697_i0 +theorem envelope_origin_697_i0 : ∀ x ∈ envelope_697_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_697_i0 j := by decide +kernel +theorem envelope_exact_697_i0 : envelope_697_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_697_i0) := by + exact envelope_eq_combination childrenD_697_i0 (3, 4) envelope_697_i0 + pivot_mem_697_i0 child_envelope_sub_697_i0 envelope_origin_697_i0 +def checked_697_i0 : CheckedCard where + required := required_697_i0 + envelope := envelope_697_i0 + height := height_697_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_697_i0 +def height_697 : ℕ := 14 +def childrenH_697 : Fin 4 → ℕ := ![height_7, height_8, height_690, height_697_i0] +theorem height_exact_697 : height_697 = 1 + Finset.univ.sup childrenH_697 := by decide +kernel +theorem required_origin_697 : ∀ x ∈ required_697, + (∃ j, x ∈ childrenC_697 j) ∨ ∀ j, x ∈ childrenD_697 j := by decide +kernel +theorem required_exact_697 : required_697 = + ((Finset.univ.biUnion childrenC_697) ∪ commonEnvelope childrenD_697).erase (5, 3) := by + exact required_eq_combination childrenC_697 childrenD_697 (5, 3) required_697 + (by decide +kernel) child_required_sub_697 common_sub_697 required_origin_697 +theorem envelope_origin_697 : ∀ x ∈ envelope_697, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_697 j := by decide +kernel +theorem envelope_exact_697 : envelope_697 = + insert (5, 3) (Finset.univ.biUnion childrenD_697) := by + exact envelope_eq_combination childrenD_697 (5, 3) envelope_697 + pivot_mem_697 child_envelope_sub_697 envelope_origin_697 +def checked_697 : CheckedCard where + required := required_697 + envelope := envelope_697 + height := height_697 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_697 +def height_705_i1 : ℕ := 10 +def childrenH_705_i1 : Fin 6 → ℕ := ![height_14, height_79, height_181, height_189, height_367, height_474] +theorem height_exact_705_i1 : height_705_i1 = 1 + Finset.univ.sup childrenH_705_i1 := by decide +kernel +theorem required_origin_705_i1 : ∀ x ∈ required_705_i1, + (∃ j, x ∈ childrenC_705_i1 j) ∨ ∀ j, x ∈ childrenD_705_i1 j := by decide +kernel +theorem required_exact_705_i1 : required_705_i1 = + ((Finset.univ.biUnion childrenC_705_i1) ∪ commonEnvelope childrenD_705_i1).erase (5, 6) := by + exact required_eq_combination childrenC_705_i1 childrenD_705_i1 (5, 6) required_705_i1 + (by decide +kernel) child_required_sub_705_i1 common_sub_705_i1 required_origin_705_i1 +theorem envelope_origin_705_i1 : ∀ x ∈ envelope_705_i1, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_705_i1 j := by decide +kernel +theorem envelope_exact_705_i1 : envelope_705_i1 = + insert (5, 6) (Finset.univ.biUnion childrenD_705_i1) := by + exact envelope_eq_combination childrenD_705_i1 (5, 6) envelope_705_i1 + pivot_mem_705_i1 child_envelope_sub_705_i1 envelope_origin_705_i1 +def checked_705_i1 : CheckedCard where + required := required_705_i1 + envelope := envelope_705_i1 + height := height_705_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_705_i1 +def height_705_i0 : ℕ := 11 +def childrenH_705_i0 : Fin 4 → ℕ := ![height_59, height_105, height_323, height_705_i1] +theorem height_exact_705_i0 : height_705_i0 = 1 + Finset.univ.sup childrenH_705_i0 := by decide +kernel +theorem required_origin_705_i0 : ∀ x ∈ required_705_i0, + (∃ j, x ∈ childrenC_705_i0 j) ∨ ∀ j, x ∈ childrenD_705_i0 j := by decide +kernel +theorem required_exact_705_i0 : required_705_i0 = + ((Finset.univ.biUnion childrenC_705_i0) ∪ commonEnvelope childrenD_705_i0).erase (5, 5) := by + exact required_eq_combination childrenC_705_i0 childrenD_705_i0 (5, 5) required_705_i0 + (by decide +kernel) child_required_sub_705_i0 common_sub_705_i0 required_origin_705_i0 +theorem envelope_origin_705_i0 : ∀ x ∈ envelope_705_i0, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_705_i0 j := by decide +kernel +theorem envelope_exact_705_i0 : envelope_705_i0 = + insert (5, 5) (Finset.univ.biUnion childrenD_705_i0) := by + exact envelope_eq_combination childrenD_705_i0 (5, 5) envelope_705_i0 + pivot_mem_705_i0 child_envelope_sub_705_i0 envelope_origin_705_i0 +def checked_705_i0 : CheckedCard where + required := required_705_i0 + envelope := envelope_705_i0 + height := height_705_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_705_i0 +def height_705_i4 : ℕ := 5 +def childrenH_705_i4 : Fin 2 → ℕ := ![height_52, height_242] +theorem height_exact_705_i4 : height_705_i4 = 1 + Finset.univ.sup childrenH_705_i4 := by decide +kernel +theorem required_origin_705_i4 : ∀ x ∈ required_705_i4, + (∃ j, x ∈ childrenC_705_i4 j) ∨ ∀ j, x ∈ childrenD_705_i4 j := by decide +kernel +theorem required_exact_705_i4 : required_705_i4 = + ((Finset.univ.biUnion childrenC_705_i4) ∪ commonEnvelope childrenD_705_i4).erase (4, 4) := by + exact required_eq_combination childrenC_705_i4 childrenD_705_i4 (4, 4) required_705_i4 + (by decide +kernel) child_required_sub_705_i4 common_sub_705_i4 required_origin_705_i4 +theorem envelope_origin_705_i4 : ∀ x ∈ envelope_705_i4, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_705_i4 j := by decide +kernel +theorem envelope_exact_705_i4 : envelope_705_i4 = + insert (4, 4) (Finset.univ.biUnion childrenD_705_i4) := by + exact envelope_eq_combination childrenD_705_i4 (4, 4) envelope_705_i4 + pivot_mem_705_i4 child_envelope_sub_705_i4 envelope_origin_705_i4 +def checked_705_i4 : CheckedCard where + required := required_705_i4 + envelope := envelope_705_i4 + height := height_705_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_705_i4 +def height_705_i3 : ℕ := 9 +def childrenH_705_i3 : Fin 4 → ℕ := ![height_79, height_243, height_518, height_705_i4] +theorem height_exact_705_i3 : height_705_i3 = 1 + Finset.univ.sup childrenH_705_i3 := by decide +kernel +theorem required_origin_705_i3 : ∀ x ∈ required_705_i3, + (∃ j, x ∈ childrenC_705_i3 j) ∨ ∀ j, x ∈ childrenD_705_i3 j := by decide +kernel +theorem required_exact_705_i3 : required_705_i3 = + ((Finset.univ.biUnion childrenC_705_i3) ∪ commonEnvelope childrenD_705_i3).erase (5, 6) := by + exact required_eq_combination childrenC_705_i3 childrenD_705_i3 (5, 6) required_705_i3 + (by decide +kernel) child_required_sub_705_i3 common_sub_705_i3 required_origin_705_i3 +theorem envelope_origin_705_i3 : ∀ x ∈ envelope_705_i3, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_705_i3 j := by decide +kernel +theorem envelope_exact_705_i3 : envelope_705_i3 = + insert (5, 6) (Finset.univ.biUnion childrenD_705_i3) := by + exact envelope_eq_combination childrenD_705_i3 (5, 6) envelope_705_i3 + pivot_mem_705_i3 child_envelope_sub_705_i3 envelope_origin_705_i3 +def checked_705_i3 : CheckedCard where + required := required_705_i3 + envelope := envelope_705_i3 + height := height_705_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_705_i3 +def height_705_i2 : ℕ := 10 +def childrenH_705_i2 : Fin 6 → ℕ := ![height_323, height_430, height_431, height_592, height_681, height_705_i3] +theorem height_exact_705_i2 : height_705_i2 = 1 + Finset.univ.sup childrenH_705_i2 := by decide +kernel +theorem required_origin_705_i2 : ∀ x ∈ required_705_i2, + (∃ j, x ∈ childrenC_705_i2 j) ∨ ∀ j, x ∈ childrenD_705_i2 j := by decide +kernel +theorem required_exact_705_i2 : required_705_i2 = + ((Finset.univ.biUnion childrenC_705_i2) ∪ commonEnvelope childrenD_705_i2).erase (5, 5) := by + exact required_eq_combination childrenC_705_i2 childrenD_705_i2 (5, 5) required_705_i2 + (by decide +kernel) child_required_sub_705_i2 common_sub_705_i2 required_origin_705_i2 +theorem envelope_origin_705_i2 : ∀ x ∈ envelope_705_i2, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_705_i2 j := by decide +kernel +theorem envelope_exact_705_i2 : envelope_705_i2 = + insert (5, 5) (Finset.univ.biUnion childrenD_705_i2) := by + exact envelope_eq_combination childrenD_705_i2 (5, 5) envelope_705_i2 + pivot_mem_705_i2 child_envelope_sub_705_i2 envelope_origin_705_i2 +def checked_705_i2 : CheckedCard where + required := required_705_i2 + envelope := envelope_705_i2 + height := height_705_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_705_i2 +def height_705 : ℕ := 14 +def childrenH_705 : Fin 7 → ℕ := ![height_422, height_450, height_503, height_642, height_680, height_705_i0, height_705_i2] +theorem height_exact_705 : height_705 = 1 + Finset.univ.sup childrenH_705 := by decide +kernel +theorem required_origin_705 : ∀ x ∈ required_705, + (∃ j, x ∈ childrenC_705 j) ∨ ∀ j, x ∈ childrenD_705 j := by decide +kernel +theorem required_exact_705 : required_705 = + ((Finset.univ.biUnion childrenC_705) ∪ commonEnvelope childrenD_705).erase (5, 4) := by + exact required_eq_combination childrenC_705 childrenD_705 (5, 4) required_705 + (by decide +kernel) child_required_sub_705 common_sub_705 required_origin_705 +theorem envelope_origin_705 : ∀ x ∈ envelope_705, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_705 j := by decide +kernel +theorem envelope_exact_705 : envelope_705 = + insert (5, 4) (Finset.univ.biUnion childrenD_705) := by + exact envelope_eq_combination childrenD_705 (5, 4) envelope_705 + pivot_mem_705 child_envelope_sub_705 envelope_origin_705 +def checked_705 : CheckedCard where + required := required_705 + envelope := envelope_705 + height := height_705 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_705 +def height_711_i0 : ℕ := 11 +def childrenH_711_i0 : Fin 6 → ℕ := ![height_104, height_359, height_452, height_476, height_479, height_520] +theorem height_exact_711_i0 : height_711_i0 = 1 + Finset.univ.sup childrenH_711_i0 := by decide +kernel +theorem required_origin_711_i0 : ∀ x ∈ required_711_i0, + (∃ j, x ∈ childrenC_711_i0 j) ∨ ∀ j, x ∈ childrenD_711_i0 j := by decide +kernel +theorem required_exact_711_i0 : required_711_i0 = + ((Finset.univ.biUnion childrenC_711_i0) ∪ commonEnvelope childrenD_711_i0).erase (6, 5) := by + exact required_eq_combination childrenC_711_i0 childrenD_711_i0 (6, 5) required_711_i0 + (by decide +kernel) child_required_sub_711_i0 common_sub_711_i0 required_origin_711_i0 +theorem envelope_origin_711_i0 : ∀ x ∈ envelope_711_i0, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_711_i0 j := by decide +kernel +theorem envelope_exact_711_i0 : envelope_711_i0 = + insert (6, 5) (Finset.univ.biUnion childrenD_711_i0) := by + exact envelope_eq_combination childrenD_711_i0 (6, 5) envelope_711_i0 + pivot_mem_711_i0 child_envelope_sub_711_i0 envelope_origin_711_i0 +def checked_711_i0 : CheckedCard where + required := required_711_i0 + envelope := envelope_711_i0 + height := height_711_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_711_i0 +def height_711 : ℕ := 14 +def childrenH_711 : Fin 9 → ℕ := ![height_120, height_338, height_437, height_611, height_613, height_634, height_642, height_643, height_711_i0] +theorem height_exact_711 : height_711 = 1 + Finset.univ.sup childrenH_711 := by decide +kernel +theorem required_origin_711 : ∀ x ∈ required_711, + (∃ j, x ∈ childrenC_711 j) ∨ ∀ j, x ∈ childrenD_711 j := by decide +kernel +theorem required_exact_711 : required_711 = + ((Finset.univ.biUnion childrenC_711) ∪ commonEnvelope childrenD_711).erase (6, 6) := by + exact required_eq_combination childrenC_711 childrenD_711 (6, 6) required_711 + (by decide +kernel) child_required_sub_711 common_sub_711 required_origin_711 +theorem envelope_origin_711 : ∀ x ∈ envelope_711, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_711 j := by decide +kernel +theorem envelope_exact_711 : envelope_711 = + insert (6, 6) (Finset.univ.biUnion childrenD_711) := by + exact envelope_eq_combination childrenD_711 (6, 6) envelope_711 + pivot_mem_711 child_envelope_sub_711 envelope_origin_711 +def checked_711 : CheckedCard where + required := required_711 + envelope := envelope_711 + height := height_711 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_711 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part01.lean new file mode 100644 index 0000000..8c5be52 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part01.lean @@ -0,0 +1,969 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_573_i0 : Finset Cell := ⟨(([(0, 3), (3, 3), (3, 4), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_573_i0 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 5), (1, 6), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_573_i0 : Fin 5 → Finset Cell := ![(placed21 1 (2, 3) required_8), (placed21 1 (0, 3) required_115), (placed21 5 (4, 3) required_197), (placed21 0 (0, 2) required_286), (placed21 0 (0, 2) required_339)] +def childrenD_573_i0 : Fin 5 → Finset Cell := ![(placed21 1 (2, 3) envelope_8), (placed21 1 (0, 3) envelope_115), (placed21 5 (4, 3) envelope_197), (placed21 0 (0, 2) envelope_286), (placed21 0 (0, 2) envelope_339)] +theorem common_sub_573_i0 : commonEnvelope childrenD_573_i0 ⊆ insert (3, 5) required_573_i0 := by decide +kernel +theorem child_required_sub_573_i0 : ∀ j, childrenC_573_i0 j ⊆ insert (3, 5) required_573_i0 := by decide +kernel +theorem child_envelope_sub_573_i0 : ∀ j, childrenD_573_i0 j ⊆ envelope_573_i0 := by decide +kernel +theorem pivot_mem_573_i0 : (3, 5) ∈ envelope_573_i0 := by decide +kernel +theorem children_work_573_i0 : ∀ j, Template HasSnaky 7 (childrenC_573_i0 j) (childrenD_573_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_115 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_197 5 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_286 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_339 0 (0, 2)).mono (by decide +kernel) +theorem row_works_573_i0 : Template HasSnaky 8 required_573_i0 envelope_573_i0 := by + refine compose HasSnaky 7 childrenC_573_i0 childrenD_573_i0 children_work_573_i0 (3, 5) + required_573_i0 envelope_573_i0 pivot_mem_573_i0 child_required_sub_573_i0 child_envelope_sub_573_i0 ?_ + intro b hb + exact common_sub_573_i0 (mem_commonEnvelope childrenD_573_i0 b hb) +def required_573_i1 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_573_i1 : Finset Cell := ⟨(([(1, 5), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_573_i1 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) required_7), (placed21 1 (2, 3) required_8), (placed21 2 (4, 2) required_9), (placed21 3 (1, 7) required_473)] +def childrenD_573_i1 : Fin 4 → Finset Cell := ![(placed21 0 (3, 2) envelope_7), (placed21 1 (2, 3) envelope_8), (placed21 2 (4, 2) envelope_9), (placed21 3 (1, 7) envelope_473)] +theorem common_sub_573_i1 : commonEnvelope childrenD_573_i1 ⊆ insert (3, 5) required_573_i1 := by decide +kernel +theorem child_required_sub_573_i1 : ∀ j, childrenC_573_i1 j ⊆ insert (3, 5) required_573_i1 := by decide +kernel +theorem child_envelope_sub_573_i1 : ∀ j, childrenD_573_i1 j ⊆ envelope_573_i1 := by decide +kernel +theorem pivot_mem_573_i1 : (3, 5) ∈ envelope_573_i1 := by decide +kernel +theorem children_work_573_i1 : ∀ j, Template HasSnaky 8 (childrenC_573_i1 j) (childrenD_573_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_473 3 (1, 7)).mono (by decide +kernel) +theorem row_works_573_i1 : Template HasSnaky 9 required_573_i1 envelope_573_i1 := by + refine compose HasSnaky 8 childrenC_573_i1 childrenD_573_i1 children_work_573_i1 (3, 5) + required_573_i1 envelope_573_i1 pivot_mem_573_i1 child_required_sub_573_i1 child_envelope_sub_573_i1 ?_ + intro b hb + exact common_sub_573_i1 (mem_commonEnvelope childrenD_573_i1 b hb) +def required_573_i2 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 6), (3, 3), (3, 4), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_573_i2 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_573_i2 : Fin 4 → Finset Cell := ![(placed21 1 (2, 3) required_8), (placed21 0 (0, 2) required_403), (placed21 0 (0, 3) required_487), (placed21 0 (0, 2) required_492)] +def childrenD_573_i2 : Fin 4 → Finset Cell := ![(placed21 1 (2, 3) envelope_8), (placed21 0 (0, 2) envelope_403), (placed21 0 (0, 3) envelope_487), (placed21 0 (0, 2) envelope_492)] +theorem common_sub_573_i2 : commonEnvelope childrenD_573_i2 ⊆ insert (3, 5) required_573_i2 := by decide +kernel +theorem child_required_sub_573_i2 : ∀ j, childrenC_573_i2 j ⊆ insert (3, 5) required_573_i2 := by decide +kernel +theorem child_envelope_sub_573_i2 : ∀ j, childrenD_573_i2 j ⊆ envelope_573_i2 := by decide +kernel +theorem pivot_mem_573_i2 : (3, 5) ∈ envelope_573_i2 := by decide +kernel +theorem children_work_573_i2 : ∀ j, Template HasSnaky 7 (childrenC_573_i2 j) (childrenD_573_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_403 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_487 0 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_492 0 (0, 2)).mono (by decide +kernel) +theorem row_works_573_i2 : Template HasSnaky 8 required_573_i2 envelope_573_i2 := by + refine compose HasSnaky 7 childrenC_573_i2 childrenD_573_i2 children_work_573_i2 (3, 5) + required_573_i2 envelope_573_i2 pivot_mem_573_i2 child_required_sub_573_i2 child_envelope_sub_573_i2 ?_ + intro b hb + exact common_sub_573_i2 (mem_commonEnvelope childrenD_573_i2 b hb) +def required_573_i3 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 6), (3, 3), (3, 4), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_573_i3 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_573_i3 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) required_87), (placed21 0 (0, 3) required_487)] +def childrenD_573_i3 : Fin 2 → Finset Cell := ![(placed21 0 (0, 2) envelope_87), (placed21 0 (0, 3) envelope_487)] +theorem common_sub_573_i3 : commonEnvelope childrenD_573_i3 ⊆ insert (3, 5) required_573_i3 := by decide +kernel +theorem child_required_sub_573_i3 : ∀ j, childrenC_573_i3 j ⊆ insert (3, 5) required_573_i3 := by decide +kernel +theorem child_envelope_sub_573_i3 : ∀ j, childrenD_573_i3 j ⊆ envelope_573_i3 := by decide +kernel +theorem pivot_mem_573_i3 : (3, 5) ∈ envelope_573_i3 := by decide +kernel +theorem children_work_573_i3 : ∀ j, Template HasSnaky 7 (childrenC_573_i3 j) (childrenD_573_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_87 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_487 0 (0, 3)).mono (by decide +kernel) +theorem row_works_573_i3 : Template HasSnaky 8 required_573_i3 envelope_573_i3 := by + refine compose HasSnaky 7 childrenC_573_i3 childrenD_573_i3 children_work_573_i3 (3, 5) + required_573_i3 envelope_573_i3 pivot_mem_573_i3 child_required_sub_573_i3 child_envelope_sub_573_i3 ?_ + intro b hb + exact common_sub_573_i3 (mem_commonEnvelope childrenD_573_i3 b hb) +def required_573_i4 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 6), (3, 3), (3, 4), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_573_i4 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 7), (0, 8), (0, 9), (0, 10), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 3), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 3), (3, 4), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_573_i4 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) required_107), required_572] +def childrenD_573_i4 : Fin 2 → Finset Cell := ![(placed21 0 (0, 3) envelope_107), envelope_572] +theorem common_sub_573_i4 : commonEnvelope childrenD_573_i4 ⊆ insert (1, 7) required_573_i4 := by decide +kernel +theorem child_required_sub_573_i4 : ∀ j, childrenC_573_i4 j ⊆ insert (1, 7) required_573_i4 := by decide +kernel +theorem child_envelope_sub_573_i4 : ∀ j, childrenD_573_i4 j ⊆ envelope_573_i4 := by decide +kernel +theorem pivot_mem_573_i4 : (1, 7) ∈ envelope_573_i4 := by decide +kernel +theorem children_work_573_i4 : ∀ j, Template HasSnaky 13 (childrenC_573_i4 j) (childrenD_573_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_107 0 (0, 3)).mono (by decide +kernel) + · exact row_works_572.mono (by decide +kernel) +theorem row_works_573_i4 : Template HasSnaky 14 required_573_i4 envelope_573_i4 := by + refine compose HasSnaky 13 childrenC_573_i4 childrenD_573_i4 children_work_573_i4 (1, 7) + required_573_i4 envelope_573_i4 pivot_mem_573_i4 child_required_sub_573_i4 child_envelope_sub_573_i4 ?_ + intro b hb + exact common_sub_573_i4 (mem_commonEnvelope childrenD_573_i4 b hb) +def required_573_i5 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 6), (3, 3), (3, 4), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_573_i5 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 2), (2, 3), (2, 6), (2, 7), (2, 8), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 2), (4, 3), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (5, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_573_i5 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) required_9), (placed21 0 (0, 2) required_249), (placed21 7 (5, 6) required_383), (placed21 0 (0, 2) required_403)] +def childrenD_573_i5 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) envelope_9), (placed21 0 (0, 2) envelope_249), (placed21 7 (5, 6) envelope_383), (placed21 0 (0, 2) envelope_403)] +theorem common_sub_573_i5 : commonEnvelope childrenD_573_i5 ⊆ insert (3, 5) required_573_i5 := by decide +kernel +theorem child_required_sub_573_i5 : ∀ j, childrenC_573_i5 j ⊆ insert (3, 5) required_573_i5 := by decide +kernel +theorem child_envelope_sub_573_i5 : ∀ j, childrenD_573_i5 j ⊆ envelope_573_i5 := by decide +kernel +theorem pivot_mem_573_i5 : (3, 5) ∈ envelope_573_i5 := by decide +kernel +theorem children_work_573_i5 : ∀ j, Template HasSnaky 6 (childrenC_573_i5 j) (childrenD_573_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_249 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_383 7 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_403 0 (0, 2)).mono (by decide +kernel) +theorem row_works_573_i5 : Template HasSnaky 7 required_573_i5 envelope_573_i5 := by + refine compose HasSnaky 6 childrenC_573_i5 childrenD_573_i5 children_work_573_i5 (3, 5) + required_573_i5 envelope_573_i5 pivot_mem_573_i5 child_required_sub_573_i5 child_envelope_sub_573_i5 ?_ + intro b hb + exact common_sub_573_i5 (mem_commonEnvelope childrenD_573_i5 b hb) +def required_573 : Finset Cell := ⟨(([(0, 3), (0, 4), (1, 6), (3, 3), (3, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_573 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 7), (0, 8), (0, 9), (0, 10), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_573 : Fin 10 → Finset Cell := ![(placed21 0 (0, 2) required_384), (placed21 0 (0, 2) required_385), (placed21 0 (0, 2) required_493), (placed21 0 (0, 2) required_494), required_573_i0, required_573_i1, required_573_i2, required_573_i3, required_573_i4, required_573_i5] +def childrenD_573 : Fin 10 → Finset Cell := ![(placed21 0 (0, 2) envelope_384), (placed21 0 (0, 2) envelope_385), (placed21 0 (0, 2) envelope_493), (placed21 0 (0, 2) envelope_494), envelope_573_i0, envelope_573_i1, envelope_573_i2, envelope_573_i3, envelope_573_i4, envelope_573_i5] +theorem common_sub_573 : commonEnvelope childrenD_573 ⊆ insert (3, 6) required_573 := by decide +kernel +theorem child_required_sub_573 : ∀ j, childrenC_573 j ⊆ insert (3, 6) required_573 := by decide +kernel +theorem child_envelope_sub_573 : ∀ j, childrenD_573 j ⊆ envelope_573 := by decide +kernel +theorem pivot_mem_573 : (3, 6) ∈ envelope_573 := by decide +kernel +theorem children_work_573 : ∀ j, Template HasSnaky 14 (childrenC_573 j) (childrenD_573 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_384 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_385 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_493 0 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_494 0 (0, 2)).mono (by decide +kernel) + · exact row_works_573_i0.mono (by decide +kernel) + · exact row_works_573_i1.mono (by decide +kernel) + · exact row_works_573_i2.mono (by decide +kernel) + · exact row_works_573_i3.mono (by decide +kernel) + · exact row_works_573_i4.mono (by decide +kernel) + · exact row_works_573_i5.mono (by decide +kernel) +theorem row_works_573 : Template HasSnaky 15 required_573 envelope_573 := by + refine compose HasSnaky 14 childrenC_573 childrenD_573 children_work_573 (3, 6) + required_573 envelope_573 pivot_mem_573 child_required_sub_573 child_envelope_sub_573 ?_ + intro b hb + exact common_sub_573 (mem_commonEnvelope childrenD_573 b hb) +def required_583_i2 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 8), (5, 6), (6, 6), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_583_i2 : Finset Cell := ⟨(([(2, 7), (2, 9), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 8), (4, 9), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 3), (7, 4), (7, 5), (7, 6), (7, 8), (7, 9), (7, 10), (8, 6), (8, 7), (9, 6), (9, 7), (10, 6), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_583_i2 : Fin 2 → Finset Cell := ![(placed21 1 (5, 6) required_6), (placed21 4 (2, 10) required_576)] +def childrenD_583_i2 : Fin 2 → Finset Cell := ![(placed21 1 (5, 6) envelope_6), (placed21 4 (2, 10) envelope_576)] +theorem common_sub_583_i2 : commonEnvelope childrenD_583_i2 ⊆ insert (9, 6) required_583_i2 := by decide +kernel +theorem child_required_sub_583_i2 : ∀ j, childrenC_583_i2 j ⊆ insert (9, 6) required_583_i2 := by decide +kernel +theorem child_envelope_sub_583_i2 : ∀ j, childrenD_583_i2 j ⊆ envelope_583_i2 := by decide +kernel +theorem pivot_mem_583_i2 : (9, 6) ∈ envelope_583_i2 := by decide +kernel +theorem children_work_583_i2 : ∀ j, Template HasSnaky 7 (childrenC_583_i2 j) (childrenD_583_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 1 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_576 4 (2, 10)).mono (by decide +kernel) +theorem row_works_583_i2 : Template HasSnaky 8 required_583_i2 envelope_583_i2 := by + refine compose HasSnaky 7 childrenC_583_i2 childrenD_583_i2 children_work_583_i2 (9, 6) + required_583_i2 envelope_583_i2 pivot_mem_583_i2 child_required_sub_583_i2 child_envelope_sub_583_i2 ?_ + intro b hb + exact common_sub_583_i2 (mem_commonEnvelope childrenD_583_i2 b hb) +def required_583_i3 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 8), (5, 6), (6, 6), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_583_i3 : Finset Cell := ⟨(([(2, 7), (2, 9), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 8), (4, 9), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 3), (7, 4), (7, 5), (7, 6), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (9, 5), (9, 6), (10, 5), (10, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_583_i3 : Fin 2 → Finset Cell := ![(placed21 3 (5, 6) required_6), (placed21 4 (2, 10) required_576)] +def childrenD_583_i3 : Fin 2 → Finset Cell := ![(placed21 3 (5, 6) envelope_6), (placed21 4 (2, 10) envelope_576)] +theorem common_sub_583_i3 : commonEnvelope childrenD_583_i3 ⊆ insert (9, 6) required_583_i3 := by decide +kernel +theorem child_required_sub_583_i3 : ∀ j, childrenC_583_i3 j ⊆ insert (9, 6) required_583_i3 := by decide +kernel +theorem child_envelope_sub_583_i3 : ∀ j, childrenD_583_i3 j ⊆ envelope_583_i3 := by decide +kernel +theorem pivot_mem_583_i3 : (9, 6) ∈ envelope_583_i3 := by decide +kernel +theorem children_work_583_i3 : ∀ j, Template HasSnaky 7 (childrenC_583_i3 j) (childrenD_583_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 3 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_576 4 (2, 10)).mono (by decide +kernel) +theorem row_works_583_i3 : Template HasSnaky 8 required_583_i3 envelope_583_i3 := by + refine compose HasSnaky 7 childrenC_583_i3 childrenD_583_i3 children_work_583_i3 (9, 6) + required_583_i3 envelope_583_i3 pivot_mem_583_i3 child_required_sub_583_i3 child_envelope_sub_583_i3 ?_ + intro b hb + exact common_sub_583_i3 (mem_commonEnvelope childrenD_583_i3 b hb) +def required_583_i1 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 8), (5, 6), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_583_i1 : Finset Cell := ⟨(([(2, 7), (2, 9), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 8), (4, 9), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 8), (7, 9), (7, 10), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 5), (10, 6), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_583_i1 : Fin 4 → Finset Cell := ![(placed21 4 (5, 7) required_8), (placed21 4 (5, 10) required_321), required_583_i2, required_583_i3] +def childrenD_583_i1 : Fin 4 → Finset Cell := ![(placed21 4 (5, 7) envelope_8), (placed21 4 (5, 10) envelope_321), envelope_583_i2, envelope_583_i3] +theorem common_sub_583_i1 : commonEnvelope childrenD_583_i1 ⊆ insert (8, 6) required_583_i1 := by decide +kernel +theorem child_required_sub_583_i1 : ∀ j, childrenC_583_i1 j ⊆ insert (8, 6) required_583_i1 := by decide +kernel +theorem child_envelope_sub_583_i1 : ∀ j, childrenD_583_i1 j ⊆ envelope_583_i1 := by decide +kernel +theorem pivot_mem_583_i1 : (8, 6) ∈ envelope_583_i1 := by decide +kernel +theorem children_work_583_i1 : ∀ j, Template HasSnaky 8 (childrenC_583_i1 j) (childrenD_583_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 4 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_321 4 (5, 10)).mono (by decide +kernel) + · exact row_works_583_i2.mono (by decide +kernel) + · exact row_works_583_i3.mono (by decide +kernel) +theorem row_works_583_i1 : Template HasSnaky 9 required_583_i1 envelope_583_i1 := by + refine compose HasSnaky 8 childrenC_583_i1 childrenD_583_i1 children_work_583_i1 (8, 6) + required_583_i1 envelope_583_i1 pivot_mem_583_i1 child_required_sub_583_i1 child_envelope_sub_583_i1 ?_ + intro b hb + exact common_sub_583_i1 (mem_commonEnvelope childrenD_583_i1 b hb) +def required_583_i0 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 5), (4, 8), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_583_i0 : Finset Cell := ⟨(([(2, 7), (2, 9), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 8), (4, 9), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 8), (7, 9), (7, 10), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 5), (10, 6), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_583_i0 : Fin 2 → Finset Cell := ![(placed21 6 (7, 6) required_3), required_583_i1] +def childrenD_583_i0 : Fin 2 → Finset Cell := ![(placed21 6 (7, 6) envelope_3), envelope_583_i1] +theorem common_sub_583_i0 : commonEnvelope childrenD_583_i0 ⊆ insert (5, 6) required_583_i0 := by decide +kernel +theorem child_required_sub_583_i0 : ∀ j, childrenC_583_i0 j ⊆ insert (5, 6) required_583_i0 := by decide +kernel +theorem child_envelope_sub_583_i0 : ∀ j, childrenD_583_i0 j ⊆ envelope_583_i0 := by decide +kernel +theorem pivot_mem_583_i0 : (5, 6) ∈ envelope_583_i0 := by decide +kernel +theorem children_work_583_i0 : ∀ j, Template HasSnaky 9 (childrenC_583_i0 j) (childrenD_583_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_3 6 (7, 6)).mono (by decide +kernel) + · exact row_works_583_i1.mono (by decide +kernel) +theorem row_works_583_i0 : Template HasSnaky 10 required_583_i0 envelope_583_i0 := by + refine compose HasSnaky 9 childrenC_583_i0 childrenD_583_i0 children_work_583_i0 (5, 6) + required_583_i0 envelope_583_i0 pivot_mem_583_i0 child_required_sub_583_i0 child_envelope_sub_583_i0 ?_ + intro b hb + exact common_sub_583_i0 (mem_commonEnvelope childrenD_583_i0 b hb) +def required_583_i5 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 5), (4, 8), (6, 6), (6, 8), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_583_i5 : Finset Cell := ⟨(([(2, 7), (2, 9), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 8), (4, 9), (4, 10), (4, 11), (5, 6), (5, 7), (5, 8), (5, 9), (6, 6), (6, 8), (6, 9), (7, 6), (7, 8), (7, 9), (8, 8), (8, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_583_i5 : Fin 3 → Finset Cell := ![(placed21 1 (2, 8) required_7), (placed21 1 (2, 5) required_86), (placed21 1 (2, 5) required_542)] +def childrenD_583_i5 : Fin 3 → Finset Cell := ![(placed21 1 (2, 8) envelope_7), (placed21 1 (2, 5) envelope_86), (placed21 1 (2, 5) envelope_542)] +theorem common_sub_583_i5 : commonEnvelope childrenD_583_i5 ⊆ insert (5, 8) required_583_i5 := by decide +kernel +theorem child_required_sub_583_i5 : ∀ j, childrenC_583_i5 j ⊆ insert (5, 8) required_583_i5 := by decide +kernel +theorem child_envelope_sub_583_i5 : ∀ j, childrenD_583_i5 j ⊆ envelope_583_i5 := by decide +kernel +theorem pivot_mem_583_i5 : (5, 8) ∈ envelope_583_i5 := by decide +kernel +theorem children_work_583_i5 : ∀ j, Template HasSnaky 7 (childrenC_583_i5 j) (childrenD_583_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 1 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_86 1 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_542 1 (2, 5)).mono (by decide +kernel) +theorem row_works_583_i5 : Template HasSnaky 8 required_583_i5 envelope_583_i5 := by + refine compose HasSnaky 7 childrenC_583_i5 childrenD_583_i5 children_work_583_i5 (5, 8) + required_583_i5 envelope_583_i5 pivot_mem_583_i5 child_required_sub_583_i5 child_envelope_sub_583_i5 ?_ + intro b hb + exact common_sub_583_i5 (mem_commonEnvelope childrenD_583_i5 b hb) +def required_583_i6 : Finset Cell := ⟨(([(3, 8), (4, 8), (6, 6), (6, 8), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_583_i6 : Finset Cell := ⟨(([(3, 8), (4, 8), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (7, 9), (7, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_583_i6 : Fin 3 → Finset Cell := ![(placed21 2 (7, 5) required_48), (placed21 0 (3, 5) required_109), (placed21 2 (7, 5) required_246)] +def childrenD_583_i6 : Fin 3 → Finset Cell := ![(placed21 2 (7, 5) envelope_48), (placed21 0 (3, 5) envelope_109), (placed21 2 (7, 5) envelope_246)] +theorem common_sub_583_i6 : commonEnvelope childrenD_583_i6 ⊆ insert (6, 7) required_583_i6 := by decide +kernel +theorem child_required_sub_583_i6 : ∀ j, childrenC_583_i6 j ⊆ insert (6, 7) required_583_i6 := by decide +kernel +theorem child_envelope_sub_583_i6 : ∀ j, childrenD_583_i6 j ⊆ envelope_583_i6 := by decide +kernel +theorem pivot_mem_583_i6 : (6, 7) ∈ envelope_583_i6 := by decide +kernel +theorem children_work_583_i6 : ∀ j, Template HasSnaky 4 (childrenC_583_i6 j) (childrenD_583_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_48 2 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_109 0 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_246 2 (7, 5)).mono (by decide +kernel) +theorem row_works_583_i6 : Template HasSnaky 5 required_583_i6 envelope_583_i6 := by + refine compose HasSnaky 4 childrenC_583_i6 childrenD_583_i6 children_work_583_i6 (6, 7) + required_583_i6 envelope_583_i6 pivot_mem_583_i6 child_required_sub_583_i6 child_envelope_sub_583_i6 ?_ + intro b hb + exact common_sub_583_i6 (mem_commonEnvelope childrenD_583_i6 b hb) +def required_583_i4 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 5), (4, 8), (6, 6), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_583_i4 : Finset Cell := ⟨(([(0, 9), (0, 10), (1, 9), (1, 10), (2, 7), (2, 9), (2, 10), (2, 11), (2, 12), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 5), (4, 6), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 9), (9, 10), (9, 11), (9, 12), (10, 10), (10, 12)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_583_i4 : Fin 5 → Finset Cell := ![(placed21 2 (7, 5) required_184), (placed21 2 (7, 5) required_423), required_583_i5, (placed21 1 (0, 5) required_572), required_583_i6] +def childrenD_583_i4 : Fin 5 → Finset Cell := ![(placed21 2 (7, 5) envelope_184), (placed21 2 (7, 5) envelope_423), envelope_583_i5, (placed21 1 (0, 5) envelope_572), envelope_583_i6] +theorem common_sub_583_i4 : commonEnvelope childrenD_583_i4 ⊆ insert (6, 8) required_583_i4 := by decide +kernel +theorem child_required_sub_583_i4 : ∀ j, childrenC_583_i4 j ⊆ insert (6, 8) required_583_i4 := by decide +kernel +theorem child_envelope_sub_583_i4 : ∀ j, childrenD_583_i4 j ⊆ envelope_583_i4 := by decide +kernel +theorem pivot_mem_583_i4 : (6, 8) ∈ envelope_583_i4 := by decide +kernel +theorem children_work_583_i4 : ∀ j, Template HasSnaky 13 (childrenC_583_i4 j) (childrenD_583_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_184 2 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_423 2 (7, 5)).mono (by decide +kernel) + · exact row_works_583_i5.mono (by decide +kernel) + · exact (placed21_template row_works_572 1 (0, 5)).mono (by decide +kernel) + · exact row_works_583_i6.mono (by decide +kernel) +theorem row_works_583_i4 : Template HasSnaky 14 required_583_i4 envelope_583_i4 := by + refine compose HasSnaky 13 childrenC_583_i4 childrenD_583_i4 children_work_583_i4 (6, 8) + required_583_i4 envelope_583_i4 pivot_mem_583_i4 child_required_sub_583_i4 child_envelope_sub_583_i4 ?_ + intro b hb + exact common_sub_583_i4 (mem_commonEnvelope childrenD_583_i4 b hb) +def required_583 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 5), (4, 8), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_583 : Finset Cell := ⟨(([(0, 9), (0, 10), (1, 9), (1, 10), (2, 6), (2, 7), (2, 9), (2, 10), (2, 11), (2, 12), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 5), (4, 6), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 12), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (12, 3), (12, 5), (12, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_583 : Fin 8 → Finset Cell := ![(placed21 0 (3, 2) required_401), (placed21 4 (0, 12) required_552), (placed21 0 (3, 2) required_556), (placed21 0 (3, 2) required_575), required_583_i0, (placed21 4 (5, 10) required_579), required_583_i4, (placed21 1 (0, 4) required_582)] +def childrenD_583 : Fin 8 → Finset Cell := ![(placed21 0 (3, 2) envelope_401), (placed21 4 (0, 12) envelope_552), (placed21 0 (3, 2) envelope_556), (placed21 0 (3, 2) envelope_575), envelope_583_i0, (placed21 4 (5, 10) envelope_579), envelope_583_i4, (placed21 1 (0, 4) envelope_582)] +theorem common_sub_583 : commonEnvelope childrenD_583 ⊆ insert (7, 6) required_583 := by decide +kernel +theorem child_required_sub_583 : ∀ j, childrenC_583 j ⊆ insert (7, 6) required_583 := by decide +kernel +theorem child_envelope_sub_583 : ∀ j, childrenD_583 j ⊆ envelope_583 := by decide +kernel +theorem pivot_mem_583 : (7, 6) ∈ envelope_583 := by decide +kernel +theorem children_work_583 : ∀ j, Template HasSnaky 14 (childrenC_583 j) (childrenD_583 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_401 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_552 4 (0, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_556 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_575 0 (3, 2)).mono (by decide +kernel) + · exact row_works_583_i0.mono (by decide +kernel) + · exact (placed21_template row_works_579 4 (5, 10)).mono (by decide +kernel) + · exact row_works_583_i4.mono (by decide +kernel) + · exact (placed21_template row_works_582 1 (0, 4)).mono (by decide +kernel) +theorem row_works_583 : Template HasSnaky 15 required_583 envelope_583 := by + refine compose HasSnaky 14 childrenC_583 childrenD_583 children_work_583 (7, 6) + required_583 envelope_583 pivot_mem_583 child_required_sub_583 child_envelope_sub_583 ?_ + intro b hb + exact common_sub_583 (mem_commonEnvelope childrenD_583 b hb) +def required_648 : Finset Cell := ⟨(([(4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_648 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 1), (10, 3), (10, 4), (10, 5), (11, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_648 : Fin 12 → Finset Cell := ![(placed21 0 (1, 1) required_174), (placed21 0 (2, 1) required_475), (placed21 0 (1, 0) required_480), (placed21 2 (7, 0) required_480), (placed21 4 (2, 8) required_483), (placed21 0 (1, 1) required_566), (placed21 0 (2, 1) required_587), (placed21 4 (2, 8) required_587), (placed21 1 (1, 2) required_605), (placed21 0 (2, 0) required_635), required_644, required_647] +def childrenD_648 : Fin 12 → Finset Cell := ![(placed21 0 (1, 1) envelope_174), (placed21 0 (2, 1) envelope_475), (placed21 0 (1, 0) envelope_480), (placed21 2 (7, 0) envelope_480), (placed21 4 (2, 8) envelope_483), (placed21 0 (1, 1) envelope_566), (placed21 0 (2, 1) envelope_587), (placed21 4 (2, 8) envelope_587), (placed21 1 (1, 2) envelope_605), (placed21 0 (2, 0) envelope_635), envelope_644, envelope_647] +theorem common_sub_648 : commonEnvelope childrenD_648 ⊆ insert (4, 4) required_648 := by decide +kernel +theorem child_required_sub_648 : ∀ j, childrenC_648 j ⊆ insert (4, 4) required_648 := by decide +kernel +theorem child_envelope_sub_648 : ∀ j, childrenD_648 j ⊆ envelope_648 := by decide +kernel +theorem pivot_mem_648 : (4, 4) ∈ envelope_648 := by decide +kernel +theorem children_work_648 : ∀ j, Template HasSnaky 14 (childrenC_648 j) (childrenD_648 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_174 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_475 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_480 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_480 2 (7, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_483 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_566 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_587 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_587 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_605 1 (1, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_635 0 (2, 0)).mono (by decide +kernel) + · exact row_works_644.mono (by decide +kernel) + · exact row_works_647.mono (by decide +kernel) +theorem row_works_648 : Template HasSnaky 15 required_648 envelope_648 := by + refine compose HasSnaky 14 childrenC_648 childrenD_648 children_work_648 (4, 4) + required_648 envelope_648 pivot_mem_648 child_required_sub_648 child_envelope_sub_648 ?_ + intro b hb + exact common_sub_648 (mem_commonEnvelope childrenD_648 b hb) +def required_656_i1 : Finset Cell := ⟨(([(5, 5), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_656_i1 : Finset Cell := ⟨(([(2, 3), (2, 5), (3, 3), (3, 4), (3, 5), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 3), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_656_i1 : Fin 7 → Finset Cell := ![(placed21 1 (2, 3) required_117), (placed21 3 (3, 7) required_134), (placed21 3 (3, 7) required_180), (placed21 6 (6, 9) required_337), (placed21 6 (8, 9) required_341), (placed21 3 (2, 7) required_435), (placed21 3 (3, 6) required_558)] +def childrenD_656_i1 : Fin 7 → Finset Cell := ![(placed21 1 (2, 3) envelope_117), (placed21 3 (3, 7) envelope_134), (placed21 3 (3, 7) envelope_180), (placed21 6 (6, 9) envelope_337), (placed21 6 (8, 9) envelope_341), (placed21 3 (2, 7) envelope_435), (placed21 3 (3, 6) envelope_558)] +theorem common_sub_656_i1 : commonEnvelope childrenD_656_i1 ⊆ insert (5, 4) required_656_i1 := by decide +kernel +theorem child_required_sub_656_i1 : ∀ j, childrenC_656_i1 j ⊆ insert (5, 4) required_656_i1 := by decide +kernel +theorem child_envelope_sub_656_i1 : ∀ j, childrenD_656_i1 j ⊆ envelope_656_i1 := by decide +kernel +theorem pivot_mem_656_i1 : (5, 4) ∈ envelope_656_i1 := by decide +kernel +theorem children_work_656_i1 : ∀ j, Template HasSnaky 8 (childrenC_656_i1 j) (childrenD_656_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_117 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_134 3 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_180 3 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_337 6 (6, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_341 6 (8, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_435 3 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_558 3 (3, 6)).mono (by decide +kernel) +theorem row_works_656_i1 : Template HasSnaky 9 required_656_i1 envelope_656_i1 := by + refine compose HasSnaky 8 childrenC_656_i1 childrenD_656_i1 children_work_656_i1 (5, 4) + required_656_i1 envelope_656_i1 pivot_mem_656_i1 child_required_sub_656_i1 child_envelope_sub_656_i1 ?_ + intro b hb + exact common_sub_656_i1 (mem_commonEnvelope childrenD_656_i1 b hb) +def required_656_i2 : Finset Cell := ⟨(([(2, 5), (5, 5), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_656_i2 : Finset Cell := ⟨(([(1, 7), (2, 5), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 4), (8, 5), (8, 6), (9, 4), (9, 5), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_656_i2 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) required_1), (placed21 1 (1, 2) required_651)] +def childrenD_656_i2 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) envelope_1), (placed21 1 (1, 2) envelope_651)] +theorem common_sub_656_i2 : commonEnvelope childrenD_656_i2 ⊆ insert (4, 5) required_656_i2 := by decide +kernel +theorem child_required_sub_656_i2 : ∀ j, childrenC_656_i2 j ⊆ insert (4, 5) required_656_i2 := by decide +kernel +theorem child_envelope_sub_656_i2 : ∀ j, childrenD_656_i2 j ⊆ envelope_656_i2 := by decide +kernel +theorem pivot_mem_656_i2 : (4, 5) ∈ envelope_656_i2 := by decide +kernel +theorem children_work_656_i2 : ∀ j, Template HasSnaky 8 (childrenC_656_i2 j) (childrenD_656_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_651 1 (1, 2)).mono (by decide +kernel) +theorem row_works_656_i2 : Template HasSnaky 9 required_656_i2 envelope_656_i2 := by + refine compose HasSnaky 8 childrenC_656_i2 childrenD_656_i2 children_work_656_i2 (4, 5) + required_656_i2 envelope_656_i2 pivot_mem_656_i2 child_required_sub_656_i2 child_envelope_sub_656_i2 ?_ + intro b hb + exact common_sub_656_i2 (mem_commonEnvelope childrenD_656_i2 b hb) +def required_656_i3 : Finset Cell := ⟨(([(2, 5), (5, 5), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_656_i3 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_656_i3 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) required_1), (placed21 4 (3, 9) required_652)] +def childrenD_656_i3 : Fin 2 → Finset Cell := ![(placed21 0 (2, 5) envelope_1), (placed21 4 (3, 9) envelope_652)] +theorem common_sub_656_i3 : commonEnvelope childrenD_656_i3 ⊆ insert (4, 5) required_656_i3 := by decide +kernel +theorem child_required_sub_656_i3 : ∀ j, childrenC_656_i3 j ⊆ insert (4, 5) required_656_i3 := by decide +kernel +theorem child_envelope_sub_656_i3 : ∀ j, childrenD_656_i3 j ⊆ envelope_656_i3 := by decide +kernel +theorem pivot_mem_656_i3 : (4, 5) ∈ envelope_656_i3 := by decide +kernel +theorem children_work_656_i3 : ∀ j, Template HasSnaky 10 (childrenC_656_i3 j) (childrenD_656_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 0 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_652 4 (3, 9)).mono (by decide +kernel) +theorem row_works_656_i3 : Template HasSnaky 11 required_656_i3 envelope_656_i3 := by + refine compose HasSnaky 10 childrenC_656_i3 childrenD_656_i3 children_work_656_i3 (4, 5) + required_656_i3 envelope_656_i3 pivot_mem_656_i3 child_required_sub_656_i3 child_envelope_sub_656_i3 ?_ + intro b hb + exact common_sub_656_i3 (mem_commonEnvelope childrenD_656_i3 b hb) +def required_656_i0 : Finset Cell := ⟨(([(2, 5), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_656_i0 : Finset Cell := ⟨(([(1, 7), (2, 3), (2, 5), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (9, 3), (9, 4), (9, 5), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_656_i0 : Fin 8 → Finset Cell := ![(placed21 6 (7, 9) required_248), (placed21 6 (7, 9) required_300), (placed21 6 (8, 9) required_436), (placed21 3 (2, 8) required_449), (placed21 3 (2, 8) required_510), required_656_i1, required_656_i2, required_656_i3] +def childrenD_656_i0 : Fin 8 → Finset Cell := ![(placed21 6 (7, 9) envelope_248), (placed21 6 (7, 9) envelope_300), (placed21 6 (8, 9) envelope_436), (placed21 3 (2, 8) envelope_449), (placed21 3 (2, 8) envelope_510), envelope_656_i1, envelope_656_i2, envelope_656_i3] +theorem common_sub_656_i0 : commonEnvelope childrenD_656_i0 ⊆ insert (5, 5) required_656_i0 := by decide +kernel +theorem child_required_sub_656_i0 : ∀ j, childrenC_656_i0 j ⊆ insert (5, 5) required_656_i0 := by decide +kernel +theorem child_envelope_sub_656_i0 : ∀ j, childrenD_656_i0 j ⊆ envelope_656_i0 := by decide +kernel +theorem pivot_mem_656_i0 : (5, 5) ∈ envelope_656_i0 := by decide +kernel +theorem children_work_656_i0 : ∀ j, Template HasSnaky 11 (childrenC_656_i0 j) (childrenD_656_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_248 6 (7, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_300 6 (7, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_436 6 (8, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_449 3 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_510 3 (2, 8)).mono (by decide +kernel) + · exact row_works_656_i1.mono (by decide +kernel) + · exact row_works_656_i2.mono (by decide +kernel) + · exact row_works_656_i3.mono (by decide +kernel) +theorem row_works_656_i0 : Template HasSnaky 12 required_656_i0 envelope_656_i0 := by + refine compose HasSnaky 11 childrenC_656_i0 childrenD_656_i0 children_work_656_i0 (5, 5) + required_656_i0 envelope_656_i0 pivot_mem_656_i0 child_required_sub_656_i0 child_envelope_sub_656_i0 ?_ + intro b hb + exact common_sub_656_i0 (mem_commonEnvelope childrenD_656_i0 b hb) +def required_656 : Finset Cell := ⟨(([(2, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_656 : Finset Cell := ⟨(([(0, 7), (1, 5), (1, 7), (1, 8), (1, 9), (2, 3), (2, 5), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 2), (3, 3), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_656 : Fin 11 → Finset Cell := ![(placed21 0 (3, 3) required_508), (placed21 4 (3, 9) required_508), (placed21 0 (3, 3) required_605), (placed21 4 (3, 9) required_605), (placed21 5 (10, 2) required_644), (placed21 5 (10, 2) required_645), (placed21 5 (10, 2) required_647), (placed21 0 (2, 1) required_650), (placed21 4 (2, 11) required_650), required_656_i0, (placed21 5 (9, 3) required_654)] +def childrenD_656 : Fin 11 → Finset Cell := ![(placed21 0 (3, 3) envelope_508), (placed21 4 (3, 9) envelope_508), (placed21 0 (3, 3) envelope_605), (placed21 4 (3, 9) envelope_605), (placed21 5 (10, 2) envelope_644), (placed21 5 (10, 2) envelope_645), (placed21 5 (10, 2) envelope_647), (placed21 0 (2, 1) envelope_650), (placed21 4 (2, 11) envelope_650), envelope_656_i0, (placed21 5 (9, 3) envelope_654)] +theorem common_sub_656 : commonEnvelope childrenD_656 ⊆ insert (6, 6) required_656 := by decide +kernel +theorem child_required_sub_656 : ∀ j, childrenC_656 j ⊆ insert (6, 6) required_656 := by decide +kernel +theorem child_envelope_sub_656 : ∀ j, childrenD_656 j ⊆ envelope_656 := by decide +kernel +theorem pivot_mem_656 : (6, 6) ∈ envelope_656 := by decide +kernel +theorem children_work_656 : ∀ j, Template HasSnaky 14 (childrenC_656 j) (childrenD_656 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_508 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_508 4 (3, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_605 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_605 4 (3, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_644 5 (10, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_645 5 (10, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_647 5 (10, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_650 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_650 4 (2, 11)).mono (by decide +kernel) + · exact row_works_656_i0.mono (by decide +kernel) + · exact (placed21_template row_works_654 5 (9, 3)).mono (by decide +kernel) +theorem row_works_656 : Template HasSnaky 15 required_656 envelope_656 := by + refine compose HasSnaky 14 childrenC_656 childrenD_656 children_work_656 (6, 6) + required_656 envelope_656 pivot_mem_656 child_required_sub_656 child_envelope_sub_656 ?_ + intro b hb + exact common_sub_656 (mem_commonEnvelope childrenD_656 b hb) +def height_573_i0 : ℕ := 8 +def childrenH_573_i0 : Fin 5 → ℕ := ![height_8, height_115, height_197, height_286, height_339] +theorem height_exact_573_i0 : height_573_i0 = 1 + Finset.univ.sup childrenH_573_i0 := by decide +kernel +theorem required_origin_573_i0 : ∀ x ∈ required_573_i0, + (∃ j, x ∈ childrenC_573_i0 j) ∨ ∀ j, x ∈ childrenD_573_i0 j := by decide +kernel +theorem required_exact_573_i0 : required_573_i0 = + ((Finset.univ.biUnion childrenC_573_i0) ∪ commonEnvelope childrenD_573_i0).erase (3, 5) := by + exact required_eq_combination childrenC_573_i0 childrenD_573_i0 (3, 5) required_573_i0 + (by decide +kernel) child_required_sub_573_i0 common_sub_573_i0 required_origin_573_i0 +theorem envelope_origin_573_i0 : ∀ x ∈ envelope_573_i0, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_573_i0 j := by decide +kernel +theorem envelope_exact_573_i0 : envelope_573_i0 = + insert (3, 5) (Finset.univ.biUnion childrenD_573_i0) := by + exact envelope_eq_combination childrenD_573_i0 (3, 5) envelope_573_i0 + pivot_mem_573_i0 child_envelope_sub_573_i0 envelope_origin_573_i0 +def checked_573_i0 : CheckedCard where + required := required_573_i0 + envelope := envelope_573_i0 + height := height_573_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_573_i0 +def height_573_i1 : ℕ := 9 +def childrenH_573_i1 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_473] +theorem height_exact_573_i1 : height_573_i1 = 1 + Finset.univ.sup childrenH_573_i1 := by decide +kernel +theorem required_origin_573_i1 : ∀ x ∈ required_573_i1, + (∃ j, x ∈ childrenC_573_i1 j) ∨ ∀ j, x ∈ childrenD_573_i1 j := by decide +kernel +theorem required_exact_573_i1 : required_573_i1 = + ((Finset.univ.biUnion childrenC_573_i1) ∪ commonEnvelope childrenD_573_i1).erase (3, 5) := by + exact required_eq_combination childrenC_573_i1 childrenD_573_i1 (3, 5) required_573_i1 + (by decide +kernel) child_required_sub_573_i1 common_sub_573_i1 required_origin_573_i1 +theorem envelope_origin_573_i1 : ∀ x ∈ envelope_573_i1, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_573_i1 j := by decide +kernel +theorem envelope_exact_573_i1 : envelope_573_i1 = + insert (3, 5) (Finset.univ.biUnion childrenD_573_i1) := by + exact envelope_eq_combination childrenD_573_i1 (3, 5) envelope_573_i1 + pivot_mem_573_i1 child_envelope_sub_573_i1 envelope_origin_573_i1 +def checked_573_i1 : CheckedCard where + required := required_573_i1 + envelope := envelope_573_i1 + height := height_573_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_573_i1 +def height_573_i2 : ℕ := 8 +def childrenH_573_i2 : Fin 4 → ℕ := ![height_8, height_403, height_487, height_492] +theorem height_exact_573_i2 : height_573_i2 = 1 + Finset.univ.sup childrenH_573_i2 := by decide +kernel +theorem required_origin_573_i2 : ∀ x ∈ required_573_i2, + (∃ j, x ∈ childrenC_573_i2 j) ∨ ∀ j, x ∈ childrenD_573_i2 j := by decide +kernel +theorem required_exact_573_i2 : required_573_i2 = + ((Finset.univ.biUnion childrenC_573_i2) ∪ commonEnvelope childrenD_573_i2).erase (3, 5) := by + exact required_eq_combination childrenC_573_i2 childrenD_573_i2 (3, 5) required_573_i2 + (by decide +kernel) child_required_sub_573_i2 common_sub_573_i2 required_origin_573_i2 +theorem envelope_origin_573_i2 : ∀ x ∈ envelope_573_i2, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_573_i2 j := by decide +kernel +theorem envelope_exact_573_i2 : envelope_573_i2 = + insert (3, 5) (Finset.univ.biUnion childrenD_573_i2) := by + exact envelope_eq_combination childrenD_573_i2 (3, 5) envelope_573_i2 + pivot_mem_573_i2 child_envelope_sub_573_i2 envelope_origin_573_i2 +def checked_573_i2 : CheckedCard where + required := required_573_i2 + envelope := envelope_573_i2 + height := height_573_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_573_i2 +def height_573_i3 : ℕ := 8 +def childrenH_573_i3 : Fin 2 → ℕ := ![height_87, height_487] +theorem height_exact_573_i3 : height_573_i3 = 1 + Finset.univ.sup childrenH_573_i3 := by decide +kernel +theorem required_origin_573_i3 : ∀ x ∈ required_573_i3, + (∃ j, x ∈ childrenC_573_i3 j) ∨ ∀ j, x ∈ childrenD_573_i3 j := by decide +kernel +theorem required_exact_573_i3 : required_573_i3 = + ((Finset.univ.biUnion childrenC_573_i3) ∪ commonEnvelope childrenD_573_i3).erase (3, 5) := by + exact required_eq_combination childrenC_573_i3 childrenD_573_i3 (3, 5) required_573_i3 + (by decide +kernel) child_required_sub_573_i3 common_sub_573_i3 required_origin_573_i3 +theorem envelope_origin_573_i3 : ∀ x ∈ envelope_573_i3, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_573_i3 j := by decide +kernel +theorem envelope_exact_573_i3 : envelope_573_i3 = + insert (3, 5) (Finset.univ.biUnion childrenD_573_i3) := by + exact envelope_eq_combination childrenD_573_i3 (3, 5) envelope_573_i3 + pivot_mem_573_i3 child_envelope_sub_573_i3 envelope_origin_573_i3 +def checked_573_i3 : CheckedCard where + required := required_573_i3 + envelope := envelope_573_i3 + height := height_573_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_573_i3 +def height_573_i4 : ℕ := 14 +def childrenH_573_i4 : Fin 2 → ℕ := ![height_107, height_572] +theorem height_exact_573_i4 : height_573_i4 = 1 + Finset.univ.sup childrenH_573_i4 := by decide +kernel +theorem required_origin_573_i4 : ∀ x ∈ required_573_i4, + (∃ j, x ∈ childrenC_573_i4 j) ∨ ∀ j, x ∈ childrenD_573_i4 j := by decide +kernel +theorem required_exact_573_i4 : required_573_i4 = + ((Finset.univ.biUnion childrenC_573_i4) ∪ commonEnvelope childrenD_573_i4).erase (1, 7) := by + exact required_eq_combination childrenC_573_i4 childrenD_573_i4 (1, 7) required_573_i4 + (by decide +kernel) child_required_sub_573_i4 common_sub_573_i4 required_origin_573_i4 +theorem envelope_origin_573_i4 : ∀ x ∈ envelope_573_i4, + x = (1, 7) ∨ ∃ j, x ∈ childrenD_573_i4 j := by decide +kernel +theorem envelope_exact_573_i4 : envelope_573_i4 = + insert (1, 7) (Finset.univ.biUnion childrenD_573_i4) := by + exact envelope_eq_combination childrenD_573_i4 (1, 7) envelope_573_i4 + pivot_mem_573_i4 child_envelope_sub_573_i4 envelope_origin_573_i4 +def checked_573_i4 : CheckedCard where + required := required_573_i4 + envelope := envelope_573_i4 + height := height_573_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_573_i4 +def height_573_i5 : ℕ := 7 +def childrenH_573_i5 : Fin 4 → ℕ := ![height_9, height_249, height_383, height_403] +theorem height_exact_573_i5 : height_573_i5 = 1 + Finset.univ.sup childrenH_573_i5 := by decide +kernel +theorem required_origin_573_i5 : ∀ x ∈ required_573_i5, + (∃ j, x ∈ childrenC_573_i5 j) ∨ ∀ j, x ∈ childrenD_573_i5 j := by decide +kernel +theorem required_exact_573_i5 : required_573_i5 = + ((Finset.univ.biUnion childrenC_573_i5) ∪ commonEnvelope childrenD_573_i5).erase (3, 5) := by + exact required_eq_combination childrenC_573_i5 childrenD_573_i5 (3, 5) required_573_i5 + (by decide +kernel) child_required_sub_573_i5 common_sub_573_i5 required_origin_573_i5 +theorem envelope_origin_573_i5 : ∀ x ∈ envelope_573_i5, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_573_i5 j := by decide +kernel +theorem envelope_exact_573_i5 : envelope_573_i5 = + insert (3, 5) (Finset.univ.biUnion childrenD_573_i5) := by + exact envelope_eq_combination childrenD_573_i5 (3, 5) envelope_573_i5 + pivot_mem_573_i5 child_envelope_sub_573_i5 envelope_origin_573_i5 +def checked_573_i5 : CheckedCard where + required := required_573_i5 + envelope := envelope_573_i5 + height := height_573_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_573_i5 +def height_573 : ℕ := 15 +def childrenH_573 : Fin 10 → ℕ := ![height_384, height_385, height_493, height_494, height_573_i0, height_573_i1, height_573_i2, height_573_i3, height_573_i4, height_573_i5] +theorem height_exact_573 : height_573 = 1 + Finset.univ.sup childrenH_573 := by decide +kernel +theorem required_origin_573 : ∀ x ∈ required_573, + (∃ j, x ∈ childrenC_573 j) ∨ ∀ j, x ∈ childrenD_573 j := by decide +kernel +theorem required_exact_573 : required_573 = + ((Finset.univ.biUnion childrenC_573) ∪ commonEnvelope childrenD_573).erase (3, 6) := by + exact required_eq_combination childrenC_573 childrenD_573 (3, 6) required_573 + (by decide +kernel) child_required_sub_573 common_sub_573 required_origin_573 +theorem envelope_origin_573 : ∀ x ∈ envelope_573, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_573 j := by decide +kernel +theorem envelope_exact_573 : envelope_573 = + insert (3, 6) (Finset.univ.biUnion childrenD_573) := by + exact envelope_eq_combination childrenD_573 (3, 6) envelope_573 + pivot_mem_573 child_envelope_sub_573 envelope_origin_573 +def checked_573 : CheckedCard where + required := required_573 + envelope := envelope_573 + height := height_573 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_573 +def height_583_i2 : ℕ := 8 +def childrenH_583_i2 : Fin 2 → ℕ := ![height_6, height_576] +theorem height_exact_583_i2 : height_583_i2 = 1 + Finset.univ.sup childrenH_583_i2 := by decide +kernel +theorem required_origin_583_i2 : ∀ x ∈ required_583_i2, + (∃ j, x ∈ childrenC_583_i2 j) ∨ ∀ j, x ∈ childrenD_583_i2 j := by decide +kernel +theorem required_exact_583_i2 : required_583_i2 = + ((Finset.univ.biUnion childrenC_583_i2) ∪ commonEnvelope childrenD_583_i2).erase (9, 6) := by + exact required_eq_combination childrenC_583_i2 childrenD_583_i2 (9, 6) required_583_i2 + (by decide +kernel) child_required_sub_583_i2 common_sub_583_i2 required_origin_583_i2 +theorem envelope_origin_583_i2 : ∀ x ∈ envelope_583_i2, + x = (9, 6) ∨ ∃ j, x ∈ childrenD_583_i2 j := by decide +kernel +theorem envelope_exact_583_i2 : envelope_583_i2 = + insert (9, 6) (Finset.univ.biUnion childrenD_583_i2) := by + exact envelope_eq_combination childrenD_583_i2 (9, 6) envelope_583_i2 + pivot_mem_583_i2 child_envelope_sub_583_i2 envelope_origin_583_i2 +def checked_583_i2 : CheckedCard where + required := required_583_i2 + envelope := envelope_583_i2 + height := height_583_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_583_i2 +def height_583_i3 : ℕ := 8 +def childrenH_583_i3 : Fin 2 → ℕ := ![height_6, height_576] +theorem height_exact_583_i3 : height_583_i3 = 1 + Finset.univ.sup childrenH_583_i3 := by decide +kernel +theorem required_origin_583_i3 : ∀ x ∈ required_583_i3, + (∃ j, x ∈ childrenC_583_i3 j) ∨ ∀ j, x ∈ childrenD_583_i3 j := by decide +kernel +theorem required_exact_583_i3 : required_583_i3 = + ((Finset.univ.biUnion childrenC_583_i3) ∪ commonEnvelope childrenD_583_i3).erase (9, 6) := by + exact required_eq_combination childrenC_583_i3 childrenD_583_i3 (9, 6) required_583_i3 + (by decide +kernel) child_required_sub_583_i3 common_sub_583_i3 required_origin_583_i3 +theorem envelope_origin_583_i3 : ∀ x ∈ envelope_583_i3, + x = (9, 6) ∨ ∃ j, x ∈ childrenD_583_i3 j := by decide +kernel +theorem envelope_exact_583_i3 : envelope_583_i3 = + insert (9, 6) (Finset.univ.biUnion childrenD_583_i3) := by + exact envelope_eq_combination childrenD_583_i3 (9, 6) envelope_583_i3 + pivot_mem_583_i3 child_envelope_sub_583_i3 envelope_origin_583_i3 +def checked_583_i3 : CheckedCard where + required := required_583_i3 + envelope := envelope_583_i3 + height := height_583_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_583_i3 +def height_583_i1 : ℕ := 9 +def childrenH_583_i1 : Fin 4 → ℕ := ![height_8, height_321, height_583_i2, height_583_i3] +theorem height_exact_583_i1 : height_583_i1 = 1 + Finset.univ.sup childrenH_583_i1 := by decide +kernel +theorem required_origin_583_i1 : ∀ x ∈ required_583_i1, + (∃ j, x ∈ childrenC_583_i1 j) ∨ ∀ j, x ∈ childrenD_583_i1 j := by decide +kernel +theorem required_exact_583_i1 : required_583_i1 = + ((Finset.univ.biUnion childrenC_583_i1) ∪ commonEnvelope childrenD_583_i1).erase (8, 6) := by + exact required_eq_combination childrenC_583_i1 childrenD_583_i1 (8, 6) required_583_i1 + (by decide +kernel) child_required_sub_583_i1 common_sub_583_i1 required_origin_583_i1 +theorem envelope_origin_583_i1 : ∀ x ∈ envelope_583_i1, + x = (8, 6) ∨ ∃ j, x ∈ childrenD_583_i1 j := by decide +kernel +theorem envelope_exact_583_i1 : envelope_583_i1 = + insert (8, 6) (Finset.univ.biUnion childrenD_583_i1) := by + exact envelope_eq_combination childrenD_583_i1 (8, 6) envelope_583_i1 + pivot_mem_583_i1 child_envelope_sub_583_i1 envelope_origin_583_i1 +def checked_583_i1 : CheckedCard where + required := required_583_i1 + envelope := envelope_583_i1 + height := height_583_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_583_i1 +def height_583_i0 : ℕ := 10 +def childrenH_583_i0 : Fin 2 → ℕ := ![height_3, height_583_i1] +theorem height_exact_583_i0 : height_583_i0 = 1 + Finset.univ.sup childrenH_583_i0 := by decide +kernel +theorem required_origin_583_i0 : ∀ x ∈ required_583_i0, + (∃ j, x ∈ childrenC_583_i0 j) ∨ ∀ j, x ∈ childrenD_583_i0 j := by decide +kernel +theorem required_exact_583_i0 : required_583_i0 = + ((Finset.univ.biUnion childrenC_583_i0) ∪ commonEnvelope childrenD_583_i0).erase (5, 6) := by + exact required_eq_combination childrenC_583_i0 childrenD_583_i0 (5, 6) required_583_i0 + (by decide +kernel) child_required_sub_583_i0 common_sub_583_i0 required_origin_583_i0 +theorem envelope_origin_583_i0 : ∀ x ∈ envelope_583_i0, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_583_i0 j := by decide +kernel +theorem envelope_exact_583_i0 : envelope_583_i0 = + insert (5, 6) (Finset.univ.biUnion childrenD_583_i0) := by + exact envelope_eq_combination childrenD_583_i0 (5, 6) envelope_583_i0 + pivot_mem_583_i0 child_envelope_sub_583_i0 envelope_origin_583_i0 +def checked_583_i0 : CheckedCard where + required := required_583_i0 + envelope := envelope_583_i0 + height := height_583_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_583_i0 +def height_583_i5 : ℕ := 8 +def childrenH_583_i5 : Fin 3 → ℕ := ![height_7, height_86, height_542] +theorem height_exact_583_i5 : height_583_i5 = 1 + Finset.univ.sup childrenH_583_i5 := by decide +kernel +theorem required_origin_583_i5 : ∀ x ∈ required_583_i5, + (∃ j, x ∈ childrenC_583_i5 j) ∨ ∀ j, x ∈ childrenD_583_i5 j := by decide +kernel +theorem required_exact_583_i5 : required_583_i5 = + ((Finset.univ.biUnion childrenC_583_i5) ∪ commonEnvelope childrenD_583_i5).erase (5, 8) := by + exact required_eq_combination childrenC_583_i5 childrenD_583_i5 (5, 8) required_583_i5 + (by decide +kernel) child_required_sub_583_i5 common_sub_583_i5 required_origin_583_i5 +theorem envelope_origin_583_i5 : ∀ x ∈ envelope_583_i5, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_583_i5 j := by decide +kernel +theorem envelope_exact_583_i5 : envelope_583_i5 = + insert (5, 8) (Finset.univ.biUnion childrenD_583_i5) := by + exact envelope_eq_combination childrenD_583_i5 (5, 8) envelope_583_i5 + pivot_mem_583_i5 child_envelope_sub_583_i5 envelope_origin_583_i5 +def checked_583_i5 : CheckedCard where + required := required_583_i5 + envelope := envelope_583_i5 + height := height_583_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_583_i5 +def height_583_i6 : ℕ := 5 +def childrenH_583_i6 : Fin 3 → ℕ := ![height_48, height_109, height_246] +theorem height_exact_583_i6 : height_583_i6 = 1 + Finset.univ.sup childrenH_583_i6 := by decide +kernel +theorem required_origin_583_i6 : ∀ x ∈ required_583_i6, + (∃ j, x ∈ childrenC_583_i6 j) ∨ ∀ j, x ∈ childrenD_583_i6 j := by decide +kernel +theorem required_exact_583_i6 : required_583_i6 = + ((Finset.univ.biUnion childrenC_583_i6) ∪ commonEnvelope childrenD_583_i6).erase (6, 7) := by + exact required_eq_combination childrenC_583_i6 childrenD_583_i6 (6, 7) required_583_i6 + (by decide +kernel) child_required_sub_583_i6 common_sub_583_i6 required_origin_583_i6 +theorem envelope_origin_583_i6 : ∀ x ∈ envelope_583_i6, + x = (6, 7) ∨ ∃ j, x ∈ childrenD_583_i6 j := by decide +kernel +theorem envelope_exact_583_i6 : envelope_583_i6 = + insert (6, 7) (Finset.univ.biUnion childrenD_583_i6) := by + exact envelope_eq_combination childrenD_583_i6 (6, 7) envelope_583_i6 + pivot_mem_583_i6 child_envelope_sub_583_i6 envelope_origin_583_i6 +def checked_583_i6 : CheckedCard where + required := required_583_i6 + envelope := envelope_583_i6 + height := height_583_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_583_i6 +def height_583_i4 : ℕ := 14 +def childrenH_583_i4 : Fin 5 → ℕ := ![height_184, height_423, height_583_i5, height_572, height_583_i6] +theorem height_exact_583_i4 : height_583_i4 = 1 + Finset.univ.sup childrenH_583_i4 := by decide +kernel +theorem required_origin_583_i4 : ∀ x ∈ required_583_i4, + (∃ j, x ∈ childrenC_583_i4 j) ∨ ∀ j, x ∈ childrenD_583_i4 j := by decide +kernel +theorem required_exact_583_i4 : required_583_i4 = + ((Finset.univ.biUnion childrenC_583_i4) ∪ commonEnvelope childrenD_583_i4).erase (6, 8) := by + exact required_eq_combination childrenC_583_i4 childrenD_583_i4 (6, 8) required_583_i4 + (by decide +kernel) child_required_sub_583_i4 common_sub_583_i4 required_origin_583_i4 +theorem envelope_origin_583_i4 : ∀ x ∈ envelope_583_i4, + x = (6, 8) ∨ ∃ j, x ∈ childrenD_583_i4 j := by decide +kernel +theorem envelope_exact_583_i4 : envelope_583_i4 = + insert (6, 8) (Finset.univ.biUnion childrenD_583_i4) := by + exact envelope_eq_combination childrenD_583_i4 (6, 8) envelope_583_i4 + pivot_mem_583_i4 child_envelope_sub_583_i4 envelope_origin_583_i4 +def checked_583_i4 : CheckedCard where + required := required_583_i4 + envelope := envelope_583_i4 + height := height_583_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_583_i4 +def height_583 : ℕ := 15 +def childrenH_583 : Fin 8 → ℕ := ![height_401, height_552, height_556, height_575, height_583_i0, height_579, height_583_i4, height_582] +theorem height_exact_583 : height_583 = 1 + Finset.univ.sup childrenH_583 := by decide +kernel +theorem required_origin_583 : ∀ x ∈ required_583, + (∃ j, x ∈ childrenC_583 j) ∨ ∀ j, x ∈ childrenD_583 j := by decide +kernel +theorem required_exact_583 : required_583 = + ((Finset.univ.biUnion childrenC_583) ∪ commonEnvelope childrenD_583).erase (7, 6) := by + exact required_eq_combination childrenC_583 childrenD_583 (7, 6) required_583 + (by decide +kernel) child_required_sub_583 common_sub_583 required_origin_583 +theorem envelope_origin_583 : ∀ x ∈ envelope_583, + x = (7, 6) ∨ ∃ j, x ∈ childrenD_583 j := by decide +kernel +theorem envelope_exact_583 : envelope_583 = + insert (7, 6) (Finset.univ.biUnion childrenD_583) := by + exact envelope_eq_combination childrenD_583 (7, 6) envelope_583 + pivot_mem_583 child_envelope_sub_583 envelope_origin_583 +def checked_583 : CheckedCard where + required := required_583 + envelope := envelope_583 + height := height_583 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_583 +def height_648 : ℕ := 15 +def childrenH_648 : Fin 12 → ℕ := ![height_174, height_475, height_480, height_480, height_483, height_566, height_587, height_587, height_605, height_635, height_644, height_647] +theorem height_exact_648 : height_648 = 1 + Finset.univ.sup childrenH_648 := by decide +kernel +theorem required_origin_648 : ∀ x ∈ required_648, + (∃ j, x ∈ childrenC_648 j) ∨ ∀ j, x ∈ childrenD_648 j := by decide +kernel +theorem required_exact_648 : required_648 = + ((Finset.univ.biUnion childrenC_648) ∪ commonEnvelope childrenD_648).erase (4, 4) := by + exact required_eq_combination childrenC_648 childrenD_648 (4, 4) required_648 + (by decide +kernel) child_required_sub_648 common_sub_648 required_origin_648 +theorem envelope_origin_648 : ∀ x ∈ envelope_648, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_648 j := by decide +kernel +theorem envelope_exact_648 : envelope_648 = + insert (4, 4) (Finset.univ.biUnion childrenD_648) := by + exact envelope_eq_combination childrenD_648 (4, 4) envelope_648 + pivot_mem_648 child_envelope_sub_648 envelope_origin_648 +def checked_648 : CheckedCard where + required := required_648 + envelope := envelope_648 + height := height_648 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_648 +def height_656_i1 : ℕ := 9 +def childrenH_656_i1 : Fin 7 → ℕ := ![height_117, height_134, height_180, height_337, height_341, height_435, height_558] +theorem height_exact_656_i1 : height_656_i1 = 1 + Finset.univ.sup childrenH_656_i1 := by decide +kernel +theorem required_origin_656_i1 : ∀ x ∈ required_656_i1, + (∃ j, x ∈ childrenC_656_i1 j) ∨ ∀ j, x ∈ childrenD_656_i1 j := by decide +kernel +theorem required_exact_656_i1 : required_656_i1 = + ((Finset.univ.biUnion childrenC_656_i1) ∪ commonEnvelope childrenD_656_i1).erase (5, 4) := by + exact required_eq_combination childrenC_656_i1 childrenD_656_i1 (5, 4) required_656_i1 + (by decide +kernel) child_required_sub_656_i1 common_sub_656_i1 required_origin_656_i1 +theorem envelope_origin_656_i1 : ∀ x ∈ envelope_656_i1, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_656_i1 j := by decide +kernel +theorem envelope_exact_656_i1 : envelope_656_i1 = + insert (5, 4) (Finset.univ.biUnion childrenD_656_i1) := by + exact envelope_eq_combination childrenD_656_i1 (5, 4) envelope_656_i1 + pivot_mem_656_i1 child_envelope_sub_656_i1 envelope_origin_656_i1 +def checked_656_i1 : CheckedCard where + required := required_656_i1 + envelope := envelope_656_i1 + height := height_656_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_656_i1 +def height_656_i2 : ℕ := 9 +def childrenH_656_i2 : Fin 2 → ℕ := ![height_1, height_651] +theorem height_exact_656_i2 : height_656_i2 = 1 + Finset.univ.sup childrenH_656_i2 := by decide +kernel +theorem required_origin_656_i2 : ∀ x ∈ required_656_i2, + (∃ j, x ∈ childrenC_656_i2 j) ∨ ∀ j, x ∈ childrenD_656_i2 j := by decide +kernel +theorem required_exact_656_i2 : required_656_i2 = + ((Finset.univ.biUnion childrenC_656_i2) ∪ commonEnvelope childrenD_656_i2).erase (4, 5) := by + exact required_eq_combination childrenC_656_i2 childrenD_656_i2 (4, 5) required_656_i2 + (by decide +kernel) child_required_sub_656_i2 common_sub_656_i2 required_origin_656_i2 +theorem envelope_origin_656_i2 : ∀ x ∈ envelope_656_i2, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_656_i2 j := by decide +kernel +theorem envelope_exact_656_i2 : envelope_656_i2 = + insert (4, 5) (Finset.univ.biUnion childrenD_656_i2) := by + exact envelope_eq_combination childrenD_656_i2 (4, 5) envelope_656_i2 + pivot_mem_656_i2 child_envelope_sub_656_i2 envelope_origin_656_i2 +def checked_656_i2 : CheckedCard where + required := required_656_i2 + envelope := envelope_656_i2 + height := height_656_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_656_i2 +def height_656_i3 : ℕ := 11 +def childrenH_656_i3 : Fin 2 → ℕ := ![height_1, height_652] +theorem height_exact_656_i3 : height_656_i3 = 1 + Finset.univ.sup childrenH_656_i3 := by decide +kernel +theorem required_origin_656_i3 : ∀ x ∈ required_656_i3, + (∃ j, x ∈ childrenC_656_i3 j) ∨ ∀ j, x ∈ childrenD_656_i3 j := by decide +kernel +theorem required_exact_656_i3 : required_656_i3 = + ((Finset.univ.biUnion childrenC_656_i3) ∪ commonEnvelope childrenD_656_i3).erase (4, 5) := by + exact required_eq_combination childrenC_656_i3 childrenD_656_i3 (4, 5) required_656_i3 + (by decide +kernel) child_required_sub_656_i3 common_sub_656_i3 required_origin_656_i3 +theorem envelope_origin_656_i3 : ∀ x ∈ envelope_656_i3, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_656_i3 j := by decide +kernel +theorem envelope_exact_656_i3 : envelope_656_i3 = + insert (4, 5) (Finset.univ.biUnion childrenD_656_i3) := by + exact envelope_eq_combination childrenD_656_i3 (4, 5) envelope_656_i3 + pivot_mem_656_i3 child_envelope_sub_656_i3 envelope_origin_656_i3 +def checked_656_i3 : CheckedCard where + required := required_656_i3 + envelope := envelope_656_i3 + height := height_656_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_656_i3 +def height_656_i0 : ℕ := 12 +def childrenH_656_i0 : Fin 8 → ℕ := ![height_248, height_300, height_436, height_449, height_510, height_656_i1, height_656_i2, height_656_i3] +theorem height_exact_656_i0 : height_656_i0 = 1 + Finset.univ.sup childrenH_656_i0 := by decide +kernel +theorem required_origin_656_i0 : ∀ x ∈ required_656_i0, + (∃ j, x ∈ childrenC_656_i0 j) ∨ ∀ j, x ∈ childrenD_656_i0 j := by decide +kernel +theorem required_exact_656_i0 : required_656_i0 = + ((Finset.univ.biUnion childrenC_656_i0) ∪ commonEnvelope childrenD_656_i0).erase (5, 5) := by + exact required_eq_combination childrenC_656_i0 childrenD_656_i0 (5, 5) required_656_i0 + (by decide +kernel) child_required_sub_656_i0 common_sub_656_i0 required_origin_656_i0 +theorem envelope_origin_656_i0 : ∀ x ∈ envelope_656_i0, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_656_i0 j := by decide +kernel +theorem envelope_exact_656_i0 : envelope_656_i0 = + insert (5, 5) (Finset.univ.biUnion childrenD_656_i0) := by + exact envelope_eq_combination childrenD_656_i0 (5, 5) envelope_656_i0 + pivot_mem_656_i0 child_envelope_sub_656_i0 envelope_origin_656_i0 +def checked_656_i0 : CheckedCard where + required := required_656_i0 + envelope := envelope_656_i0 + height := height_656_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_656_i0 +def height_656 : ℕ := 15 +def childrenH_656 : Fin 11 → ℕ := ![height_508, height_508, height_605, height_605, height_644, height_645, height_647, height_650, height_650, height_656_i0, height_654] +theorem height_exact_656 : height_656 = 1 + Finset.univ.sup childrenH_656 := by decide +kernel +theorem required_origin_656 : ∀ x ∈ required_656, + (∃ j, x ∈ childrenC_656 j) ∨ ∀ j, x ∈ childrenD_656 j := by decide +kernel +theorem required_exact_656 : required_656 = + ((Finset.univ.biUnion childrenC_656) ∪ commonEnvelope childrenD_656).erase (6, 6) := by + exact required_eq_combination childrenC_656 childrenD_656 (6, 6) required_656 + (by decide +kernel) child_required_sub_656 common_sub_656 required_origin_656 +theorem envelope_origin_656 : ∀ x ∈ envelope_656, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_656 j := by decide +kernel +theorem envelope_exact_656 : envelope_656 = + insert (6, 6) (Finset.univ.biUnion childrenD_656) := by + exact envelope_eq_combination childrenD_656 (6, 6) envelope_656 + pivot_mem_656 child_envelope_sub_656 envelope_origin_656 +def checked_656 : CheckedCard where + required := required_656 + envelope := envelope_656 + height := height_656 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_656 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part02.lean new file mode 100644 index 0000000..9632c45 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part02.lean @@ -0,0 +1,1008 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part03 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_670_i0 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i0 : Finset Cell := ⟨(([(1, 6), (2, 4), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 9), (7, 10), (7, 11), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 6), (10, 7), (10, 8), (11, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i0 : Fin 3 → Finset Cell := ![(placed21 7 (7, 6) required_40), (placed21 1 (2, 4) required_125), (placed21 1 (1, 1) required_660)] +def childrenD_670_i0 : Fin 3 → Finset Cell := ![(placed21 7 (7, 6) envelope_40), (placed21 1 (2, 4) envelope_125), (placed21 1 (1, 1) envelope_660)] +theorem common_sub_670_i0 : commonEnvelope childrenD_670_i0 ⊆ insert (5, 5) required_670_i0 := by decide +kernel +theorem child_required_sub_670_i0 : ∀ j, childrenC_670_i0 j ⊆ insert (5, 5) required_670_i0 := by decide +kernel +theorem child_envelope_sub_670_i0 : ∀ j, childrenD_670_i0 j ⊆ envelope_670_i0 := by decide +kernel +theorem pivot_mem_670_i0 : (5, 5) ∈ envelope_670_i0 := by decide +kernel +theorem children_work_670_i0 : ∀ j, Template HasSnaky 11 (childrenC_670_i0 j) (childrenD_670_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_40 7 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_125 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_660 1 (1, 1)).mono (by decide +kernel) +theorem row_works_670_i0 : Template HasSnaky 12 required_670_i0 envelope_670_i0 := by + refine compose HasSnaky 11 childrenC_670_i0 childrenD_670_i0 children_work_670_i0 (5, 5) + required_670_i0 envelope_670_i0 pivot_mem_670_i0 child_required_sub_670_i0 child_envelope_sub_670_i0 ?_ + intro b hb + exact common_sub_670_i0 (mem_commonEnvelope childrenD_670_i0 b hb) +def required_670_i1 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i1 : Finset Cell := ⟨(([(1, 6), (2, 4), (2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 5), (9, 6), (9, 7), (9, 8), (10, 6), (10, 7), (10, 8), (11, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i1 : Fin 3 → Finset Cell := ![(placed21 7 (7, 6) required_40), (placed21 1 (2, 4) required_125), (placed21 1 (1, 3) required_663)] +def childrenD_670_i1 : Fin 3 → Finset Cell := ![(placed21 7 (7, 6) envelope_40), (placed21 1 (2, 4) envelope_125), (placed21 1 (1, 3) envelope_663)] +theorem common_sub_670_i1 : commonEnvelope childrenD_670_i1 ⊆ insert (5, 5) required_670_i1 := by decide +kernel +theorem child_required_sub_670_i1 : ∀ j, childrenC_670_i1 j ⊆ insert (5, 5) required_670_i1 := by decide +kernel +theorem child_envelope_sub_670_i1 : ∀ j, childrenD_670_i1 j ⊆ envelope_670_i1 := by decide +kernel +theorem pivot_mem_670_i1 : (5, 5) ∈ envelope_670_i1 := by decide +kernel +theorem children_work_670_i1 : ∀ j, Template HasSnaky 11 (childrenC_670_i1 j) (childrenD_670_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_40 7 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_125 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_663 1 (1, 3)).mono (by decide +kernel) +theorem row_works_670_i1 : Template HasSnaky 12 required_670_i1 envelope_670_i1 := by + refine compose HasSnaky 11 childrenC_670_i1 childrenD_670_i1 children_work_670_i1 (5, 5) + required_670_i1 envelope_670_i1 pivot_mem_670_i1 child_required_sub_670_i1 child_envelope_sub_670_i1 ?_ + intro b hb + exact common_sub_670_i1 (mem_commonEnvelope childrenD_670_i1 b hb) +def required_670_i3 : Finset Cell := ⟨(([(3, 5), (5, 6), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i3 : Finset Cell := ⟨(([(3, 5), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 4), (9, 5), (9, 6), (9, 7), (10, 4), (10, 5), (10, 6), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i3 : Fin 3 → Finset Cell := ![(placed21 1 (3, 5) required_106), (placed21 1 (3, 5) required_219), (placed21 4 (5, 9) required_530)] +def childrenD_670_i3 : Fin 3 → Finset Cell := ![(placed21 1 (3, 5) envelope_106), (placed21 1 (3, 5) envelope_219), (placed21 4 (5, 9) envelope_530)] +theorem common_sub_670_i3 : commonEnvelope childrenD_670_i3 ⊆ insert (7, 6) required_670_i3 := by decide +kernel +theorem child_required_sub_670_i3 : ∀ j, childrenC_670_i3 j ⊆ insert (7, 6) required_670_i3 := by decide +kernel +theorem child_envelope_sub_670_i3 : ∀ j, childrenD_670_i3 j ⊆ envelope_670_i3 := by decide +kernel +theorem pivot_mem_670_i3 : (7, 6) ∈ envelope_670_i3 := by decide +kernel +theorem children_work_670_i3 : ∀ j, Template HasSnaky 8 (childrenC_670_i3 j) (childrenD_670_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_106 1 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_219 1 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_530 4 (5, 9)).mono (by decide +kernel) +theorem row_works_670_i3 : Template HasSnaky 9 required_670_i3 envelope_670_i3 := by + refine compose HasSnaky 8 childrenC_670_i3 childrenD_670_i3 children_work_670_i3 (7, 6) + required_670_i3 envelope_670_i3 pivot_mem_670_i3 child_required_sub_670_i3 child_envelope_sub_670_i3 ?_ + intro b hb + exact common_sub_670_i3 (mem_commonEnvelope childrenD_670_i3 b hb) +def required_670_i4 : Finset Cell := ⟨(([(3, 4), (3, 5), (5, 6), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i4 : Finset Cell := ⟨(([(2, 4), (3, 4), (3, 5), (4, 4), (4, 5), (4, 7), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i4 : Fin 3 → Finset Cell := ![(placed21 7 (7, 6) required_40), (placed21 3 (2, 5) required_98), (placed21 4 (4, 9) required_512)] +def childrenD_670_i4 : Fin 3 → Finset Cell := ![(placed21 7 (7, 6) envelope_40), (placed21 3 (2, 5) envelope_98), (placed21 4 (4, 9) envelope_512)] +theorem common_sub_670_i4 : commonEnvelope childrenD_670_i4 ⊆ insert (5, 5) required_670_i4 := by decide +kernel +theorem child_required_sub_670_i4 : ∀ j, childrenC_670_i4 j ⊆ insert (5, 5) required_670_i4 := by decide +kernel +theorem child_envelope_sub_670_i4 : ∀ j, childrenD_670_i4 j ⊆ envelope_670_i4 := by decide +kernel +theorem pivot_mem_670_i4 : (5, 5) ∈ envelope_670_i4 := by decide +kernel +theorem children_work_670_i4 : ∀ j, Template HasSnaky 9 (childrenC_670_i4 j) (childrenD_670_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_40 7 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_98 3 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_512 4 (4, 9)).mono (by decide +kernel) +theorem row_works_670_i4 : Template HasSnaky 10 required_670_i4 envelope_670_i4 := by + refine compose HasSnaky 9 childrenC_670_i4 childrenD_670_i4 children_work_670_i4 (5, 5) + required_670_i4 envelope_670_i4 pivot_mem_670_i4 child_required_sub_670_i4 child_envelope_sub_670_i4 ?_ + intro b hb + exact common_sub_670_i4 (mem_commonEnvelope childrenD_670_i4 b hb) +def required_670_i2 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i2 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (2, 9), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (11, 4), (11, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i2 : Fin 5 → Finset Cell := ![(placed21 0 (3, 4) required_270), (placed21 2 (7, 3) required_588), (placed21 4 (4, 9) required_638), required_670_i3, required_670_i4] +def childrenD_670_i2 : Fin 5 → Finset Cell := ![(placed21 0 (3, 4) envelope_270), (placed21 2 (7, 3) envelope_588), (placed21 4 (4, 9) envelope_638), envelope_670_i3, envelope_670_i4] +theorem common_sub_670_i2 : commonEnvelope childrenD_670_i2 ⊆ insert (5, 6) required_670_i2 := by decide +kernel +theorem child_required_sub_670_i2 : ∀ j, childrenC_670_i2 j ⊆ insert (5, 6) required_670_i2 := by decide +kernel +theorem child_envelope_sub_670_i2 : ∀ j, childrenD_670_i2 j ⊆ envelope_670_i2 := by decide +kernel +theorem pivot_mem_670_i2 : (5, 6) ∈ envelope_670_i2 := by decide +kernel +theorem children_work_670_i2 : ∀ j, Template HasSnaky 12 (childrenC_670_i2 j) (childrenD_670_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_270 0 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_588 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_638 4 (4, 9)).mono (by decide +kernel) + · exact row_works_670_i3.mono (by decide +kernel) + · exact row_works_670_i4.mono (by decide +kernel) +theorem row_works_670_i2 : Template HasSnaky 13 required_670_i2 envelope_670_i2 := by + refine compose HasSnaky 12 childrenC_670_i2 childrenD_670_i2 children_work_670_i2 (5, 6) + required_670_i2 envelope_670_i2 pivot_mem_670_i2 child_required_sub_670_i2 child_envelope_sub_670_i2 ?_ + intro b hb + exact common_sub_670_i2 (mem_commonEnvelope childrenD_670_i2 b hb) +def required_670_i5 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i5 : Finset Cell := ⟨(([(2, 4), (2, 6), (2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 4), (10, 5), (10, 6), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i5 : Fin 3 → Finset Cell := ![(placed21 7 (7, 6) required_40), (placed21 1 (2, 4) required_125), (placed21 0 (2, 1) required_617)] +def childrenD_670_i5 : Fin 3 → Finset Cell := ![(placed21 7 (7, 6) envelope_40), (placed21 1 (2, 4) envelope_125), (placed21 0 (2, 1) envelope_617)] +theorem common_sub_670_i5 : commonEnvelope childrenD_670_i5 ⊆ insert (5, 5) required_670_i5 := by decide +kernel +theorem child_required_sub_670_i5 : ∀ j, childrenC_670_i5 j ⊆ insert (5, 5) required_670_i5 := by decide +kernel +theorem child_envelope_sub_670_i5 : ∀ j, childrenD_670_i5 j ⊆ envelope_670_i5 := by decide +kernel +theorem pivot_mem_670_i5 : (5, 5) ∈ envelope_670_i5 := by decide +kernel +theorem children_work_670_i5 : ∀ j, Template HasSnaky 11 (childrenC_670_i5 j) (childrenD_670_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_40 7 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_125 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_617 0 (2, 1)).mono (by decide +kernel) +theorem row_works_670_i5 : Template HasSnaky 12 required_670_i5 envelope_670_i5 := by + refine compose HasSnaky 11 childrenC_670_i5 childrenD_670_i5 children_work_670_i5 (5, 5) + required_670_i5 envelope_670_i5 pivot_mem_670_i5 child_required_sub_670_i5 child_envelope_sub_670_i5 ?_ + intro b hb + exact common_sub_670_i5 (mem_commonEnvelope childrenD_670_i5 b hb) +def required_670_i6 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i6 : Finset Cell := ⟨(([(2, 6), (2, 7), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 6), (8, 7), (9, 6), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i6 : Fin 7 → Finset Cell := ![(placed21 4 (5, 8) required_13), (placed21 4 (5, 8) required_31), (placed21 4 (3, 7) required_355), (placed21 4 (3, 8) required_356), (placed21 0 (2, 3) required_434), (placed21 1 (3, 3) required_435), (placed21 6 (7, 8) required_441)] +def childrenD_670_i6 : Fin 7 → Finset Cell := ![(placed21 4 (5, 8) envelope_13), (placed21 4 (5, 8) envelope_31), (placed21 4 (3, 7) envelope_355), (placed21 4 (3, 8) envelope_356), (placed21 0 (2, 3) envelope_434), (placed21 1 (3, 3) envelope_435), (placed21 6 (7, 8) envelope_441)] +theorem common_sub_670_i6 : commonEnvelope childrenD_670_i6 ⊆ insert (6, 4) required_670_i6 := by decide +kernel +theorem child_required_sub_670_i6 : ∀ j, childrenC_670_i6 j ⊆ insert (6, 4) required_670_i6 := by decide +kernel +theorem child_envelope_sub_670_i6 : ∀ j, childrenD_670_i6 j ⊆ envelope_670_i6 := by decide +kernel +theorem pivot_mem_670_i6 : (6, 4) ∈ envelope_670_i6 := by decide +kernel +theorem children_work_670_i6 : ∀ j, Template HasSnaky 9 (childrenC_670_i6 j) (childrenD_670_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 4 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_31 4 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_355 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_356 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_434 0 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_435 1 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_441 6 (7, 8)).mono (by decide +kernel) +theorem row_works_670_i6 : Template HasSnaky 10 required_670_i6 envelope_670_i6 := by + refine compose HasSnaky 9 childrenC_670_i6 childrenD_670_i6 children_work_670_i6 (6, 4) + required_670_i6 envelope_670_i6 pivot_mem_670_i6 child_required_sub_670_i6 child_envelope_sub_670_i6 ?_ + intro b hb + exact common_sub_670_i6 (mem_commonEnvelope childrenD_670_i6 b hb) +def required_670_i7 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i7 : Finset Cell := ⟨(([(2, 4), (2, 6), (3, 4), (3, 5), (3, 6), (4, 4), (4, 5), (4, 6), (4, 8), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 4), (10, 5), (10, 6), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i7 : Fin 3 → Finset Cell := ![(placed21 7 (7, 6) required_40), (placed21 1 (2, 4) required_125), (placed21 4 (4, 10) required_535)] +def childrenD_670_i7 : Fin 3 → Finset Cell := ![(placed21 7 (7, 6) envelope_40), (placed21 1 (2, 4) envelope_125), (placed21 4 (4, 10) envelope_535)] +theorem common_sub_670_i7 : commonEnvelope childrenD_670_i7 ⊆ insert (5, 5) required_670_i7 := by decide +kernel +theorem child_required_sub_670_i7 : ∀ j, childrenC_670_i7 j ⊆ insert (5, 5) required_670_i7 := by decide +kernel +theorem child_envelope_sub_670_i7 : ∀ j, childrenD_670_i7 j ⊆ envelope_670_i7 := by decide +kernel +theorem pivot_mem_670_i7 : (5, 5) ∈ envelope_670_i7 := by decide +kernel +theorem children_work_670_i7 : ∀ j, Template HasSnaky 10 (childrenC_670_i7 j) (childrenD_670_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_40 7 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_125 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_535 4 (4, 10)).mono (by decide +kernel) +theorem row_works_670_i7 : Template HasSnaky 11 required_670_i7 envelope_670_i7 := by + refine compose HasSnaky 10 childrenC_670_i7 childrenD_670_i7 children_work_670_i7 (5, 5) + required_670_i7 envelope_670_i7 pivot_mem_670_i7 child_required_sub_670_i7 child_envelope_sub_670_i7 ?_ + intro b hb + exact common_sub_670_i7 (mem_commonEnvelope childrenD_670_i7 b hb) +def required_670_i8 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i8 : Finset Cell := ⟨(([(2, 4), (2, 6), (2, 8), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 5), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 2), (8, 3), (8, 4), (8, 6), (9, 2), (9, 3), (9, 4), (9, 6), (10, 2), (10, 3), (10, 4), (11, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i8 : Fin 6 → Finset Cell := ![(placed21 0 (4, 2) required_188), (placed21 4 (4, 8) required_188), (placed21 6 (7, 8) required_441), (placed21 6 (7, 8) required_442), (placed21 2 (7, 3) required_514), (placed21 4 (3, 7) required_667)] +def childrenD_670_i8 : Fin 6 → Finset Cell := ![(placed21 0 (4, 2) envelope_188), (placed21 4 (4, 8) envelope_188), (placed21 6 (7, 8) envelope_441), (placed21 6 (7, 8) envelope_442), (placed21 2 (7, 3) envelope_514), (placed21 4 (3, 7) envelope_667)] +theorem common_sub_670_i8 : commonEnvelope childrenD_670_i8 ⊆ insert (6, 4) required_670_i8 := by decide +kernel +theorem child_required_sub_670_i8 : ∀ j, childrenC_670_i8 j ⊆ insert (6, 4) required_670_i8 := by decide +kernel +theorem child_envelope_sub_670_i8 : ∀ j, childrenD_670_i8 j ⊆ envelope_670_i8 := by decide +kernel +theorem pivot_mem_670_i8 : (6, 4) ∈ envelope_670_i8 := by decide +kernel +theorem children_work_670_i8 : ∀ j, Template HasSnaky 9 (childrenC_670_i8 j) (childrenD_670_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_188 0 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_188 4 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_441 6 (7, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_442 6 (7, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_514 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_667 4 (3, 7)).mono (by decide +kernel) +theorem row_works_670_i8 : Template HasSnaky 10 required_670_i8 envelope_670_i8 := by + refine compose HasSnaky 9 childrenC_670_i8 childrenD_670_i8 children_work_670_i8 (6, 4) + required_670_i8 envelope_670_i8 pivot_mem_670_i8 child_required_sub_670_i8 child_envelope_sub_670_i8 ?_ + intro b hb + exact common_sub_670_i8 (mem_commonEnvelope childrenD_670_i8 b hb) +def required_670_i10 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i10 : Finset Cell := ⟨(([(2, 4), (2, 6), (3, 4), (3, 5), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (8, 4), (9, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i10 : Fin 2 → Finset Cell := ![(placed21 1 (2, 4) required_125), (placed21 4 (4, 7) required_136)] +def childrenD_670_i10 : Fin 2 → Finset Cell := ![(placed21 1 (2, 4) envelope_125), (placed21 4 (4, 7) envelope_136)] +theorem common_sub_670_i10 : commonEnvelope childrenD_670_i10 ⊆ insert (5, 5) required_670_i10 := by decide +kernel +theorem child_required_sub_670_i10 : ∀ j, childrenC_670_i10 j ⊆ insert (5, 5) required_670_i10 := by decide +kernel +theorem child_envelope_sub_670_i10 : ∀ j, childrenD_670_i10 j ⊆ envelope_670_i10 := by decide +kernel +theorem pivot_mem_670_i10 : (5, 5) ∈ envelope_670_i10 := by decide +kernel +theorem children_work_670_i10 : ∀ j, Template HasSnaky 6 (childrenC_670_i10 j) (childrenD_670_i10 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_125 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_136 4 (4, 7)).mono (by decide +kernel) +theorem row_works_670_i10 : Template HasSnaky 7 required_670_i10 envelope_670_i10 := by + refine compose HasSnaky 6 childrenC_670_i10 childrenD_670_i10 children_work_670_i10 (5, 5) + required_670_i10 envelope_670_i10 pivot_mem_670_i10 child_required_sub_670_i10 child_envelope_sub_670_i10 ?_ + intro b hb + exact common_sub_670_i10 (mem_commonEnvelope childrenD_670_i10 b hb) +def required_670_i9 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670_i9 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (2, 9), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (9, 2), (9, 3), (9, 4), (10, 2), (10, 3), (10, 4), (11, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670_i9 : Fin 5 → Finset Cell := ![(placed21 2 (7, 2) required_13), (placed21 2 (7, 3) required_514), (placed21 2 (7, 3) required_590), (placed21 4 (3, 7) required_668), required_670_i10] +def childrenD_670_i9 : Fin 5 → Finset Cell := ![(placed21 2 (7, 2) envelope_13), (placed21 2 (7, 3) envelope_514), (placed21 2 (7, 3) envelope_590), (placed21 4 (3, 7) envelope_668), envelope_670_i10] +theorem common_sub_670_i9 : commonEnvelope childrenD_670_i9 ⊆ insert (6, 4) required_670_i9 := by decide +kernel +theorem child_required_sub_670_i9 : ∀ j, childrenC_670_i9 j ⊆ insert (6, 4) required_670_i9 := by decide +kernel +theorem child_envelope_sub_670_i9 : ∀ j, childrenD_670_i9 j ⊆ envelope_670_i9 := by decide +kernel +theorem pivot_mem_670_i9 : (6, 4) ∈ envelope_670_i9 := by decide +kernel +theorem children_work_670_i9 : ∀ j, Template HasSnaky 13 (childrenC_670_i9 j) (childrenD_670_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 2 (7, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_514 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_590 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_668 4 (3, 7)).mono (by decide +kernel) + · exact row_works_670_i10.mono (by decide +kernel) +theorem row_works_670_i9 : Template HasSnaky 14 required_670_i9 envelope_670_i9 := by + refine compose HasSnaky 13 childrenC_670_i9 childrenD_670_i9 children_work_670_i9 (6, 4) + required_670_i9 envelope_670_i9 pivot_mem_670_i9 child_required_sub_670_i9 child_envelope_sub_670_i9 ?_ + intro b hb + exact common_sub_670_i9 (mem_commonEnvelope childrenD_670_i9 b hb) +def required_670 : Finset Cell := ⟨(([(3, 4), (3, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_670 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (2, 9), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (11, 4), (11, 5), (11, 6), (11, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_670 : Fin 12 → Finset Cell := ![(placed21 0 (5, 1) required_459), required_670_i0, (placed21 4 (2, 10) required_661), required_670_i1, required_670_i2, required_670_i5, required_670_i6, required_670_i7, (placed21 1 (0, 2) required_665), required_670_i8, required_670_i9, required_669] +def childrenD_670 : Fin 12 → Finset Cell := ![(placed21 0 (5, 1) envelope_459), envelope_670_i0, (placed21 4 (2, 10) envelope_661), envelope_670_i1, envelope_670_i2, envelope_670_i5, envelope_670_i6, envelope_670_i7, (placed21 1 (0, 2) envelope_665), envelope_670_i8, envelope_670_i9, envelope_669] +theorem common_sub_670 : commonEnvelope childrenD_670 ⊆ insert (6, 6) required_670 := by decide +kernel +theorem child_required_sub_670 : ∀ j, childrenC_670 j ⊆ insert (6, 6) required_670 := by decide +kernel +theorem child_envelope_sub_670 : ∀ j, childrenD_670 j ⊆ envelope_670 := by decide +kernel +theorem pivot_mem_670 : (6, 6) ∈ envelope_670 := by decide +kernel +theorem children_work_670 : ∀ j, Template HasSnaky 14 (childrenC_670 j) (childrenD_670 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_459 0 (5, 1)).mono (by decide +kernel) + · exact row_works_670_i0.mono (by decide +kernel) + · exact (placed21_template row_works_661 4 (2, 10)).mono (by decide +kernel) + · exact row_works_670_i1.mono (by decide +kernel) + · exact row_works_670_i2.mono (by decide +kernel) + · exact row_works_670_i5.mono (by decide +kernel) + · exact row_works_670_i6.mono (by decide +kernel) + · exact row_works_670_i7.mono (by decide +kernel) + · exact (placed21_template row_works_665 1 (0, 2)).mono (by decide +kernel) + · exact row_works_670_i8.mono (by decide +kernel) + · exact row_works_670_i9.mono (by decide +kernel) + · exact row_works_669.mono (by decide +kernel) +theorem row_works_670 : Template HasSnaky 15 required_670 envelope_670 := by + refine compose HasSnaky 14 childrenC_670 childrenD_670 children_work_670 (6, 6) + required_670 envelope_670 pivot_mem_670 child_required_sub_670 child_envelope_sub_670 ?_ + intro b hb + exact common_sub_670 (mem_commonEnvelope childrenD_670 b hb) +def required_682_i0 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_682_i0 : Finset Cell := ⟨(([(1, 3), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_682_i0 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) required_44), (placed21 2 (4, 2) required_52), (placed21 4 (3, 7) required_128), (placed21 1 (1, 2) required_676)] +def childrenD_682_i0 : Fin 4 → Finset Cell := ![(placed21 2 (4, 2) envelope_44), (placed21 2 (4, 2) envelope_52), (placed21 4 (3, 7) envelope_128), (placed21 1 (1, 2) envelope_676)] +theorem common_sub_682_i0 : commonEnvelope childrenD_682_i0 ⊆ insert (4, 3) required_682_i0 := by decide +kernel +theorem child_required_sub_682_i0 : ∀ j, childrenC_682_i0 j ⊆ insert (4, 3) required_682_i0 := by decide +kernel +theorem child_envelope_sub_682_i0 : ∀ j, childrenD_682_i0 j ⊆ envelope_682_i0 := by decide +kernel +theorem pivot_mem_682_i0 : (4, 3) ∈ envelope_682_i0 := by decide +kernel +theorem children_work_682_i0 : ∀ j, Template HasSnaky 11 (childrenC_682_i0 j) (childrenD_682_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_52 2 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_128 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_676 1 (1, 2)).mono (by decide +kernel) +theorem row_works_682_i0 : Template HasSnaky 12 required_682_i0 envelope_682_i0 := by + refine compose HasSnaky 11 childrenC_682_i0 childrenD_682_i0 children_work_682_i0 (4, 3) + required_682_i0 envelope_682_i0 pivot_mem_682_i0 child_required_sub_682_i0 child_envelope_sub_682_i0 ?_ + intro b hb + exact common_sub_682_i0 (mem_commonEnvelope childrenD_682_i0 b hb) +def required_682_i5 : Finset Cell := ⟨(([(4, 6), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_682_i5 : Finset Cell := ⟨(([(3, 6), (3, 7), (4, 6), (4, 7), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_682_i5 : Fin 3 → Finset Cell := ![(placed21 0 (6, 3) required_7), (placed21 2 (7, 3) required_9), (placed21 5 (8, 4) required_386)] +def childrenD_682_i5 : Fin 3 → Finset Cell := ![(placed21 0 (6, 3) envelope_7), (placed21 2 (7, 3) envelope_9), (placed21 5 (8, 4) envelope_386)] +theorem common_sub_682_i5 : commonEnvelope childrenD_682_i5 ⊆ insert (6, 7) required_682_i5 := by decide +kernel +theorem child_required_sub_682_i5 : ∀ j, childrenC_682_i5 j ⊆ insert (6, 7) required_682_i5 := by decide +kernel +theorem child_envelope_sub_682_i5 : ∀ j, childrenD_682_i5 j ⊆ envelope_682_i5 := by decide +kernel +theorem pivot_mem_682_i5 : (6, 7) ∈ envelope_682_i5 := by decide +kernel +theorem children_work_682_i5 : ∀ j, Template HasSnaky 5 (childrenC_682_i5 j) (childrenD_682_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_386 5 (8, 4)).mono (by decide +kernel) +theorem row_works_682_i5 : Template HasSnaky 6 required_682_i5 envelope_682_i5 := by + refine compose HasSnaky 5 childrenC_682_i5 childrenD_682_i5 children_work_682_i5 (6, 7) + required_682_i5 envelope_682_i5 pivot_mem_682_i5 child_required_sub_682_i5 child_envelope_sub_682_i5 ?_ + intro b hb + exact common_sub_682_i5 (mem_commonEnvelope childrenD_682_i5 b hb) +def required_682_i6 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5), (4, 6), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_682_i6 : Finset Cell := ⟨(([(2, 7), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (5, 6), (6, 5), (6, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_682_i6 : Fin 2 → Finset Cell := ![(placed21 6 (7, 6) required_0), (placed21 1 (2, 4) required_222)] +def childrenD_682_i6 : Fin 2 → Finset Cell := ![(placed21 6 (7, 6) envelope_0), (placed21 1 (2, 4) envelope_222)] +theorem common_sub_682_i6 : commonEnvelope childrenD_682_i6 ⊆ insert (5, 6) required_682_i6 := by decide +kernel +theorem child_required_sub_682_i6 : ∀ j, childrenC_682_i6 j ⊆ insert (5, 6) required_682_i6 := by decide +kernel +theorem child_envelope_sub_682_i6 : ∀ j, childrenD_682_i6 j ⊆ envelope_682_i6 := by decide +kernel +theorem pivot_mem_682_i6 : (5, 6) ∈ envelope_682_i6 := by decide +kernel +theorem children_work_682_i6 : ∀ j, Template HasSnaky 3 (childrenC_682_i6 j) (childrenD_682_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_222 1 (2, 4)).mono (by decide +kernel) +theorem row_works_682_i6 : Template HasSnaky 4 required_682_i6 envelope_682_i6 := by + refine compose HasSnaky 3 childrenC_682_i6 childrenD_682_i6 children_work_682_i6 (5, 6) + required_682_i6 envelope_682_i6 pivot_mem_682_i6 child_required_sub_682_i6 child_envelope_sub_682_i6 ?_ + intro b hb + exact common_sub_682_i6 (mem_commonEnvelope childrenD_682_i6 b hb) +def required_682_i4 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5), (6, 4), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_682_i4 : Finset Cell := ⟨(([(2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 6), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_682_i4 : Fin 4 → Finset Cell := ![(placed21 2 (7, 3) required_377), required_682_i5, (placed21 0 (2, 3) required_426), required_682_i6] +def childrenD_682_i4 : Fin 4 → Finset Cell := ![(placed21 2 (7, 3) envelope_377), envelope_682_i5, (placed21 0 (2, 3) envelope_426), envelope_682_i6] +theorem common_sub_682_i4 : commonEnvelope childrenD_682_i4 ⊆ insert (4, 6) required_682_i4 := by decide +kernel +theorem child_required_sub_682_i4 : ∀ j, childrenC_682_i4 j ⊆ insert (4, 6) required_682_i4 := by decide +kernel +theorem child_envelope_sub_682_i4 : ∀ j, childrenD_682_i4 j ⊆ envelope_682_i4 := by decide +kernel +theorem pivot_mem_682_i4 : (4, 6) ∈ envelope_682_i4 := by decide +kernel +theorem children_work_682_i4 : ∀ j, Template HasSnaky 6 (childrenC_682_i4 j) (childrenD_682_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_377 2 (7, 3)).mono (by decide +kernel) + · exact row_works_682_i5.mono (by decide +kernel) + · exact (placed21_template row_works_426 0 (2, 3)).mono (by decide +kernel) + · exact row_works_682_i6.mono (by decide +kernel) +theorem row_works_682_i4 : Template HasSnaky 7 required_682_i4 envelope_682_i4 := by + refine compose HasSnaky 6 childrenC_682_i4 childrenD_682_i4 children_work_682_i4 (4, 6) + required_682_i4 envelope_682_i4 pivot_mem_682_i4 child_required_sub_682_i4 child_envelope_sub_682_i4 ?_ + intro b hb + exact common_sub_682_i4 (mem_commonEnvelope childrenD_682_i4 b hb) +def required_682_i3 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_682_i3 : Finset Cell := ⟨(([(2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_682_i3 : Fin 5 → Finset Cell := ![(placed21 2 (7, 2) required_13), (placed21 6 (7, 8) required_14), (placed21 4 (3, 7) required_79), (placed21 2 (7, 3) required_679), required_682_i4] +def childrenD_682_i3 : Fin 5 → Finset Cell := ![(placed21 2 (7, 2) envelope_13), (placed21 6 (7, 8) envelope_14), (placed21 4 (3, 7) envelope_79), (placed21 2 (7, 3) envelope_679), envelope_682_i4] +theorem common_sub_682_i3 : commonEnvelope childrenD_682_i3 ⊆ insert (6, 6) required_682_i3 := by decide +kernel +theorem child_required_sub_682_i3 : ∀ j, childrenC_682_i3 j ⊆ insert (6, 6) required_682_i3 := by decide +kernel +theorem child_envelope_sub_682_i3 : ∀ j, childrenD_682_i3 j ⊆ envelope_682_i3 := by decide +kernel +theorem pivot_mem_682_i3 : (6, 6) ∈ envelope_682_i3 := by decide +kernel +theorem children_work_682_i3 : ∀ j, Template HasSnaky 7 (childrenC_682_i3 j) (childrenD_682_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 2 (7, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_14 6 (7, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_79 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_679 2 (7, 3)).mono (by decide +kernel) + · exact row_works_682_i4.mono (by decide +kernel) +theorem row_works_682_i3 : Template HasSnaky 8 required_682_i3 envelope_682_i3 := by + refine compose HasSnaky 7 childrenC_682_i3 childrenD_682_i3 children_work_682_i3 (6, 6) + required_682_i3 envelope_682_i3 pivot_mem_682_i3 child_required_sub_682_i3 child_envelope_sub_682_i3 ?_ + intro b hb + exact common_sub_682_i3 (mem_commonEnvelope childrenD_682_i3 b hb) +def required_682_i2 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_682_i2 : Finset Cell := ⟨(([(2, 4), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_682_i2 : Fin 4 → Finset Cell := ![(placed21 4 (3, 8) required_59), (placed21 3 (2, 5) required_105), (placed21 2 (7, 1) required_678), required_682_i3] +def childrenD_682_i2 : Fin 4 → Finset Cell := ![(placed21 4 (3, 8) envelope_59), (placed21 3 (2, 5) envelope_105), (placed21 2 (7, 1) envelope_678), envelope_682_i3] +theorem common_sub_682_i2 : commonEnvelope childrenD_682_i2 ⊆ insert (6, 5) required_682_i2 := by decide +kernel +theorem child_required_sub_682_i2 : ∀ j, childrenC_682_i2 j ⊆ insert (6, 5) required_682_i2 := by decide +kernel +theorem child_envelope_sub_682_i2 : ∀ j, childrenD_682_i2 j ⊆ envelope_682_i2 := by decide +kernel +theorem pivot_mem_682_i2 : (6, 5) ∈ envelope_682_i2 := by decide +kernel +theorem children_work_682_i2 : ∀ j, Template HasSnaky 8 (childrenC_682_i2 j) (childrenD_682_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_59 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_105 3 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_678 2 (7, 1)).mono (by decide +kernel) + · exact row_works_682_i3.mono (by decide +kernel) +theorem row_works_682_i2 : Template HasSnaky 9 required_682_i2 envelope_682_i2 := by + refine compose HasSnaky 8 childrenC_682_i2 childrenD_682_i2 children_work_682_i2 (6, 5) + required_682_i2 envelope_682_i2 pivot_mem_682_i2 child_required_sub_682_i2 child_envelope_sub_682_i2 ?_ + intro b hb + exact common_sub_682_i2 (mem_commonEnvelope childrenD_682_i2 b hb) +def required_682_i8 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_682_i8 : Finset Cell := ⟨(([(2, 3), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (5, 1), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_682_i8 : Fin 4 → Finset Cell := ![(placed21 6 (7, 8) required_13), (placed21 4 (3, 7) required_79), (placed21 2 (7, 2) required_243), (placed21 2 (7, 3) required_679)] +def childrenD_682_i8 : Fin 4 → Finset Cell := ![(placed21 6 (7, 8) envelope_13), (placed21 4 (3, 7) envelope_79), (placed21 2 (7, 2) envelope_243), (placed21 2 (7, 3) envelope_679)] +theorem common_sub_682_i8 : commonEnvelope childrenD_682_i8 ⊆ insert (6, 6) required_682_i8 := by decide +kernel +theorem child_required_sub_682_i8 : ∀ j, childrenC_682_i8 j ⊆ insert (6, 6) required_682_i8 := by decide +kernel +theorem child_envelope_sub_682_i8 : ∀ j, childrenD_682_i8 j ⊆ envelope_682_i8 := by decide +kernel +theorem pivot_mem_682_i8 : (6, 6) ∈ envelope_682_i8 := by decide +kernel +theorem children_work_682_i8 : ∀ j, Template HasSnaky 5 (childrenC_682_i8 j) (childrenD_682_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 6 (7, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_79 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_243 2 (7, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_679 2 (7, 3)).mono (by decide +kernel) +theorem row_works_682_i8 : Template HasSnaky 6 required_682_i8 envelope_682_i8 := by + refine compose HasSnaky 5 childrenC_682_i8 childrenD_682_i8 children_work_682_i8 (6, 6) + required_682_i8 envelope_682_i8 pivot_mem_682_i8 child_required_sub_682_i8 child_envelope_sub_682_i8 ?_ + intro b hb + exact common_sub_682_i8 (mem_commonEnvelope childrenD_682_i8 b hb) +def required_682_i7 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_682_i7 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (2, 7), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 1), (7, 2), (7, 3), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_682_i7 : Fin 6 → Finset Cell := ![(placed21 0 (3, 1) required_430), (placed21 0 (2, 2) required_431), (placed21 7 (7, 5) required_592), (placed21 2 (7, 1) required_678), required_682_i8, (placed21 4 (2, 9) required_681)] +def childrenD_682_i7 : Fin 6 → Finset Cell := ![(placed21 0 (3, 1) envelope_430), (placed21 0 (2, 2) envelope_431), (placed21 7 (7, 5) envelope_592), (placed21 2 (7, 1) envelope_678), envelope_682_i8, (placed21 4 (2, 9) envelope_681)] +theorem common_sub_682_i7 : commonEnvelope childrenD_682_i7 ⊆ insert (6, 5) required_682_i7 := by decide +kernel +theorem child_required_sub_682_i7 : ∀ j, childrenC_682_i7 j ⊆ insert (6, 5) required_682_i7 := by decide +kernel +theorem child_envelope_sub_682_i7 : ∀ j, childrenD_682_i7 j ⊆ envelope_682_i7 := by decide +kernel +theorem pivot_mem_682_i7 : (6, 5) ∈ envelope_682_i7 := by decide +kernel +theorem children_work_682_i7 : ∀ j, Template HasSnaky 8 (childrenC_682_i7 j) (childrenD_682_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_430 0 (3, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_431 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_592 7 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_678 2 (7, 1)).mono (by decide +kernel) + · exact row_works_682_i8.mono (by decide +kernel) + · exact (placed21_template row_works_681 4 (2, 9)).mono (by decide +kernel) +theorem row_works_682_i7 : Template HasSnaky 9 required_682_i7 envelope_682_i7 := by + refine compose HasSnaky 8 childrenC_682_i7 childrenD_682_i7 children_work_682_i7 (6, 5) + required_682_i7 envelope_682_i7 pivot_mem_682_i7 child_required_sub_682_i7 child_envelope_sub_682_i7 ?_ + intro b hb + exact common_sub_682_i7 (mem_commonEnvelope childrenD_682_i7 b hb) +def required_682_i1 : Finset Cell := ⟨(([(3, 5), (4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_682_i1 : Finset Cell := ⟨(([(1, 3), (2, 3), (2, 4), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_682_i1 : Fin 7 → Finset Cell := ![(placed21 2 (7, 2) required_422), (placed21 4 (2, 8) required_450), (placed21 6 (7, 7) required_503), (placed21 0 (3, 0) required_642), required_682_i2, (placed21 4 (2, 7) required_680), required_682_i7] +def childrenD_682_i1 : Fin 7 → Finset Cell := ![(placed21 2 (7, 2) envelope_422), (placed21 4 (2, 8) envelope_450), (placed21 6 (7, 7) envelope_503), (placed21 0 (3, 0) envelope_642), envelope_682_i2, (placed21 4 (2, 7) envelope_680), envelope_682_i7] +theorem common_sub_682_i1 : commonEnvelope childrenD_682_i1 ⊆ insert (6, 4) required_682_i1 := by decide +kernel +theorem child_required_sub_682_i1 : ∀ j, childrenC_682_i1 j ⊆ insert (6, 4) required_682_i1 := by decide +kernel +theorem child_envelope_sub_682_i1 : ∀ j, childrenD_682_i1 j ⊆ envelope_682_i1 := by decide +kernel +theorem pivot_mem_682_i1 : (6, 4) ∈ envelope_682_i1 := by decide +kernel +theorem children_work_682_i1 : ∀ j, Template HasSnaky 13 (childrenC_682_i1 j) (childrenD_682_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_422 2 (7, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_450 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_503 6 (7, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_642 0 (3, 0)).mono (by decide +kernel) + · exact row_works_682_i2.mono (by decide +kernel) + · exact (placed21_template row_works_680 4 (2, 7)).mono (by decide +kernel) + · exact row_works_682_i7.mono (by decide +kernel) +theorem row_works_682_i1 : Template HasSnaky 14 required_682_i1 envelope_682_i1 := by + refine compose HasSnaky 13 childrenC_682_i1 childrenD_682_i1 children_work_682_i1 (6, 4) + required_682_i1 envelope_682_i1 pivot_mem_682_i1 child_required_sub_682_i1 child_envelope_sub_682_i1 ?_ + intro b hb + exact common_sub_682_i1 (mem_commonEnvelope childrenD_682_i1 b hb) +def required_682 : Finset Cell := ⟨(([(3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_682 : Finset Cell := ⟨(([(0, 2), (0, 3), (0, 4), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_682 : Fin 9 → Finset Cell := ![(placed21 4 (3, 8) required_408), (placed21 4 (3, 8) required_410), (placed21 6 (6, 8) required_475), (placed21 3 (1, 7) required_509), (placed21 7 (7, 7) required_510), (placed21 4 (2, 8) required_587), (placed21 6 (7, 8) required_646), required_682_i0, required_682_i1] +def childrenD_682 : Fin 9 → Finset Cell := ![(placed21 4 (3, 8) envelope_408), (placed21 4 (3, 8) envelope_410), (placed21 6 (6, 8) envelope_475), (placed21 3 (1, 7) envelope_509), (placed21 7 (7, 7) envelope_510), (placed21 4 (2, 8) envelope_587), (placed21 6 (7, 8) envelope_646), envelope_682_i0, envelope_682_i1] +theorem common_sub_682 : commonEnvelope childrenD_682 ⊆ insert (4, 4) required_682 := by decide +kernel +theorem child_required_sub_682 : ∀ j, childrenC_682 j ⊆ insert (4, 4) required_682 := by decide +kernel +theorem child_envelope_sub_682 : ∀ j, childrenD_682 j ⊆ envelope_682 := by decide +kernel +theorem pivot_mem_682 : (4, 4) ∈ envelope_682 := by decide +kernel +theorem children_work_682 : ∀ j, Template HasSnaky 14 (childrenC_682 j) (childrenD_682 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_408 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_410 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_475 6 (6, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_509 3 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_510 7 (7, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_587 4 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_646 6 (7, 8)).mono (by decide +kernel) + · exact row_works_682_i0.mono (by decide +kernel) + · exact row_works_682_i1.mono (by decide +kernel) +theorem row_works_682 : Template HasSnaky 15 required_682 envelope_682 := by + refine compose HasSnaky 14 childrenC_682 childrenD_682 children_work_682 (4, 4) + required_682 envelope_682 pivot_mem_682 child_required_sub_682 child_envelope_sub_682 ?_ + intro b hb + exact common_sub_682 (mem_commonEnvelope childrenD_682 b hb) +def height_670_i0 : ℕ := 12 +def childrenH_670_i0 : Fin 3 → ℕ := ![height_40, height_125, height_660] +theorem height_exact_670_i0 : height_670_i0 = 1 + Finset.univ.sup childrenH_670_i0 := by decide +kernel +theorem required_origin_670_i0 : ∀ x ∈ required_670_i0, + (∃ j, x ∈ childrenC_670_i0 j) ∨ ∀ j, x ∈ childrenD_670_i0 j := by decide +kernel +theorem required_exact_670_i0 : required_670_i0 = + ((Finset.univ.biUnion childrenC_670_i0) ∪ commonEnvelope childrenD_670_i0).erase (5, 5) := by + exact required_eq_combination childrenC_670_i0 childrenD_670_i0 (5, 5) required_670_i0 + (by decide +kernel) child_required_sub_670_i0 common_sub_670_i0 required_origin_670_i0 +theorem envelope_origin_670_i0 : ∀ x ∈ envelope_670_i0, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_670_i0 j := by decide +kernel +theorem envelope_exact_670_i0 : envelope_670_i0 = + insert (5, 5) (Finset.univ.biUnion childrenD_670_i0) := by + exact envelope_eq_combination childrenD_670_i0 (5, 5) envelope_670_i0 + pivot_mem_670_i0 child_envelope_sub_670_i0 envelope_origin_670_i0 +def checked_670_i0 : CheckedCard where + required := required_670_i0 + envelope := envelope_670_i0 + height := height_670_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i0 +def height_670_i1 : ℕ := 12 +def childrenH_670_i1 : Fin 3 → ℕ := ![height_40, height_125, height_663] +theorem height_exact_670_i1 : height_670_i1 = 1 + Finset.univ.sup childrenH_670_i1 := by decide +kernel +theorem required_origin_670_i1 : ∀ x ∈ required_670_i1, + (∃ j, x ∈ childrenC_670_i1 j) ∨ ∀ j, x ∈ childrenD_670_i1 j := by decide +kernel +theorem required_exact_670_i1 : required_670_i1 = + ((Finset.univ.biUnion childrenC_670_i1) ∪ commonEnvelope childrenD_670_i1).erase (5, 5) := by + exact required_eq_combination childrenC_670_i1 childrenD_670_i1 (5, 5) required_670_i1 + (by decide +kernel) child_required_sub_670_i1 common_sub_670_i1 required_origin_670_i1 +theorem envelope_origin_670_i1 : ∀ x ∈ envelope_670_i1, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_670_i1 j := by decide +kernel +theorem envelope_exact_670_i1 : envelope_670_i1 = + insert (5, 5) (Finset.univ.biUnion childrenD_670_i1) := by + exact envelope_eq_combination childrenD_670_i1 (5, 5) envelope_670_i1 + pivot_mem_670_i1 child_envelope_sub_670_i1 envelope_origin_670_i1 +def checked_670_i1 : CheckedCard where + required := required_670_i1 + envelope := envelope_670_i1 + height := height_670_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i1 +def height_670_i3 : ℕ := 9 +def childrenH_670_i3 : Fin 3 → ℕ := ![height_106, height_219, height_530] +theorem height_exact_670_i3 : height_670_i3 = 1 + Finset.univ.sup childrenH_670_i3 := by decide +kernel +theorem required_origin_670_i3 : ∀ x ∈ required_670_i3, + (∃ j, x ∈ childrenC_670_i3 j) ∨ ∀ j, x ∈ childrenD_670_i3 j := by decide +kernel +theorem required_exact_670_i3 : required_670_i3 = + ((Finset.univ.biUnion childrenC_670_i3) ∪ commonEnvelope childrenD_670_i3).erase (7, 6) := by + exact required_eq_combination childrenC_670_i3 childrenD_670_i3 (7, 6) required_670_i3 + (by decide +kernel) child_required_sub_670_i3 common_sub_670_i3 required_origin_670_i3 +theorem envelope_origin_670_i3 : ∀ x ∈ envelope_670_i3, + x = (7, 6) ∨ ∃ j, x ∈ childrenD_670_i3 j := by decide +kernel +theorem envelope_exact_670_i3 : envelope_670_i3 = + insert (7, 6) (Finset.univ.biUnion childrenD_670_i3) := by + exact envelope_eq_combination childrenD_670_i3 (7, 6) envelope_670_i3 + pivot_mem_670_i3 child_envelope_sub_670_i3 envelope_origin_670_i3 +def checked_670_i3 : CheckedCard where + required := required_670_i3 + envelope := envelope_670_i3 + height := height_670_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i3 +def height_670_i4 : ℕ := 10 +def childrenH_670_i4 : Fin 3 → ℕ := ![height_40, height_98, height_512] +theorem height_exact_670_i4 : height_670_i4 = 1 + Finset.univ.sup childrenH_670_i4 := by decide +kernel +theorem required_origin_670_i4 : ∀ x ∈ required_670_i4, + (∃ j, x ∈ childrenC_670_i4 j) ∨ ∀ j, x ∈ childrenD_670_i4 j := by decide +kernel +theorem required_exact_670_i4 : required_670_i4 = + ((Finset.univ.biUnion childrenC_670_i4) ∪ commonEnvelope childrenD_670_i4).erase (5, 5) := by + exact required_eq_combination childrenC_670_i4 childrenD_670_i4 (5, 5) required_670_i4 + (by decide +kernel) child_required_sub_670_i4 common_sub_670_i4 required_origin_670_i4 +theorem envelope_origin_670_i4 : ∀ x ∈ envelope_670_i4, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_670_i4 j := by decide +kernel +theorem envelope_exact_670_i4 : envelope_670_i4 = + insert (5, 5) (Finset.univ.biUnion childrenD_670_i4) := by + exact envelope_eq_combination childrenD_670_i4 (5, 5) envelope_670_i4 + pivot_mem_670_i4 child_envelope_sub_670_i4 envelope_origin_670_i4 +def checked_670_i4 : CheckedCard where + required := required_670_i4 + envelope := envelope_670_i4 + height := height_670_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i4 +def height_670_i2 : ℕ := 13 +def childrenH_670_i2 : Fin 5 → ℕ := ![height_270, height_588, height_638, height_670_i3, height_670_i4] +theorem height_exact_670_i2 : height_670_i2 = 1 + Finset.univ.sup childrenH_670_i2 := by decide +kernel +theorem required_origin_670_i2 : ∀ x ∈ required_670_i2, + (∃ j, x ∈ childrenC_670_i2 j) ∨ ∀ j, x ∈ childrenD_670_i2 j := by decide +kernel +theorem required_exact_670_i2 : required_670_i2 = + ((Finset.univ.biUnion childrenC_670_i2) ∪ commonEnvelope childrenD_670_i2).erase (5, 6) := by + exact required_eq_combination childrenC_670_i2 childrenD_670_i2 (5, 6) required_670_i2 + (by decide +kernel) child_required_sub_670_i2 common_sub_670_i2 required_origin_670_i2 +theorem envelope_origin_670_i2 : ∀ x ∈ envelope_670_i2, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_670_i2 j := by decide +kernel +theorem envelope_exact_670_i2 : envelope_670_i2 = + insert (5, 6) (Finset.univ.biUnion childrenD_670_i2) := by + exact envelope_eq_combination childrenD_670_i2 (5, 6) envelope_670_i2 + pivot_mem_670_i2 child_envelope_sub_670_i2 envelope_origin_670_i2 +def checked_670_i2 : CheckedCard where + required := required_670_i2 + envelope := envelope_670_i2 + height := height_670_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i2 +def height_670_i5 : ℕ := 12 +def childrenH_670_i5 : Fin 3 → ℕ := ![height_40, height_125, height_617] +theorem height_exact_670_i5 : height_670_i5 = 1 + Finset.univ.sup childrenH_670_i5 := by decide +kernel +theorem required_origin_670_i5 : ∀ x ∈ required_670_i5, + (∃ j, x ∈ childrenC_670_i5 j) ∨ ∀ j, x ∈ childrenD_670_i5 j := by decide +kernel +theorem required_exact_670_i5 : required_670_i5 = + ((Finset.univ.biUnion childrenC_670_i5) ∪ commonEnvelope childrenD_670_i5).erase (5, 5) := by + exact required_eq_combination childrenC_670_i5 childrenD_670_i5 (5, 5) required_670_i5 + (by decide +kernel) child_required_sub_670_i5 common_sub_670_i5 required_origin_670_i5 +theorem envelope_origin_670_i5 : ∀ x ∈ envelope_670_i5, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_670_i5 j := by decide +kernel +theorem envelope_exact_670_i5 : envelope_670_i5 = + insert (5, 5) (Finset.univ.biUnion childrenD_670_i5) := by + exact envelope_eq_combination childrenD_670_i5 (5, 5) envelope_670_i5 + pivot_mem_670_i5 child_envelope_sub_670_i5 envelope_origin_670_i5 +def checked_670_i5 : CheckedCard where + required := required_670_i5 + envelope := envelope_670_i5 + height := height_670_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i5 +def height_670_i6 : ℕ := 10 +def childrenH_670_i6 : Fin 7 → ℕ := ![height_13, height_31, height_355, height_356, height_434, height_435, height_441] +theorem height_exact_670_i6 : height_670_i6 = 1 + Finset.univ.sup childrenH_670_i6 := by decide +kernel +theorem required_origin_670_i6 : ∀ x ∈ required_670_i6, + (∃ j, x ∈ childrenC_670_i6 j) ∨ ∀ j, x ∈ childrenD_670_i6 j := by decide +kernel +theorem required_exact_670_i6 : required_670_i6 = + ((Finset.univ.biUnion childrenC_670_i6) ∪ commonEnvelope childrenD_670_i6).erase (6, 4) := by + exact required_eq_combination childrenC_670_i6 childrenD_670_i6 (6, 4) required_670_i6 + (by decide +kernel) child_required_sub_670_i6 common_sub_670_i6 required_origin_670_i6 +theorem envelope_origin_670_i6 : ∀ x ∈ envelope_670_i6, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_670_i6 j := by decide +kernel +theorem envelope_exact_670_i6 : envelope_670_i6 = + insert (6, 4) (Finset.univ.biUnion childrenD_670_i6) := by + exact envelope_eq_combination childrenD_670_i6 (6, 4) envelope_670_i6 + pivot_mem_670_i6 child_envelope_sub_670_i6 envelope_origin_670_i6 +def checked_670_i6 : CheckedCard where + required := required_670_i6 + envelope := envelope_670_i6 + height := height_670_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i6 +def height_670_i7 : ℕ := 11 +def childrenH_670_i7 : Fin 3 → ℕ := ![height_40, height_125, height_535] +theorem height_exact_670_i7 : height_670_i7 = 1 + Finset.univ.sup childrenH_670_i7 := by decide +kernel +theorem required_origin_670_i7 : ∀ x ∈ required_670_i7, + (∃ j, x ∈ childrenC_670_i7 j) ∨ ∀ j, x ∈ childrenD_670_i7 j := by decide +kernel +theorem required_exact_670_i7 : required_670_i7 = + ((Finset.univ.biUnion childrenC_670_i7) ∪ commonEnvelope childrenD_670_i7).erase (5, 5) := by + exact required_eq_combination childrenC_670_i7 childrenD_670_i7 (5, 5) required_670_i7 + (by decide +kernel) child_required_sub_670_i7 common_sub_670_i7 required_origin_670_i7 +theorem envelope_origin_670_i7 : ∀ x ∈ envelope_670_i7, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_670_i7 j := by decide +kernel +theorem envelope_exact_670_i7 : envelope_670_i7 = + insert (5, 5) (Finset.univ.biUnion childrenD_670_i7) := by + exact envelope_eq_combination childrenD_670_i7 (5, 5) envelope_670_i7 + pivot_mem_670_i7 child_envelope_sub_670_i7 envelope_origin_670_i7 +def checked_670_i7 : CheckedCard where + required := required_670_i7 + envelope := envelope_670_i7 + height := height_670_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i7 +def height_670_i8 : ℕ := 10 +def childrenH_670_i8 : Fin 6 → ℕ := ![height_188, height_188, height_441, height_442, height_514, height_667] +theorem height_exact_670_i8 : height_670_i8 = 1 + Finset.univ.sup childrenH_670_i8 := by decide +kernel +theorem required_origin_670_i8 : ∀ x ∈ required_670_i8, + (∃ j, x ∈ childrenC_670_i8 j) ∨ ∀ j, x ∈ childrenD_670_i8 j := by decide +kernel +theorem required_exact_670_i8 : required_670_i8 = + ((Finset.univ.biUnion childrenC_670_i8) ∪ commonEnvelope childrenD_670_i8).erase (6, 4) := by + exact required_eq_combination childrenC_670_i8 childrenD_670_i8 (6, 4) required_670_i8 + (by decide +kernel) child_required_sub_670_i8 common_sub_670_i8 required_origin_670_i8 +theorem envelope_origin_670_i8 : ∀ x ∈ envelope_670_i8, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_670_i8 j := by decide +kernel +theorem envelope_exact_670_i8 : envelope_670_i8 = + insert (6, 4) (Finset.univ.biUnion childrenD_670_i8) := by + exact envelope_eq_combination childrenD_670_i8 (6, 4) envelope_670_i8 + pivot_mem_670_i8 child_envelope_sub_670_i8 envelope_origin_670_i8 +def checked_670_i8 : CheckedCard where + required := required_670_i8 + envelope := envelope_670_i8 + height := height_670_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i8 +def height_670_i10 : ℕ := 7 +def childrenH_670_i10 : Fin 2 → ℕ := ![height_125, height_136] +theorem height_exact_670_i10 : height_670_i10 = 1 + Finset.univ.sup childrenH_670_i10 := by decide +kernel +theorem required_origin_670_i10 : ∀ x ∈ required_670_i10, + (∃ j, x ∈ childrenC_670_i10 j) ∨ ∀ j, x ∈ childrenD_670_i10 j := by decide +kernel +theorem required_exact_670_i10 : required_670_i10 = + ((Finset.univ.biUnion childrenC_670_i10) ∪ commonEnvelope childrenD_670_i10).erase (5, 5) := by + exact required_eq_combination childrenC_670_i10 childrenD_670_i10 (5, 5) required_670_i10 + (by decide +kernel) child_required_sub_670_i10 common_sub_670_i10 required_origin_670_i10 +theorem envelope_origin_670_i10 : ∀ x ∈ envelope_670_i10, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_670_i10 j := by decide +kernel +theorem envelope_exact_670_i10 : envelope_670_i10 = + insert (5, 5) (Finset.univ.biUnion childrenD_670_i10) := by + exact envelope_eq_combination childrenD_670_i10 (5, 5) envelope_670_i10 + pivot_mem_670_i10 child_envelope_sub_670_i10 envelope_origin_670_i10 +def checked_670_i10 : CheckedCard where + required := required_670_i10 + envelope := envelope_670_i10 + height := height_670_i10 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i10 +def height_670_i9 : ℕ := 14 +def childrenH_670_i9 : Fin 5 → ℕ := ![height_13, height_514, height_590, height_668, height_670_i10] +theorem height_exact_670_i9 : height_670_i9 = 1 + Finset.univ.sup childrenH_670_i9 := by decide +kernel +theorem required_origin_670_i9 : ∀ x ∈ required_670_i9, + (∃ j, x ∈ childrenC_670_i9 j) ∨ ∀ j, x ∈ childrenD_670_i9 j := by decide +kernel +theorem required_exact_670_i9 : required_670_i9 = + ((Finset.univ.biUnion childrenC_670_i9) ∪ commonEnvelope childrenD_670_i9).erase (6, 4) := by + exact required_eq_combination childrenC_670_i9 childrenD_670_i9 (6, 4) required_670_i9 + (by decide +kernel) child_required_sub_670_i9 common_sub_670_i9 required_origin_670_i9 +theorem envelope_origin_670_i9 : ∀ x ∈ envelope_670_i9, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_670_i9 j := by decide +kernel +theorem envelope_exact_670_i9 : envelope_670_i9 = + insert (6, 4) (Finset.univ.biUnion childrenD_670_i9) := by + exact envelope_eq_combination childrenD_670_i9 (6, 4) envelope_670_i9 + pivot_mem_670_i9 child_envelope_sub_670_i9 envelope_origin_670_i9 +def checked_670_i9 : CheckedCard where + required := required_670_i9 + envelope := envelope_670_i9 + height := height_670_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670_i9 +def height_670 : ℕ := 15 +def childrenH_670 : Fin 12 → ℕ := ![height_459, height_670_i0, height_661, height_670_i1, height_670_i2, height_670_i5, height_670_i6, height_670_i7, height_665, height_670_i8, height_670_i9, height_669] +theorem height_exact_670 : height_670 = 1 + Finset.univ.sup childrenH_670 := by decide +kernel +theorem required_origin_670 : ∀ x ∈ required_670, + (∃ j, x ∈ childrenC_670 j) ∨ ∀ j, x ∈ childrenD_670 j := by decide +kernel +theorem required_exact_670 : required_670 = + ((Finset.univ.biUnion childrenC_670) ∪ commonEnvelope childrenD_670).erase (6, 6) := by + exact required_eq_combination childrenC_670 childrenD_670 (6, 6) required_670 + (by decide +kernel) child_required_sub_670 common_sub_670 required_origin_670 +theorem envelope_origin_670 : ∀ x ∈ envelope_670, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_670 j := by decide +kernel +theorem envelope_exact_670 : envelope_670 = + insert (6, 6) (Finset.univ.biUnion childrenD_670) := by + exact envelope_eq_combination childrenD_670 (6, 6) envelope_670 + pivot_mem_670 child_envelope_sub_670 envelope_origin_670 +def checked_670 : CheckedCard where + required := required_670 + envelope := envelope_670 + height := height_670 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_670 +def height_682_i0 : ℕ := 12 +def childrenH_682_i0 : Fin 4 → ℕ := ![height_44, height_52, height_128, height_676] +theorem height_exact_682_i0 : height_682_i0 = 1 + Finset.univ.sup childrenH_682_i0 := by decide +kernel +theorem required_origin_682_i0 : ∀ x ∈ required_682_i0, + (∃ j, x ∈ childrenC_682_i0 j) ∨ ∀ j, x ∈ childrenD_682_i0 j := by decide +kernel +theorem required_exact_682_i0 : required_682_i0 = + ((Finset.univ.biUnion childrenC_682_i0) ∪ commonEnvelope childrenD_682_i0).erase (4, 3) := by + exact required_eq_combination childrenC_682_i0 childrenD_682_i0 (4, 3) required_682_i0 + (by decide +kernel) child_required_sub_682_i0 common_sub_682_i0 required_origin_682_i0 +theorem envelope_origin_682_i0 : ∀ x ∈ envelope_682_i0, + x = (4, 3) ∨ ∃ j, x ∈ childrenD_682_i0 j := by decide +kernel +theorem envelope_exact_682_i0 : envelope_682_i0 = + insert (4, 3) (Finset.univ.biUnion childrenD_682_i0) := by + exact envelope_eq_combination childrenD_682_i0 (4, 3) envelope_682_i0 + pivot_mem_682_i0 child_envelope_sub_682_i0 envelope_origin_682_i0 +def checked_682_i0 : CheckedCard where + required := required_682_i0 + envelope := envelope_682_i0 + height := height_682_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_682_i0 +def height_682_i5 : ℕ := 6 +def childrenH_682_i5 : Fin 3 → ℕ := ![height_7, height_9, height_386] +theorem height_exact_682_i5 : height_682_i5 = 1 + Finset.univ.sup childrenH_682_i5 := by decide +kernel +theorem required_origin_682_i5 : ∀ x ∈ required_682_i5, + (∃ j, x ∈ childrenC_682_i5 j) ∨ ∀ j, x ∈ childrenD_682_i5 j := by decide +kernel +theorem required_exact_682_i5 : required_682_i5 = + ((Finset.univ.biUnion childrenC_682_i5) ∪ commonEnvelope childrenD_682_i5).erase (6, 7) := by + exact required_eq_combination childrenC_682_i5 childrenD_682_i5 (6, 7) required_682_i5 + (by decide +kernel) child_required_sub_682_i5 common_sub_682_i5 required_origin_682_i5 +theorem envelope_origin_682_i5 : ∀ x ∈ envelope_682_i5, + x = (6, 7) ∨ ∃ j, x ∈ childrenD_682_i5 j := by decide +kernel +theorem envelope_exact_682_i5 : envelope_682_i5 = + insert (6, 7) (Finset.univ.biUnion childrenD_682_i5) := by + exact envelope_eq_combination childrenD_682_i5 (6, 7) envelope_682_i5 + pivot_mem_682_i5 child_envelope_sub_682_i5 envelope_origin_682_i5 +def checked_682_i5 : CheckedCard where + required := required_682_i5 + envelope := envelope_682_i5 + height := height_682_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_682_i5 +def height_682_i6 : ℕ := 4 +def childrenH_682_i6 : Fin 2 → ℕ := ![height_0, height_222] +theorem height_exact_682_i6 : height_682_i6 = 1 + Finset.univ.sup childrenH_682_i6 := by decide +kernel +theorem required_origin_682_i6 : ∀ x ∈ required_682_i6, + (∃ j, x ∈ childrenC_682_i6 j) ∨ ∀ j, x ∈ childrenD_682_i6 j := by decide +kernel +theorem required_exact_682_i6 : required_682_i6 = + ((Finset.univ.biUnion childrenC_682_i6) ∪ commonEnvelope childrenD_682_i6).erase (5, 6) := by + exact required_eq_combination childrenC_682_i6 childrenD_682_i6 (5, 6) required_682_i6 + (by decide +kernel) child_required_sub_682_i6 common_sub_682_i6 required_origin_682_i6 +theorem envelope_origin_682_i6 : ∀ x ∈ envelope_682_i6, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_682_i6 j := by decide +kernel +theorem envelope_exact_682_i6 : envelope_682_i6 = + insert (5, 6) (Finset.univ.biUnion childrenD_682_i6) := by + exact envelope_eq_combination childrenD_682_i6 (5, 6) envelope_682_i6 + pivot_mem_682_i6 child_envelope_sub_682_i6 envelope_origin_682_i6 +def checked_682_i6 : CheckedCard where + required := required_682_i6 + envelope := envelope_682_i6 + height := height_682_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_682_i6 +def height_682_i4 : ℕ := 7 +def childrenH_682_i4 : Fin 4 → ℕ := ![height_377, height_682_i5, height_426, height_682_i6] +theorem height_exact_682_i4 : height_682_i4 = 1 + Finset.univ.sup childrenH_682_i4 := by decide +kernel +theorem required_origin_682_i4 : ∀ x ∈ required_682_i4, + (∃ j, x ∈ childrenC_682_i4 j) ∨ ∀ j, x ∈ childrenD_682_i4 j := by decide +kernel +theorem required_exact_682_i4 : required_682_i4 = + ((Finset.univ.biUnion childrenC_682_i4) ∪ commonEnvelope childrenD_682_i4).erase (4, 6) := by + exact required_eq_combination childrenC_682_i4 childrenD_682_i4 (4, 6) required_682_i4 + (by decide +kernel) child_required_sub_682_i4 common_sub_682_i4 required_origin_682_i4 +theorem envelope_origin_682_i4 : ∀ x ∈ envelope_682_i4, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_682_i4 j := by decide +kernel +theorem envelope_exact_682_i4 : envelope_682_i4 = + insert (4, 6) (Finset.univ.biUnion childrenD_682_i4) := by + exact envelope_eq_combination childrenD_682_i4 (4, 6) envelope_682_i4 + pivot_mem_682_i4 child_envelope_sub_682_i4 envelope_origin_682_i4 +def checked_682_i4 : CheckedCard where + required := required_682_i4 + envelope := envelope_682_i4 + height := height_682_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_682_i4 +def height_682_i3 : ℕ := 8 +def childrenH_682_i3 : Fin 5 → ℕ := ![height_13, height_14, height_79, height_679, height_682_i4] +theorem height_exact_682_i3 : height_682_i3 = 1 + Finset.univ.sup childrenH_682_i3 := by decide +kernel +theorem required_origin_682_i3 : ∀ x ∈ required_682_i3, + (∃ j, x ∈ childrenC_682_i3 j) ∨ ∀ j, x ∈ childrenD_682_i3 j := by decide +kernel +theorem required_exact_682_i3 : required_682_i3 = + ((Finset.univ.biUnion childrenC_682_i3) ∪ commonEnvelope childrenD_682_i3).erase (6, 6) := by + exact required_eq_combination childrenC_682_i3 childrenD_682_i3 (6, 6) required_682_i3 + (by decide +kernel) child_required_sub_682_i3 common_sub_682_i3 required_origin_682_i3 +theorem envelope_origin_682_i3 : ∀ x ∈ envelope_682_i3, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_682_i3 j := by decide +kernel +theorem envelope_exact_682_i3 : envelope_682_i3 = + insert (6, 6) (Finset.univ.biUnion childrenD_682_i3) := by + exact envelope_eq_combination childrenD_682_i3 (6, 6) envelope_682_i3 + pivot_mem_682_i3 child_envelope_sub_682_i3 envelope_origin_682_i3 +def checked_682_i3 : CheckedCard where + required := required_682_i3 + envelope := envelope_682_i3 + height := height_682_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_682_i3 +def height_682_i2 : ℕ := 9 +def childrenH_682_i2 : Fin 4 → ℕ := ![height_59, height_105, height_678, height_682_i3] +theorem height_exact_682_i2 : height_682_i2 = 1 + Finset.univ.sup childrenH_682_i2 := by decide +kernel +theorem required_origin_682_i2 : ∀ x ∈ required_682_i2, + (∃ j, x ∈ childrenC_682_i2 j) ∨ ∀ j, x ∈ childrenD_682_i2 j := by decide +kernel +theorem required_exact_682_i2 : required_682_i2 = + ((Finset.univ.biUnion childrenC_682_i2) ∪ commonEnvelope childrenD_682_i2).erase (6, 5) := by + exact required_eq_combination childrenC_682_i2 childrenD_682_i2 (6, 5) required_682_i2 + (by decide +kernel) child_required_sub_682_i2 common_sub_682_i2 required_origin_682_i2 +theorem envelope_origin_682_i2 : ∀ x ∈ envelope_682_i2, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_682_i2 j := by decide +kernel +theorem envelope_exact_682_i2 : envelope_682_i2 = + insert (6, 5) (Finset.univ.biUnion childrenD_682_i2) := by + exact envelope_eq_combination childrenD_682_i2 (6, 5) envelope_682_i2 + pivot_mem_682_i2 child_envelope_sub_682_i2 envelope_origin_682_i2 +def checked_682_i2 : CheckedCard where + required := required_682_i2 + envelope := envelope_682_i2 + height := height_682_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_682_i2 +def height_682_i8 : ℕ := 6 +def childrenH_682_i8 : Fin 4 → ℕ := ![height_13, height_79, height_243, height_679] +theorem height_exact_682_i8 : height_682_i8 = 1 + Finset.univ.sup childrenH_682_i8 := by decide +kernel +theorem required_origin_682_i8 : ∀ x ∈ required_682_i8, + (∃ j, x ∈ childrenC_682_i8 j) ∨ ∀ j, x ∈ childrenD_682_i8 j := by decide +kernel +theorem required_exact_682_i8 : required_682_i8 = + ((Finset.univ.biUnion childrenC_682_i8) ∪ commonEnvelope childrenD_682_i8).erase (6, 6) := by + exact required_eq_combination childrenC_682_i8 childrenD_682_i8 (6, 6) required_682_i8 + (by decide +kernel) child_required_sub_682_i8 common_sub_682_i8 required_origin_682_i8 +theorem envelope_origin_682_i8 : ∀ x ∈ envelope_682_i8, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_682_i8 j := by decide +kernel +theorem envelope_exact_682_i8 : envelope_682_i8 = + insert (6, 6) (Finset.univ.biUnion childrenD_682_i8) := by + exact envelope_eq_combination childrenD_682_i8 (6, 6) envelope_682_i8 + pivot_mem_682_i8 child_envelope_sub_682_i8 envelope_origin_682_i8 +def checked_682_i8 : CheckedCard where + required := required_682_i8 + envelope := envelope_682_i8 + height := height_682_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_682_i8 +def height_682_i7 : ℕ := 9 +def childrenH_682_i7 : Fin 6 → ℕ := ![height_430, height_431, height_592, height_678, height_682_i8, height_681] +theorem height_exact_682_i7 : height_682_i7 = 1 + Finset.univ.sup childrenH_682_i7 := by decide +kernel +theorem required_origin_682_i7 : ∀ x ∈ required_682_i7, + (∃ j, x ∈ childrenC_682_i7 j) ∨ ∀ j, x ∈ childrenD_682_i7 j := by decide +kernel +theorem required_exact_682_i7 : required_682_i7 = + ((Finset.univ.biUnion childrenC_682_i7) ∪ commonEnvelope childrenD_682_i7).erase (6, 5) := by + exact required_eq_combination childrenC_682_i7 childrenD_682_i7 (6, 5) required_682_i7 + (by decide +kernel) child_required_sub_682_i7 common_sub_682_i7 required_origin_682_i7 +theorem envelope_origin_682_i7 : ∀ x ∈ envelope_682_i7, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_682_i7 j := by decide +kernel +theorem envelope_exact_682_i7 : envelope_682_i7 = + insert (6, 5) (Finset.univ.biUnion childrenD_682_i7) := by + exact envelope_eq_combination childrenD_682_i7 (6, 5) envelope_682_i7 + pivot_mem_682_i7 child_envelope_sub_682_i7 envelope_origin_682_i7 +def checked_682_i7 : CheckedCard where + required := required_682_i7 + envelope := envelope_682_i7 + height := height_682_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_682_i7 +def height_682_i1 : ℕ := 14 +def childrenH_682_i1 : Fin 7 → ℕ := ![height_422, height_450, height_503, height_642, height_682_i2, height_680, height_682_i7] +theorem height_exact_682_i1 : height_682_i1 = 1 + Finset.univ.sup childrenH_682_i1 := by decide +kernel +theorem required_origin_682_i1 : ∀ x ∈ required_682_i1, + (∃ j, x ∈ childrenC_682_i1 j) ∨ ∀ j, x ∈ childrenD_682_i1 j := by decide +kernel +theorem required_exact_682_i1 : required_682_i1 = + ((Finset.univ.biUnion childrenC_682_i1) ∪ commonEnvelope childrenD_682_i1).erase (6, 4) := by + exact required_eq_combination childrenC_682_i1 childrenD_682_i1 (6, 4) required_682_i1 + (by decide +kernel) child_required_sub_682_i1 common_sub_682_i1 required_origin_682_i1 +theorem envelope_origin_682_i1 : ∀ x ∈ envelope_682_i1, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_682_i1 j := by decide +kernel +theorem envelope_exact_682_i1 : envelope_682_i1 = + insert (6, 4) (Finset.univ.biUnion childrenD_682_i1) := by + exact envelope_eq_combination childrenD_682_i1 (6, 4) envelope_682_i1 + pivot_mem_682_i1 child_envelope_sub_682_i1 envelope_origin_682_i1 +def checked_682_i1 : CheckedCard where + required := required_682_i1 + envelope := envelope_682_i1 + height := height_682_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_682_i1 +def height_682 : ℕ := 15 +def childrenH_682 : Fin 9 → ℕ := ![height_408, height_410, height_475, height_509, height_510, height_587, height_646, height_682_i0, height_682_i1] +theorem height_exact_682 : height_682 = 1 + Finset.univ.sup childrenH_682 := by decide +kernel +theorem required_origin_682 : ∀ x ∈ required_682, + (∃ j, x ∈ childrenC_682 j) ∨ ∀ j, x ∈ childrenD_682 j := by decide +kernel +theorem required_exact_682 : required_682 = + ((Finset.univ.biUnion childrenC_682) ∪ commonEnvelope childrenD_682).erase (4, 4) := by + exact required_eq_combination childrenC_682 childrenD_682 (4, 4) required_682 + (by decide +kernel) child_required_sub_682 common_sub_682 required_origin_682 +theorem envelope_origin_682 : ∀ x ∈ envelope_682, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_682 j := by decide +kernel +theorem envelope_exact_682 : envelope_682 = + insert (4, 4) (Finset.univ.biUnion childrenD_682) := by + exact envelope_eq_combination childrenD_682 (4, 4) envelope_682 + pivot_mem_682 child_envelope_sub_682 envelope_origin_682 +def checked_682 : CheckedCard where + required := required_682 + envelope := envelope_682 + height := height_682 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_682 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part03.lean new file mode 100644 index 0000000..9eb3903 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part03.lean @@ -0,0 +1,973 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_698 : Finset Cell := ⟨(([(4, 4), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_698 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 7), (0, 8), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (11, 6), (11, 7), (11, 8), (11, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_698 : Fin 8 → Finset Cell := ![(placed21 0 (3, 2) required_12), (placed21 6 (6, 8) required_182), (placed21 0 (2, 2) required_188), (placed21 5 (7, 3) required_619), (placed21 0 (1, 0) required_620), (placed21 0 (1, 1) required_622), (placed21 1 (0, 1) required_687), (placed21 1 (1, 2) required_697)] +def childrenD_698 : Fin 8 → Finset Cell := ![(placed21 0 (3, 2) envelope_12), (placed21 6 (6, 8) envelope_182), (placed21 0 (2, 2) envelope_188), (placed21 5 (7, 3) envelope_619), (placed21 0 (1, 0) envelope_620), (placed21 0 (1, 1) envelope_622), (placed21 1 (0, 1) envelope_687), (placed21 1 (1, 2) envelope_697)] +theorem common_sub_698 : commonEnvelope childrenD_698 ⊆ insert (4, 6) required_698 := by decide +kernel +theorem child_required_sub_698 : ∀ j, childrenC_698 j ⊆ insert (4, 6) required_698 := by decide +kernel +theorem child_envelope_sub_698 : ∀ j, childrenD_698 j ⊆ envelope_698 := by decide +kernel +theorem pivot_mem_698 : (4, 6) ∈ envelope_698 := by decide +kernel +theorem children_work_698 : ∀ j, Template HasSnaky 14 (childrenC_698 j) (childrenD_698 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_182 6 (6, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_188 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_619 5 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_620 0 (1, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_622 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_687 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_697 1 (1, 2)).mono (by decide +kernel) +theorem row_works_698 : Template HasSnaky 15 required_698 envelope_698 := by + refine compose HasSnaky 14 childrenC_698 childrenD_698 children_work_698 (4, 6) + required_698 envelope_698 pivot_mem_698 child_required_sub_698 child_envelope_sub_698 ?_ + intro b hb + exact common_sub_698 (mem_commonEnvelope childrenD_698 b hb) +def required_699_i3 : Finset Cell := ⟨(([(5, 5), (6, 5), (7, 5), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_699_i3 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 4), (6, 5), (6, 6), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 5), (8, 6), (8, 8), (8, 9), (8, 10), (9, 6), (10, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_699_i3 : Fin 2 → Finset Cell := ![(placed21 0 (6, 4) required_42), (placed21 1 (4, 5) required_52)] +def childrenD_699_i3 : Fin 2 → Finset Cell := ![(placed21 0 (6, 4) envelope_42), (placed21 1 (4, 5) envelope_52)] +theorem common_sub_699_i3 : commonEnvelope childrenD_699_i3 ⊆ insert (7, 6) required_699_i3 := by decide +kernel +theorem child_required_sub_699_i3 : ∀ j, childrenC_699_i3 j ⊆ insert (7, 6) required_699_i3 := by decide +kernel +theorem child_envelope_sub_699_i3 : ∀ j, childrenD_699_i3 j ⊆ envelope_699_i3 := by decide +kernel +theorem pivot_mem_699_i3 : (7, 6) ∈ envelope_699_i3 := by decide +kernel +theorem children_work_699_i3 : ∀ j, Template HasSnaky 4 (childrenC_699_i3 j) (childrenD_699_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_42 0 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_52 1 (4, 5)).mono (by decide +kernel) +theorem row_works_699_i3 : Template HasSnaky 5 required_699_i3 envelope_699_i3 := by + refine compose HasSnaky 4 childrenC_699_i3 childrenD_699_i3 children_work_699_i3 (7, 6) + required_699_i3 envelope_699_i3 pivot_mem_699_i3 child_required_sub_699_i3 child_envelope_sub_699_i3 ?_ + intro b hb + exact common_sub_699_i3 (mem_commonEnvelope childrenD_699_i3 b hb) +def required_699_i2 : Finset Cell := ⟨(([(4, 8), (5, 5), (6, 5), (6, 8), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_699_i2 : Finset Cell := ⟨(([(1, 7), (1, 9), (2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9), (4, 5), (4, 8), (4, 9), (5, 5), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 8), (6, 9), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 6), (9, 7), (9, 8), (9, 9), (10, 6), (10, 7), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_699_i2 : Fin 3 → Finset Cell := ![(placed21 7 (10, 9) required_95), (placed21 1 (4, 4) required_112), required_699_i3] +def childrenD_699_i2 : Fin 3 → Finset Cell := ![(placed21 7 (10, 9) envelope_95), (placed21 1 (4, 4) envelope_112), envelope_699_i3] +theorem common_sub_699_i2 : commonEnvelope childrenD_699_i2 ⊆ insert (7, 8) required_699_i2 := by decide +kernel +theorem child_required_sub_699_i2 : ∀ j, childrenC_699_i2 j ⊆ insert (7, 8) required_699_i2 := by decide +kernel +theorem child_envelope_sub_699_i2 : ∀ j, childrenD_699_i2 j ⊆ envelope_699_i2 := by decide +kernel +theorem pivot_mem_699_i2 : (7, 8) ∈ envelope_699_i2 := by decide +kernel +theorem children_work_699_i2 : ∀ j, Template HasSnaky 6 (childrenC_699_i2 j) (childrenD_699_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_95 7 (10, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_112 1 (4, 4)).mono (by decide +kernel) + · exact row_works_699_i3.mono (by decide +kernel) +theorem row_works_699_i2 : Template HasSnaky 7 required_699_i2 envelope_699_i2 := by + refine compose HasSnaky 6 childrenC_699_i2 childrenD_699_i2 children_work_699_i2 (7, 8) + required_699_i2 envelope_699_i2 pivot_mem_699_i2 child_required_sub_699_i2 child_envelope_sub_699_i2 ?_ + intro b hb + exact common_sub_699_i2 (mem_commonEnvelope childrenD_699_i2 b hb) +def required_699_i1 : Finset Cell := ⟨(([(4, 5), (4, 8), (5, 5), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_699_i1 : Finset Cell := ⟨(([(1, 7), (1, 9), (2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9), (4, 5), (4, 8), (4, 9), (4, 10), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 4), (10, 5), (10, 6), (10, 7), (10, 9), (11, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_699_i1 : Fin 3 → Finset Cell := ![(placed21 0 (4, 4) required_371), (placed21 5 (9, 7) required_460), required_699_i2] +def childrenD_699_i1 : Fin 3 → Finset Cell := ![(placed21 0 (4, 4) envelope_371), (placed21 5 (9, 7) envelope_460), envelope_699_i2] +theorem common_sub_699_i1 : commonEnvelope childrenD_699_i1 ⊆ insert (6, 8) required_699_i1 := by decide +kernel +theorem child_required_sub_699_i1 : ∀ j, childrenC_699_i1 j ⊆ insert (6, 8) required_699_i1 := by decide +kernel +theorem child_envelope_sub_699_i1 : ∀ j, childrenD_699_i1 j ⊆ envelope_699_i1 := by decide +kernel +theorem pivot_mem_699_i1 : (6, 8) ∈ envelope_699_i1 := by decide +kernel +theorem children_work_699_i1 : ∀ j, Template HasSnaky 10 (childrenC_699_i1 j) (childrenD_699_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_371 0 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_460 5 (9, 7)).mono (by decide +kernel) + · exact row_works_699_i2.mono (by decide +kernel) +theorem row_works_699_i1 : Template HasSnaky 11 required_699_i1 envelope_699_i1 := by + refine compose HasSnaky 10 childrenC_699_i1 childrenD_699_i1 children_work_699_i1 (6, 8) + required_699_i1 envelope_699_i1 pivot_mem_699_i1 child_required_sub_699_i1 child_envelope_sub_699_i1 ?_ + intro b hb + exact common_sub_699_i1 (mem_commonEnvelope childrenD_699_i1 b hb) +def required_699_i0 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_699_i0 : Finset Cell := ⟨(([(0, 7), (0, 9), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (10, 4), (10, 5), (10, 6), (10, 7), (10, 9), (11, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_699_i0 : Fin 4 → Finset Cell := ![(placed21 2 (7, 4) required_147), (placed21 3 (3, 8) required_249), (placed21 5 (9, 5) required_692), required_699_i1] +def childrenD_699_i0 : Fin 4 → Finset Cell := ![(placed21 2 (7, 4) envelope_147), (placed21 3 (3, 8) envelope_249), (placed21 5 (9, 5) envelope_692), envelope_699_i1] +theorem common_sub_699_i0 : commonEnvelope childrenD_699_i0 ⊆ insert (4, 8) required_699_i0 := by decide +kernel +theorem child_required_sub_699_i0 : ∀ j, childrenC_699_i0 j ⊆ insert (4, 8) required_699_i0 := by decide +kernel +theorem child_envelope_sub_699_i0 : ∀ j, childrenD_699_i0 j ⊆ envelope_699_i0 := by decide +kernel +theorem pivot_mem_699_i0 : (4, 8) ∈ envelope_699_i0 := by decide +kernel +theorem children_work_699_i0 : ∀ j, Template HasSnaky 13 (childrenC_699_i0 j) (childrenD_699_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_147 2 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_249 3 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_692 5 (9, 5)).mono (by decide +kernel) + · exact row_works_699_i1.mono (by decide +kernel) +theorem row_works_699_i0 : Template HasSnaky 14 required_699_i0 envelope_699_i0 := by + refine compose HasSnaky 13 childrenC_699_i0 childrenD_699_i0 children_work_699_i0 (4, 8) + required_699_i0 envelope_699_i0 pivot_mem_699_i0 child_required_sub_699_i0 child_envelope_sub_699_i0 ?_ + intro b hb + exact common_sub_699_i0 (mem_commonEnvelope childrenD_699_i0 b hb) +def required_699_i6 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 3), (6, 4), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_699_i6 : Finset Cell := ⟨(([(4, 5), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (6, 6), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 2), (8, 3), (8, 4), (9, 3), (10, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_699_i6 : Fin 2 → Finset Cell := ![(placed21 4 (4, 5) required_5), (placed21 4 (5, 7) required_259)] +def childrenD_699_i6 : Fin 2 → Finset Cell := ![(placed21 4 (4, 5) envelope_5), (placed21 4 (5, 7) envelope_259)] +theorem common_sub_699_i6 : commonEnvelope childrenD_699_i6 ⊆ insert (7, 4) required_699_i6 := by decide +kernel +theorem child_required_sub_699_i6 : ∀ j, childrenC_699_i6 j ⊆ insert (7, 4) required_699_i6 := by decide +kernel +theorem child_envelope_sub_699_i6 : ∀ j, childrenD_699_i6 j ⊆ envelope_699_i6 := by decide +kernel +theorem pivot_mem_699_i6 : (7, 4) ∈ envelope_699_i6 := by decide +kernel +theorem children_work_699_i6 : ∀ j, Template HasSnaky 4 (childrenC_699_i6 j) (childrenD_699_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_259 4 (5, 7)).mono (by decide +kernel) +theorem row_works_699_i6 : Template HasSnaky 5 required_699_i6 envelope_699_i6 := by + refine compose HasSnaky 4 childrenC_699_i6 childrenD_699_i6 children_work_699_i6 (7, 4) + required_699_i6 envelope_699_i6 pivot_mem_699_i6 child_required_sub_699_i6 child_envelope_sub_699_i6 ?_ + intro b hb + exact common_sub_699_i6 (mem_commonEnvelope childrenD_699_i6 b hb) +def required_699_i5 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 4), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_699_i5 : Finset Cell := ⟨(([(4, 2), (4, 5), (5, 0), (5, 1), (5, 2), (5, 4), (5, 5), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 2), (8, 3), (8, 4), (9, 3), (10, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_699_i5 : Fin 4 → Finset Cell := ![(placed21 6 (7, 6) required_10), (placed21 6 (7, 6) required_48), (placed21 3 (4, 6) required_134), required_699_i6] +def childrenD_699_i5 : Fin 4 → Finset Cell := ![(placed21 6 (7, 6) envelope_10), (placed21 6 (7, 6) envelope_48), (placed21 3 (4, 6) envelope_134), envelope_699_i6] +theorem common_sub_699_i5 : commonEnvelope childrenD_699_i5 ⊆ insert (6, 3) required_699_i5 := by decide +kernel +theorem child_required_sub_699_i5 : ∀ j, childrenC_699_i5 j ⊆ insert (6, 3) required_699_i5 := by decide +kernel +theorem child_envelope_sub_699_i5 : ∀ j, childrenD_699_i5 j ⊆ envelope_699_i5 := by decide +kernel +theorem pivot_mem_699_i5 : (6, 3) ∈ envelope_699_i5 := by decide +kernel +theorem children_work_699_i5 : ∀ j, Template HasSnaky 6 (childrenC_699_i5 j) (childrenD_699_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 6 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_48 6 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_134 3 (4, 6)).mono (by decide +kernel) + · exact row_works_699_i6.mono (by decide +kernel) +theorem row_works_699_i5 : Template HasSnaky 7 required_699_i5 envelope_699_i5 := by + refine compose HasSnaky 6 childrenC_699_i5 childrenD_699_i5 children_work_699_i5 (6, 3) + required_699_i5 envelope_699_i5 pivot_mem_699_i5 child_required_sub_699_i5 child_envelope_sub_699_i5 ?_ + intro b hb + exact common_sub_699_i5 (mem_commonEnvelope childrenD_699_i5 b hb) +def required_699_i4 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_699_i4 : Finset Cell := ⟨(([(4, 2), (4, 5), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 2), (8, 3), (8, 4), (8, 5), (9, 2), (9, 3), (9, 4), (9, 5), (10, 2), (10, 3), (10, 4), (10, 5), (11, 2), (11, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_699_i4 : Fin 5 → Finset Cell := ![(placed21 3 (4, 5) required_389), (placed21 0 (5, 0) required_545), (placed21 4 (5, 9) required_546), (placed21 0 (5, 0) required_549), required_699_i5] +def childrenD_699_i4 : Fin 5 → Finset Cell := ![(placed21 3 (4, 5) envelope_389), (placed21 0 (5, 0) envelope_545), (placed21 4 (5, 9) envelope_546), (placed21 0 (5, 0) envelope_549), envelope_699_i5] +theorem common_sub_699_i4 : commonEnvelope childrenD_699_i4 ⊆ insert (6, 4) required_699_i4 := by decide +kernel +theorem child_required_sub_699_i4 : ∀ j, childrenC_699_i4 j ⊆ insert (6, 4) required_699_i4 := by decide +kernel +theorem child_envelope_sub_699_i4 : ∀ j, childrenD_699_i4 j ⊆ envelope_699_i4 := by decide +kernel +theorem pivot_mem_699_i4 : (6, 4) ∈ envelope_699_i4 := by decide +kernel +theorem children_work_699_i4 : ∀ j, Template HasSnaky 10 (childrenC_699_i4 j) (childrenD_699_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_389 3 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_545 0 (5, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_546 4 (5, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_549 0 (5, 0)).mono (by decide +kernel) + · exact row_works_699_i5.mono (by decide +kernel) +theorem row_works_699_i4 : Template HasSnaky 11 required_699_i4 envelope_699_i4 := by + refine compose HasSnaky 10 childrenC_699_i4 childrenD_699_i4 children_work_699_i4 (6, 4) + required_699_i4 envelope_699_i4 pivot_mem_699_i4 child_required_sub_699_i4 child_envelope_sub_699_i4 ?_ + intro b hb + exact common_sub_699_i4 (mem_commonEnvelope childrenD_699_i4 b hb) +def required_699 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_699 : Finset Cell := ⟨(([(0, 7), (0, 9), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 2), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 9), (11, 2), (11, 4), (11, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_699 : Fin 5 → Finset Cell := ![(placed21 0 (4, 4) required_197), (placed21 0 (4, 1) required_321), (placed21 2 (11, 0) required_693), required_699_i0, required_699_i4] +def childrenD_699 : Fin 5 → Finset Cell := ![(placed21 0 (4, 4) envelope_197), (placed21 0 (4, 1) envelope_321), (placed21 2 (11, 0) envelope_693), envelope_699_i0, envelope_699_i4] +theorem common_sub_699 : commonEnvelope childrenD_699 ⊆ insert (7, 5) required_699 := by decide +kernel +theorem child_required_sub_699 : ∀ j, childrenC_699 j ⊆ insert (7, 5) required_699 := by decide +kernel +theorem child_envelope_sub_699 : ∀ j, childrenD_699 j ⊆ envelope_699 := by decide +kernel +theorem pivot_mem_699 : (7, 5) ∈ envelope_699 := by decide +kernel +theorem children_work_699 : ∀ j, Template HasSnaky 14 (childrenC_699 j) (childrenD_699 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_197 0 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_321 0 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_693 2 (11, 0)).mono (by decide +kernel) + · exact row_works_699_i0.mono (by decide +kernel) + · exact row_works_699_i4.mono (by decide +kernel) +theorem row_works_699 : Template HasSnaky 15 required_699 envelope_699 := by + refine compose HasSnaky 14 childrenC_699 childrenD_699 children_work_699 (7, 5) + required_699 envelope_699 pivot_mem_699 child_required_sub_699 child_envelope_sub_699 ?_ + intro b hb + exact common_sub_699 (mem_commonEnvelope childrenD_699 b hb) +def required_712_i1 : Finset Cell := ⟨(([(5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_712_i1 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (4, 4), (4, 5), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3), (9, 4), (9, 5), (10, 3), (10, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_712_i1 : Fin 3 → Finset Cell := ![(placed21 4 (5, 7) required_44), (placed21 5 (10, 3) required_545), (placed21 7 (10, 7) required_655)] +def childrenD_712_i1 : Fin 3 → Finset Cell := ![(placed21 4 (5, 7) envelope_44), (placed21 5 (10, 3) envelope_545), (placed21 7 (10, 7) envelope_655)] +theorem common_sub_712_i1 : commonEnvelope childrenD_712_i1 ⊆ insert (6, 4) required_712_i1 := by decide +kernel +theorem child_required_sub_712_i1 : ∀ j, childrenC_712_i1 j ⊆ insert (6, 4) required_712_i1 := by decide +kernel +theorem child_envelope_sub_712_i1 : ∀ j, childrenD_712_i1 j ⊆ envelope_712_i1 := by decide +kernel +theorem pivot_mem_712_i1 : (6, 4) ∈ envelope_712_i1 := by decide +kernel +theorem children_work_712_i1 : ∀ j, Template HasSnaky 10 (childrenC_712_i1 j) (childrenD_712_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 4 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_545 5 (10, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_655 7 (10, 7)).mono (by decide +kernel) +theorem row_works_712_i1 : Template HasSnaky 11 required_712_i1 envelope_712_i1 := by + refine compose HasSnaky 10 childrenC_712_i1 childrenD_712_i1 children_work_712_i1 (6, 4) + required_712_i1 envelope_712_i1 pivot_mem_712_i1 child_required_sub_712_i1 child_envelope_sub_712_i1 ?_ + intro b hb + exact common_sub_712_i1 (mem_commonEnvelope childrenD_712_i1 b hb) +def required_712_i0 : Finset Cell := ⟨(([(5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_712_i0 : Finset Cell := ⟨(([(0, 5), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3), (9, 4), (9, 5), (9, 7), (10, 3), (10, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_712_i0 : Fin 6 → Finset Cell := ![(placed21 3 (2, 7) required_116), (placed21 3 (2, 8) required_297), (placed21 5 (8, 3) required_435), (placed21 1 (2, 3) required_435), (placed21 7 (10, 8) required_649), required_712_i1] +def childrenD_712_i0 : Fin 6 → Finset Cell := ![(placed21 3 (2, 7) envelope_116), (placed21 3 (2, 8) envelope_297), (placed21 5 (8, 3) envelope_435), (placed21 1 (2, 3) envelope_435), (placed21 7 (10, 8) envelope_649), envelope_712_i1] +theorem common_sub_712_i0 : commonEnvelope childrenD_712_i0 ⊆ insert (5, 4) required_712_i0 := by decide +kernel +theorem child_required_sub_712_i0 : ∀ j, childrenC_712_i0 j ⊆ insert (5, 4) required_712_i0 := by decide +kernel +theorem child_envelope_sub_712_i0 : ∀ j, childrenD_712_i0 j ⊆ envelope_712_i0 := by decide +kernel +theorem pivot_mem_712_i0 : (5, 4) ∈ envelope_712_i0 := by decide +kernel +theorem children_work_712_i0 : ∀ j, Template HasSnaky 12 (childrenC_712_i0 j) (childrenD_712_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_116 3 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_297 3 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_435 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_649 7 (10, 8)).mono (by decide +kernel) + · exact row_works_712_i1.mono (by decide +kernel) +theorem row_works_712_i0 : Template HasSnaky 13 required_712_i0 envelope_712_i0 := by + refine compose HasSnaky 12 childrenC_712_i0 childrenD_712_i0 children_work_712_i0 (5, 4) + required_712_i0 envelope_712_i0 pivot_mem_712_i0 child_required_sub_712_i0 child_envelope_sub_712_i0 ?_ + intro b hb + exact common_sub_712_i0 (mem_commonEnvelope childrenD_712_i0 b hb) +def required_712 : Finset Cell := ⟨(([(5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_712 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 8), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (11, 5), (11, 6), (11, 7), (12, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_712 : Fin 13 → Finset Cell := ![(placed21 4 (2, 9) required_174), (placed21 1 (2, 3) required_508), (placed21 5 (8, 3) required_508), (placed21 4 (2, 9) required_566), (placed21 1 (2, 3) required_605), (placed21 5 (8, 3) required_605), (placed21 4 (1, 10) required_647), (placed21 1 (0, 2) required_650), (placed21 5 (10, 2) required_650), required_712_i0, (placed21 2 (9, 1) required_661), (placed21 0 (2, 1) required_710), (placed21 0 (1, 0) required_711)] +def childrenD_712 : Fin 13 → Finset Cell := ![(placed21 4 (2, 9) envelope_174), (placed21 1 (2, 3) envelope_508), (placed21 5 (8, 3) envelope_508), (placed21 4 (2, 9) envelope_566), (placed21 1 (2, 3) envelope_605), (placed21 5 (8, 3) envelope_605), (placed21 4 (1, 10) envelope_647), (placed21 1 (0, 2) envelope_650), (placed21 5 (10, 2) envelope_650), envelope_712_i0, (placed21 2 (9, 1) envelope_661), (placed21 0 (2, 1) envelope_710), (placed21 0 (1, 0) envelope_711)] +theorem common_sub_712 : commonEnvelope childrenD_712 ⊆ insert (5, 6) required_712 := by decide +kernel +theorem child_required_sub_712 : ∀ j, childrenC_712 j ⊆ insert (5, 6) required_712 := by decide +kernel +theorem child_envelope_sub_712 : ∀ j, childrenD_712 j ⊆ envelope_712 := by decide +kernel +theorem pivot_mem_712 : (5, 6) ∈ envelope_712 := by decide +kernel +theorem children_work_712 : ∀ j, Template HasSnaky 14 (childrenC_712 j) (childrenD_712 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_174 4 (2, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_508 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_508 5 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_566 4 (2, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_605 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_605 5 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_647 4 (1, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_650 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_650 5 (10, 2)).mono (by decide +kernel) + · exact row_works_712_i0.mono (by decide +kernel) + · exact (placed21_template row_works_661 2 (9, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_710 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_711 0 (1, 0)).mono (by decide +kernel) +theorem row_works_712 : Template HasSnaky 15 required_712 envelope_712 := by + refine compose HasSnaky 14 childrenC_712 childrenD_712 children_work_712 (5, 6) + required_712 envelope_712 pivot_mem_712 child_required_sub_712 child_envelope_sub_712 ?_ + intro b hb + exact common_sub_712 (mem_commonEnvelope childrenD_712 b hb) +def required_713 : Finset Cell := ⟨(([(5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_713 : Finset Cell := ⟨(([(0, 4), (0, 6), (0, 8), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (11, 5), (11, 6), (11, 7), (12, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_713 : Fin 11 → Finset Cell := ![(placed21 1 (2, 3) required_508), (placed21 5 (8, 3) required_508), (placed21 1 (2, 3) required_605), (placed21 5 (8, 3) required_605), (placed21 4 (1, 10) required_645), (placed21 4 (1, 10) required_647), (placed21 1 (0, 2) required_650), (placed21 5 (10, 2) required_650), (placed21 4 (2, 9) required_654), (placed21 6 (8, 9) required_654), (placed21 0 (1, 0) required_711)] +def childrenD_713 : Fin 11 → Finset Cell := ![(placed21 1 (2, 3) envelope_508), (placed21 5 (8, 3) envelope_508), (placed21 1 (2, 3) envelope_605), (placed21 5 (8, 3) envelope_605), (placed21 4 (1, 10) envelope_645), (placed21 4 (1, 10) envelope_647), (placed21 1 (0, 2) envelope_650), (placed21 5 (10, 2) envelope_650), (placed21 4 (2, 9) envelope_654), (placed21 6 (8, 9) envelope_654), (placed21 0 (1, 0) envelope_711)] +theorem common_sub_713 : commonEnvelope childrenD_713 ⊆ insert (5, 6) required_713 := by decide +kernel +theorem child_required_sub_713 : ∀ j, childrenC_713 j ⊆ insert (5, 6) required_713 := by decide +kernel +theorem child_envelope_sub_713 : ∀ j, childrenD_713 j ⊆ envelope_713 := by decide +kernel +theorem pivot_mem_713 : (5, 6) ∈ envelope_713 := by decide +kernel +theorem children_work_713 : ∀ j, Template HasSnaky 14 (childrenC_713 j) (childrenD_713 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_508 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_508 5 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_605 1 (2, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_605 5 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_645 4 (1, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_647 4 (1, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_650 1 (0, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_650 5 (10, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_654 4 (2, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_654 6 (8, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_711 0 (1, 0)).mono (by decide +kernel) +theorem row_works_713 : Template HasSnaky 15 required_713 envelope_713 := by + refine compose HasSnaky 14 childrenC_713 childrenD_713 children_work_713 (5, 6) + required_713 envelope_713 pivot_mem_713 child_required_sub_713 child_envelope_sub_713 ?_ + intro b hb + exact common_sub_713 (mem_commonEnvelope childrenD_713 b hb) +def required_718_i0 : Finset Cell := ⟨(([(5, 5), (5, 6), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_718_i0 : Finset Cell := ⟨(([(2, 4), (2, 6), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 5), (8, 6), (9, 4), (9, 5), (9, 6), (10, 4), (10, 5), (10, 6), (11, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_718_i0 : Fin 4 → Finset Cell := ![(placed21 5 (8, 5) required_44), (placed21 5 (8, 5) required_52), (placed21 6 (8, 7) required_155), (placed21 3 (2, 8) required_341)] +def childrenD_718_i0 : Fin 4 → Finset Cell := ![(placed21 5 (8, 5) envelope_44), (placed21 5 (8, 5) envelope_52), (placed21 6 (8, 7) envelope_155), (placed21 3 (2, 8) envelope_341)] +theorem common_sub_718_i0 : commonEnvelope childrenD_718_i0 ⊆ insert (6, 5) required_718_i0 := by decide +kernel +theorem child_required_sub_718_i0 : ∀ j, childrenC_718_i0 j ⊆ insert (6, 5) required_718_i0 := by decide +kernel +theorem child_envelope_sub_718_i0 : ∀ j, childrenD_718_i0 j ⊆ envelope_718_i0 := by decide +kernel +theorem pivot_mem_718_i0 : (6, 5) ∈ envelope_718_i0 := by decide +kernel +theorem children_work_718_i0 : ∀ j, Template HasSnaky 7 (childrenC_718_i0 j) (childrenD_718_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 5 (8, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_52 5 (8, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_155 6 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_341 3 (2, 8)).mono (by decide +kernel) +theorem row_works_718_i0 : Template HasSnaky 8 required_718_i0 envelope_718_i0 := by + refine compose HasSnaky 7 childrenC_718_i0 childrenD_718_i0 children_work_718_i0 (6, 5) + required_718_i0 envelope_718_i0 pivot_mem_718_i0 child_required_sub_718_i0 child_envelope_sub_718_i0 ?_ + intro b hb + exact common_sub_718_i0 (mem_commonEnvelope childrenD_718_i0 b hb) +def required_718_i1 : Finset Cell := ⟨(([(5, 5), (5, 6), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_718_i1 : Finset Cell := ⟨(([(2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 1), (8, 2), (8, 3), (8, 4), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_718_i1 : Fin 5 → Finset Cell := ![(placed21 0 (2, 2) required_452), (placed21 2 (10, 0) required_520), (placed21 4 (5, 9) required_587), (placed21 7 (8, 6) required_612), (placed21 0 (2, 1) required_633)] +def childrenD_718_i1 : Fin 5 → Finset Cell := ![(placed21 0 (2, 2) envelope_452), (placed21 2 (10, 0) envelope_520), (placed21 4 (5, 9) envelope_587), (placed21 7 (8, 6) envelope_612), (placed21 0 (2, 1) envelope_633)] +theorem common_sub_718_i1 : commonEnvelope childrenD_718_i1 ⊆ insert (7, 6) required_718_i1 := by decide +kernel +theorem child_required_sub_718_i1 : ∀ j, childrenC_718_i1 j ⊆ insert (7, 6) required_718_i1 := by decide +kernel +theorem child_envelope_sub_718_i1 : ∀ j, childrenD_718_i1 j ⊆ envelope_718_i1 := by decide +kernel +theorem pivot_mem_718_i1 : (7, 6) ∈ envelope_718_i1 := by decide +kernel +theorem children_work_718_i1 : ∀ j, Template HasSnaky 12 (childrenC_718_i1 j) (childrenD_718_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_452 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_520 2 (10, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_587 4 (5, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_612 7 (8, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_633 0 (2, 1)).mono (by decide +kernel) +theorem row_works_718_i1 : Template HasSnaky 13 required_718_i1 envelope_718_i1 := by + refine compose HasSnaky 12 childrenC_718_i1 childrenD_718_i1 children_work_718_i1 (7, 6) + required_718_i1 envelope_718_i1 pivot_mem_718_i1 child_required_sub_718_i1 child_envelope_sub_718_i1 ?_ + intro b hb + exact common_sub_718_i1 (mem_commonEnvelope childrenD_718_i1 b hb) +def required_718_i3 : Finset Cell := ⟨(([(5, 5), (5, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_718_i3 : Finset Cell := ⟨(([(1, 7), (2, 5), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (4, 5), (4, 6), (5, 5), (5, 6), (5, 7), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (9, 5), (9, 6), (9, 7), (10, 5), (10, 6), (10, 7), (11, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_718_i3 : Fin 4 → Finset Cell := ![(placed21 3 (4, 6) required_52), (placed21 7 (8, 6) required_52), (placed21 1 (4, 5) required_232), (placed21 5 (8, 5) required_232)] +def childrenD_718_i3 : Fin 4 → Finset Cell := ![(placed21 3 (4, 6) envelope_52), (placed21 7 (8, 6) envelope_52), (placed21 1 (4, 5) envelope_232), (placed21 5 (8, 5) envelope_232)] +theorem common_sub_718_i3 : commonEnvelope childrenD_718_i3 ⊆ insert (6, 6) required_718_i3 := by decide +kernel +theorem child_required_sub_718_i3 : ∀ j, childrenC_718_i3 j ⊆ insert (6, 6) required_718_i3 := by decide +kernel +theorem child_envelope_sub_718_i3 : ∀ j, childrenD_718_i3 j ⊆ envelope_718_i3 := by decide +kernel +theorem pivot_mem_718_i3 : (6, 6) ∈ envelope_718_i3 := by decide +kernel +theorem children_work_718_i3 : ∀ j, Template HasSnaky 5 (childrenC_718_i3 j) (childrenD_718_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 3 (4, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_52 7 (8, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_232 1 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_232 5 (8, 5)).mono (by decide +kernel) +theorem row_works_718_i3 : Template HasSnaky 6 required_718_i3 envelope_718_i3 := by + refine compose HasSnaky 5 childrenC_718_i3 childrenD_718_i3 children_work_718_i3 (6, 6) + required_718_i3 envelope_718_i3 pivot_mem_718_i3 child_required_sub_718_i3 child_envelope_sub_718_i3 ?_ + intro b hb + exact common_sub_718_i3 (mem_commonEnvelope childrenD_718_i3 b hb) +def required_718_i5 : Finset Cell := ⟨(([(5, 6), (7, 4), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_718_i5 : Finset Cell := ⟨(([(4, 6), (5, 6), (6, 1), (6, 2), (6, 3), (6, 6), (6, 7), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (8, 1), (8, 2), (8, 3), (8, 5), (8, 6), (8, 7), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_718_i5 : Fin 2 → Finset Cell := ![(placed21 3 (6, 6) required_8), (placed21 5 (9, 3) required_229)] +def childrenD_718_i5 : Fin 2 → Finset Cell := ![(placed21 3 (6, 6) envelope_8), (placed21 5 (9, 3) envelope_229)] +theorem common_sub_718_i5 : commonEnvelope childrenD_718_i5 ⊆ insert (7, 3) required_718_i5 := by decide +kernel +theorem child_required_sub_718_i5 : ∀ j, childrenC_718_i5 j ⊆ insert (7, 3) required_718_i5 := by decide +kernel +theorem child_envelope_sub_718_i5 : ∀ j, childrenD_718_i5 j ⊆ envelope_718_i5 := by decide +kernel +theorem pivot_mem_718_i5 : (7, 3) ∈ envelope_718_i5 := by decide +kernel +theorem children_work_718_i5 : ∀ j, Template HasSnaky 4 (childrenC_718_i5 j) (childrenD_718_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 3 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_229 5 (9, 3)).mono (by decide +kernel) +theorem row_works_718_i5 : Template HasSnaky 5 required_718_i5 envelope_718_i5 := by + refine compose HasSnaky 4 childrenC_718_i5 childrenD_718_i5 children_work_718_i5 (7, 3) + required_718_i5 envelope_718_i5 pivot_mem_718_i5 child_required_sub_718_i5 child_envelope_sub_718_i5 ?_ + intro b hb + exact common_sub_718_i5 (mem_commonEnvelope childrenD_718_i5 b hb) +def required_718_i4 : Finset Cell := ⟨(([(5, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_718_i4 : Finset Cell := ⟨(([(4, 6), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_718_i4 : Fin 5 → Finset Cell := ![(placed21 4 (6, 8) required_12), (placed21 6 (8, 8) required_12), (placed21 0 (6, 2) required_12), (placed21 2 (8, 3) required_377), required_718_i5] +def childrenD_718_i4 : Fin 5 → Finset Cell := ![(placed21 4 (6, 8) envelope_12), (placed21 6 (8, 8) envelope_12), (placed21 0 (6, 2) envelope_12), (placed21 2 (8, 3) envelope_377), envelope_718_i5] +theorem common_sub_718_i4 : commonEnvelope childrenD_718_i4 ⊆ insert (7, 4) required_718_i4 := by decide +kernel +theorem child_required_sub_718_i4 : ∀ j, childrenC_718_i4 j ⊆ insert (7, 4) required_718_i4 := by decide +kernel +theorem child_envelope_sub_718_i4 : ∀ j, childrenD_718_i4 j ⊆ envelope_718_i4 := by decide +kernel +theorem pivot_mem_718_i4 : (7, 4) ∈ envelope_718_i4 := by decide +kernel +theorem children_work_718_i4 : ∀ j, Template HasSnaky 5 (childrenC_718_i4 j) (childrenD_718_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 4 (6, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_12 6 (8, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_12 0 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_377 2 (8, 3)).mono (by decide +kernel) + · exact row_works_718_i5.mono (by decide +kernel) +theorem row_works_718_i4 : Template HasSnaky 6 required_718_i4 envelope_718_i4 := by + refine compose HasSnaky 5 childrenC_718_i4 childrenD_718_i4 children_work_718_i4 (7, 4) + required_718_i4 envelope_718_i4 pivot_mem_718_i4 child_required_sub_718_i4 child_envelope_sub_718_i4 ?_ + intro b hb + exact common_sub_718_i4 (mem_commonEnvelope childrenD_718_i4 b hb) +def required_718_i6 : Finset Cell := ⟨(([(5, 5), (5, 6), (7, 5), (7, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_718_i6 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 5), (5, 6), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 7), (8, 8), (8, 9), (8, 10), (9, 2), (9, 3), (9, 4), (9, 7), (10, 2), (10, 3), (10, 4), (10, 7), (11, 2)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_718_i6 : Fin 3 → Finset Cell := ![(placed21 5 (8, 5) required_315), (placed21 0 (4, 2) required_317), (placed21 4 (3, 9) required_640)] +def childrenD_718_i6 : Fin 3 → Finset Cell := ![(placed21 5 (8, 5) envelope_315), (placed21 0 (4, 2) envelope_317), (placed21 4 (3, 9) envelope_640)] +theorem common_sub_718_i6 : commonEnvelope childrenD_718_i6 ⊆ insert (6, 6) required_718_i6 := by decide +kernel +theorem child_required_sub_718_i6 : ∀ j, childrenC_718_i6 j ⊆ insert (6, 6) required_718_i6 := by decide +kernel +theorem child_envelope_sub_718_i6 : ∀ j, childrenD_718_i6 j ⊆ envelope_718_i6 := by decide +kernel +theorem pivot_mem_718_i6 : (6, 6) ∈ envelope_718_i6 := by decide +kernel +theorem children_work_718_i6 : ∀ j, Template HasSnaky 9 (childrenC_718_i6 j) (childrenD_718_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_315 5 (8, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_317 0 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_640 4 (3, 9)).mono (by decide +kernel) +theorem row_works_718_i6 : Template HasSnaky 10 required_718_i6 envelope_718_i6 := by + refine compose HasSnaky 9 childrenC_718_i6 childrenD_718_i6 children_work_718_i6 (6, 6) + required_718_i6 envelope_718_i6 pivot_mem_718_i6 child_required_sub_718_i6 child_envelope_sub_718_i6 ?_ + intro b hb + exact common_sub_718_i6 (mem_commonEnvelope childrenD_718_i6 b hb) +def required_718_i2 : Finset Cell := ⟨(([(5, 5), (5, 6), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_718_i2 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (11, 2), (11, 4), (11, 6), (11, 7), (11, 8), (12, 6), (12, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_718_i2 : Fin 6 → Finset Cell := ![(placed21 5 (10, 5) required_329), (placed21 0 (2, 2) required_452), (placed21 4 (6, 9) required_462), required_718_i3, required_718_i4, required_718_i6] +def childrenD_718_i2 : Fin 6 → Finset Cell := ![(placed21 5 (10, 5) envelope_329), (placed21 0 (2, 2) envelope_452), (placed21 4 (6, 9) envelope_462), envelope_718_i3, envelope_718_i4, envelope_718_i6] +theorem common_sub_718_i2 : commonEnvelope childrenD_718_i2 ⊆ insert (7, 6) required_718_i2 := by decide +kernel +theorem child_required_sub_718_i2 : ∀ j, childrenC_718_i2 j ⊆ insert (7, 6) required_718_i2 := by decide +kernel +theorem child_envelope_sub_718_i2 : ∀ j, childrenD_718_i2 j ⊆ envelope_718_i2 := by decide +kernel +theorem pivot_mem_718_i2 : (7, 6) ∈ envelope_718_i2 := by decide +kernel +theorem children_work_718_i2 : ∀ j, Template HasSnaky 13 (childrenC_718_i2 j) (childrenD_718_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_329 5 (10, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_452 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_462 4 (6, 9)).mono (by decide +kernel) + · exact row_works_718_i3.mono (by decide +kernel) + · exact row_works_718_i4.mono (by decide +kernel) + · exact row_works_718_i6.mono (by decide +kernel) +theorem row_works_718_i2 : Template HasSnaky 14 required_718_i2 envelope_718_i2 := by + refine compose HasSnaky 13 childrenC_718_i2 childrenD_718_i2 children_work_718_i2 (7, 6) + required_718_i2 envelope_718_i2 pivot_mem_718_i2 child_required_sub_718_i2 child_envelope_sub_718_i2 ?_ + intro b hb + exact common_sub_718_i2 (mem_commonEnvelope childrenD_718_i2 b hb) +def required_718 : Finset Cell := ⟨(([(5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_718 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 6), (1, 7), (2, 4), (2, 5), (2, 6), (2, 7), (3, 2), (3, 4), (3, 5), (3, 6), (3, 7), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 8), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (11, 2), (11, 4), (11, 6), (11, 7), (11, 8), (12, 6), (12, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_718 : Fin 10 → Finset Cell := ![(placed21 6 (8, 8) required_120), (placed21 3 (2, 7) required_276), (placed21 3 (2, 7) required_338), (placed21 3 (2, 8) required_437), (placed21 3 (1, 7) required_611), (placed21 0 (4, 1) required_642), (placed21 0 (4, 1) required_643), required_718_i0, required_718_i1, required_718_i2] +def childrenD_718 : Fin 10 → Finset Cell := ![(placed21 6 (8, 8) envelope_120), (placed21 3 (2, 7) envelope_276), (placed21 3 (2, 7) envelope_338), (placed21 3 (2, 8) envelope_437), (placed21 3 (1, 7) envelope_611), (placed21 0 (4, 1) envelope_642), (placed21 0 (4, 1) envelope_643), envelope_718_i0, envelope_718_i1, envelope_718_i2] +theorem common_sub_718 : commonEnvelope childrenD_718 ⊆ insert (7, 5) required_718 := by decide +kernel +theorem child_required_sub_718 : ∀ j, childrenC_718 j ⊆ insert (7, 5) required_718 := by decide +kernel +theorem child_envelope_sub_718 : ∀ j, childrenD_718 j ⊆ envelope_718 := by decide +kernel +theorem pivot_mem_718 : (7, 5) ∈ envelope_718 := by decide +kernel +theorem children_work_718 : ∀ j, Template HasSnaky 14 (childrenC_718 j) (childrenD_718 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_120 6 (8, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_276 3 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_338 3 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_437 3 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_611 3 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_642 0 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_643 0 (4, 1)).mono (by decide +kernel) + · exact row_works_718_i0.mono (by decide +kernel) + · exact row_works_718_i1.mono (by decide +kernel) + · exact row_works_718_i2.mono (by decide +kernel) +theorem row_works_718 : Template HasSnaky 15 required_718 envelope_718 := by + refine compose HasSnaky 14 childrenC_718 childrenD_718 children_work_718 (7, 5) + required_718 envelope_718 pivot_mem_718 child_required_sub_718 child_envelope_sub_718 ?_ + intro b hb + exact common_sub_718 (mem_commonEnvelope childrenD_718 b hb) +def height_698 : ℕ := 15 +def childrenH_698 : Fin 8 → ℕ := ![height_12, height_182, height_188, height_619, height_620, height_622, height_687, height_697] +theorem height_exact_698 : height_698 = 1 + Finset.univ.sup childrenH_698 := by decide +kernel +theorem required_origin_698 : ∀ x ∈ required_698, + (∃ j, x ∈ childrenC_698 j) ∨ ∀ j, x ∈ childrenD_698 j := by decide +kernel +theorem required_exact_698 : required_698 = + ((Finset.univ.biUnion childrenC_698) ∪ commonEnvelope childrenD_698).erase (4, 6) := by + exact required_eq_combination childrenC_698 childrenD_698 (4, 6) required_698 + (by decide +kernel) child_required_sub_698 common_sub_698 required_origin_698 +theorem envelope_origin_698 : ∀ x ∈ envelope_698, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_698 j := by decide +kernel +theorem envelope_exact_698 : envelope_698 = + insert (4, 6) (Finset.univ.biUnion childrenD_698) := by + exact envelope_eq_combination childrenD_698 (4, 6) envelope_698 + pivot_mem_698 child_envelope_sub_698 envelope_origin_698 +def checked_698 : CheckedCard where + required := required_698 + envelope := envelope_698 + height := height_698 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_698 +def height_699_i3 : ℕ := 5 +def childrenH_699_i3 : Fin 2 → ℕ := ![height_42, height_52] +theorem height_exact_699_i3 : height_699_i3 = 1 + Finset.univ.sup childrenH_699_i3 := by decide +kernel +theorem required_origin_699_i3 : ∀ x ∈ required_699_i3, + (∃ j, x ∈ childrenC_699_i3 j) ∨ ∀ j, x ∈ childrenD_699_i3 j := by decide +kernel +theorem required_exact_699_i3 : required_699_i3 = + ((Finset.univ.biUnion childrenC_699_i3) ∪ commonEnvelope childrenD_699_i3).erase (7, 6) := by + exact required_eq_combination childrenC_699_i3 childrenD_699_i3 (7, 6) required_699_i3 + (by decide +kernel) child_required_sub_699_i3 common_sub_699_i3 required_origin_699_i3 +theorem envelope_origin_699_i3 : ∀ x ∈ envelope_699_i3, + x = (7, 6) ∨ ∃ j, x ∈ childrenD_699_i3 j := by decide +kernel +theorem envelope_exact_699_i3 : envelope_699_i3 = + insert (7, 6) (Finset.univ.biUnion childrenD_699_i3) := by + exact envelope_eq_combination childrenD_699_i3 (7, 6) envelope_699_i3 + pivot_mem_699_i3 child_envelope_sub_699_i3 envelope_origin_699_i3 +def checked_699_i3 : CheckedCard where + required := required_699_i3 + envelope := envelope_699_i3 + height := height_699_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_699_i3 +def height_699_i2 : ℕ := 7 +def childrenH_699_i2 : Fin 3 → ℕ := ![height_95, height_112, height_699_i3] +theorem height_exact_699_i2 : height_699_i2 = 1 + Finset.univ.sup childrenH_699_i2 := by decide +kernel +theorem required_origin_699_i2 : ∀ x ∈ required_699_i2, + (∃ j, x ∈ childrenC_699_i2 j) ∨ ∀ j, x ∈ childrenD_699_i2 j := by decide +kernel +theorem required_exact_699_i2 : required_699_i2 = + ((Finset.univ.biUnion childrenC_699_i2) ∪ commonEnvelope childrenD_699_i2).erase (7, 8) := by + exact required_eq_combination childrenC_699_i2 childrenD_699_i2 (7, 8) required_699_i2 + (by decide +kernel) child_required_sub_699_i2 common_sub_699_i2 required_origin_699_i2 +theorem envelope_origin_699_i2 : ∀ x ∈ envelope_699_i2, + x = (7, 8) ∨ ∃ j, x ∈ childrenD_699_i2 j := by decide +kernel +theorem envelope_exact_699_i2 : envelope_699_i2 = + insert (7, 8) (Finset.univ.biUnion childrenD_699_i2) := by + exact envelope_eq_combination childrenD_699_i2 (7, 8) envelope_699_i2 + pivot_mem_699_i2 child_envelope_sub_699_i2 envelope_origin_699_i2 +def checked_699_i2 : CheckedCard where + required := required_699_i2 + envelope := envelope_699_i2 + height := height_699_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_699_i2 +def height_699_i1 : ℕ := 11 +def childrenH_699_i1 : Fin 3 → ℕ := ![height_371, height_460, height_699_i2] +theorem height_exact_699_i1 : height_699_i1 = 1 + Finset.univ.sup childrenH_699_i1 := by decide +kernel +theorem required_origin_699_i1 : ∀ x ∈ required_699_i1, + (∃ j, x ∈ childrenC_699_i1 j) ∨ ∀ j, x ∈ childrenD_699_i1 j := by decide +kernel +theorem required_exact_699_i1 : required_699_i1 = + ((Finset.univ.biUnion childrenC_699_i1) ∪ commonEnvelope childrenD_699_i1).erase (6, 8) := by + exact required_eq_combination childrenC_699_i1 childrenD_699_i1 (6, 8) required_699_i1 + (by decide +kernel) child_required_sub_699_i1 common_sub_699_i1 required_origin_699_i1 +theorem envelope_origin_699_i1 : ∀ x ∈ envelope_699_i1, + x = (6, 8) ∨ ∃ j, x ∈ childrenD_699_i1 j := by decide +kernel +theorem envelope_exact_699_i1 : envelope_699_i1 = + insert (6, 8) (Finset.univ.biUnion childrenD_699_i1) := by + exact envelope_eq_combination childrenD_699_i1 (6, 8) envelope_699_i1 + pivot_mem_699_i1 child_envelope_sub_699_i1 envelope_origin_699_i1 +def checked_699_i1 : CheckedCard where + required := required_699_i1 + envelope := envelope_699_i1 + height := height_699_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_699_i1 +def height_699_i0 : ℕ := 14 +def childrenH_699_i0 : Fin 4 → ℕ := ![height_147, height_249, height_692, height_699_i1] +theorem height_exact_699_i0 : height_699_i0 = 1 + Finset.univ.sup childrenH_699_i0 := by decide +kernel +theorem required_origin_699_i0 : ∀ x ∈ required_699_i0, + (∃ j, x ∈ childrenC_699_i0 j) ∨ ∀ j, x ∈ childrenD_699_i0 j := by decide +kernel +theorem required_exact_699_i0 : required_699_i0 = + ((Finset.univ.biUnion childrenC_699_i0) ∪ commonEnvelope childrenD_699_i0).erase (4, 8) := by + exact required_eq_combination childrenC_699_i0 childrenD_699_i0 (4, 8) required_699_i0 + (by decide +kernel) child_required_sub_699_i0 common_sub_699_i0 required_origin_699_i0 +theorem envelope_origin_699_i0 : ∀ x ∈ envelope_699_i0, + x = (4, 8) ∨ ∃ j, x ∈ childrenD_699_i0 j := by decide +kernel +theorem envelope_exact_699_i0 : envelope_699_i0 = + insert (4, 8) (Finset.univ.biUnion childrenD_699_i0) := by + exact envelope_eq_combination childrenD_699_i0 (4, 8) envelope_699_i0 + pivot_mem_699_i0 child_envelope_sub_699_i0 envelope_origin_699_i0 +def checked_699_i0 : CheckedCard where + required := required_699_i0 + envelope := envelope_699_i0 + height := height_699_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_699_i0 +def height_699_i6 : ℕ := 5 +def childrenH_699_i6 : Fin 2 → ℕ := ![height_5, height_259] +theorem height_exact_699_i6 : height_699_i6 = 1 + Finset.univ.sup childrenH_699_i6 := by decide +kernel +theorem required_origin_699_i6 : ∀ x ∈ required_699_i6, + (∃ j, x ∈ childrenC_699_i6 j) ∨ ∀ j, x ∈ childrenD_699_i6 j := by decide +kernel +theorem required_exact_699_i6 : required_699_i6 = + ((Finset.univ.biUnion childrenC_699_i6) ∪ commonEnvelope childrenD_699_i6).erase (7, 4) := by + exact required_eq_combination childrenC_699_i6 childrenD_699_i6 (7, 4) required_699_i6 + (by decide +kernel) child_required_sub_699_i6 common_sub_699_i6 required_origin_699_i6 +theorem envelope_origin_699_i6 : ∀ x ∈ envelope_699_i6, + x = (7, 4) ∨ ∃ j, x ∈ childrenD_699_i6 j := by decide +kernel +theorem envelope_exact_699_i6 : envelope_699_i6 = + insert (7, 4) (Finset.univ.biUnion childrenD_699_i6) := by + exact envelope_eq_combination childrenD_699_i6 (7, 4) envelope_699_i6 + pivot_mem_699_i6 child_envelope_sub_699_i6 envelope_origin_699_i6 +def checked_699_i6 : CheckedCard where + required := required_699_i6 + envelope := envelope_699_i6 + height := height_699_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_699_i6 +def height_699_i5 : ℕ := 7 +def childrenH_699_i5 : Fin 4 → ℕ := ![height_10, height_48, height_134, height_699_i6] +theorem height_exact_699_i5 : height_699_i5 = 1 + Finset.univ.sup childrenH_699_i5 := by decide +kernel +theorem required_origin_699_i5 : ∀ x ∈ required_699_i5, + (∃ j, x ∈ childrenC_699_i5 j) ∨ ∀ j, x ∈ childrenD_699_i5 j := by decide +kernel +theorem required_exact_699_i5 : required_699_i5 = + ((Finset.univ.biUnion childrenC_699_i5) ∪ commonEnvelope childrenD_699_i5).erase (6, 3) := by + exact required_eq_combination childrenC_699_i5 childrenD_699_i5 (6, 3) required_699_i5 + (by decide +kernel) child_required_sub_699_i5 common_sub_699_i5 required_origin_699_i5 +theorem envelope_origin_699_i5 : ∀ x ∈ envelope_699_i5, + x = (6, 3) ∨ ∃ j, x ∈ childrenD_699_i5 j := by decide +kernel +theorem envelope_exact_699_i5 : envelope_699_i5 = + insert (6, 3) (Finset.univ.biUnion childrenD_699_i5) := by + exact envelope_eq_combination childrenD_699_i5 (6, 3) envelope_699_i5 + pivot_mem_699_i5 child_envelope_sub_699_i5 envelope_origin_699_i5 +def checked_699_i5 : CheckedCard where + required := required_699_i5 + envelope := envelope_699_i5 + height := height_699_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_699_i5 +def height_699_i4 : ℕ := 11 +def childrenH_699_i4 : Fin 5 → ℕ := ![height_389, height_545, height_546, height_549, height_699_i5] +theorem height_exact_699_i4 : height_699_i4 = 1 + Finset.univ.sup childrenH_699_i4 := by decide +kernel +theorem required_origin_699_i4 : ∀ x ∈ required_699_i4, + (∃ j, x ∈ childrenC_699_i4 j) ∨ ∀ j, x ∈ childrenD_699_i4 j := by decide +kernel +theorem required_exact_699_i4 : required_699_i4 = + ((Finset.univ.biUnion childrenC_699_i4) ∪ commonEnvelope childrenD_699_i4).erase (6, 4) := by + exact required_eq_combination childrenC_699_i4 childrenD_699_i4 (6, 4) required_699_i4 + (by decide +kernel) child_required_sub_699_i4 common_sub_699_i4 required_origin_699_i4 +theorem envelope_origin_699_i4 : ∀ x ∈ envelope_699_i4, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_699_i4 j := by decide +kernel +theorem envelope_exact_699_i4 : envelope_699_i4 = + insert (6, 4) (Finset.univ.biUnion childrenD_699_i4) := by + exact envelope_eq_combination childrenD_699_i4 (6, 4) envelope_699_i4 + pivot_mem_699_i4 child_envelope_sub_699_i4 envelope_origin_699_i4 +def checked_699_i4 : CheckedCard where + required := required_699_i4 + envelope := envelope_699_i4 + height := height_699_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_699_i4 +def height_699 : ℕ := 15 +def childrenH_699 : Fin 5 → ℕ := ![height_197, height_321, height_693, height_699_i0, height_699_i4] +theorem height_exact_699 : height_699 = 1 + Finset.univ.sup childrenH_699 := by decide +kernel +theorem required_origin_699 : ∀ x ∈ required_699, + (∃ j, x ∈ childrenC_699 j) ∨ ∀ j, x ∈ childrenD_699 j := by decide +kernel +theorem required_exact_699 : required_699 = + ((Finset.univ.biUnion childrenC_699) ∪ commonEnvelope childrenD_699).erase (7, 5) := by + exact required_eq_combination childrenC_699 childrenD_699 (7, 5) required_699 + (by decide +kernel) child_required_sub_699 common_sub_699 required_origin_699 +theorem envelope_origin_699 : ∀ x ∈ envelope_699, + x = (7, 5) ∨ ∃ j, x ∈ childrenD_699 j := by decide +kernel +theorem envelope_exact_699 : envelope_699 = + insert (7, 5) (Finset.univ.biUnion childrenD_699) := by + exact envelope_eq_combination childrenD_699 (7, 5) envelope_699 + pivot_mem_699 child_envelope_sub_699 envelope_origin_699 +def checked_699 : CheckedCard where + required := required_699 + envelope := envelope_699 + height := height_699 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_699 +def height_712_i1 : ℕ := 11 +def childrenH_712_i1 : Fin 3 → ℕ := ![height_44, height_545, height_655] +theorem height_exact_712_i1 : height_712_i1 = 1 + Finset.univ.sup childrenH_712_i1 := by decide +kernel +theorem required_origin_712_i1 : ∀ x ∈ required_712_i1, + (∃ j, x ∈ childrenC_712_i1 j) ∨ ∀ j, x ∈ childrenD_712_i1 j := by decide +kernel +theorem required_exact_712_i1 : required_712_i1 = + ((Finset.univ.biUnion childrenC_712_i1) ∪ commonEnvelope childrenD_712_i1).erase (6, 4) := by + exact required_eq_combination childrenC_712_i1 childrenD_712_i1 (6, 4) required_712_i1 + (by decide +kernel) child_required_sub_712_i1 common_sub_712_i1 required_origin_712_i1 +theorem envelope_origin_712_i1 : ∀ x ∈ envelope_712_i1, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_712_i1 j := by decide +kernel +theorem envelope_exact_712_i1 : envelope_712_i1 = + insert (6, 4) (Finset.univ.biUnion childrenD_712_i1) := by + exact envelope_eq_combination childrenD_712_i1 (6, 4) envelope_712_i1 + pivot_mem_712_i1 child_envelope_sub_712_i1 envelope_origin_712_i1 +def checked_712_i1 : CheckedCard where + required := required_712_i1 + envelope := envelope_712_i1 + height := height_712_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_712_i1 +def height_712_i0 : ℕ := 13 +def childrenH_712_i0 : Fin 6 → ℕ := ![height_116, height_297, height_435, height_435, height_649, height_712_i1] +theorem height_exact_712_i0 : height_712_i0 = 1 + Finset.univ.sup childrenH_712_i0 := by decide +kernel +theorem required_origin_712_i0 : ∀ x ∈ required_712_i0, + (∃ j, x ∈ childrenC_712_i0 j) ∨ ∀ j, x ∈ childrenD_712_i0 j := by decide +kernel +theorem required_exact_712_i0 : required_712_i0 = + ((Finset.univ.biUnion childrenC_712_i0) ∪ commonEnvelope childrenD_712_i0).erase (5, 4) := by + exact required_eq_combination childrenC_712_i0 childrenD_712_i0 (5, 4) required_712_i0 + (by decide +kernel) child_required_sub_712_i0 common_sub_712_i0 required_origin_712_i0 +theorem envelope_origin_712_i0 : ∀ x ∈ envelope_712_i0, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_712_i0 j := by decide +kernel +theorem envelope_exact_712_i0 : envelope_712_i0 = + insert (5, 4) (Finset.univ.biUnion childrenD_712_i0) := by + exact envelope_eq_combination childrenD_712_i0 (5, 4) envelope_712_i0 + pivot_mem_712_i0 child_envelope_sub_712_i0 envelope_origin_712_i0 +def checked_712_i0 : CheckedCard where + required := required_712_i0 + envelope := envelope_712_i0 + height := height_712_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_712_i0 +def height_712 : ℕ := 15 +def childrenH_712 : Fin 13 → ℕ := ![height_174, height_508, height_508, height_566, height_605, height_605, height_647, height_650, height_650, height_712_i0, height_661, height_710, height_711] +theorem height_exact_712 : height_712 = 1 + Finset.univ.sup childrenH_712 := by decide +kernel +theorem required_origin_712 : ∀ x ∈ required_712, + (∃ j, x ∈ childrenC_712 j) ∨ ∀ j, x ∈ childrenD_712 j := by decide +kernel +theorem required_exact_712 : required_712 = + ((Finset.univ.biUnion childrenC_712) ∪ commonEnvelope childrenD_712).erase (5, 6) := by + exact required_eq_combination childrenC_712 childrenD_712 (5, 6) required_712 + (by decide +kernel) child_required_sub_712 common_sub_712 required_origin_712 +theorem envelope_origin_712 : ∀ x ∈ envelope_712, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_712 j := by decide +kernel +theorem envelope_exact_712 : envelope_712 = + insert (5, 6) (Finset.univ.biUnion childrenD_712) := by + exact envelope_eq_combination childrenD_712 (5, 6) envelope_712 + pivot_mem_712 child_envelope_sub_712 envelope_origin_712 +def checked_712 : CheckedCard where + required := required_712 + envelope := envelope_712 + height := height_712 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_712 +def height_713 : ℕ := 15 +def childrenH_713 : Fin 11 → ℕ := ![height_508, height_508, height_605, height_605, height_645, height_647, height_650, height_650, height_654, height_654, height_711] +theorem height_exact_713 : height_713 = 1 + Finset.univ.sup childrenH_713 := by decide +kernel +theorem required_origin_713 : ∀ x ∈ required_713, + (∃ j, x ∈ childrenC_713 j) ∨ ∀ j, x ∈ childrenD_713 j := by decide +kernel +theorem required_exact_713 : required_713 = + ((Finset.univ.biUnion childrenC_713) ∪ commonEnvelope childrenD_713).erase (5, 6) := by + exact required_eq_combination childrenC_713 childrenD_713 (5, 6) required_713 + (by decide +kernel) child_required_sub_713 common_sub_713 required_origin_713 +theorem envelope_origin_713 : ∀ x ∈ envelope_713, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_713 j := by decide +kernel +theorem envelope_exact_713 : envelope_713 = + insert (5, 6) (Finset.univ.biUnion childrenD_713) := by + exact envelope_eq_combination childrenD_713 (5, 6) envelope_713 + pivot_mem_713 child_envelope_sub_713 envelope_origin_713 +def checked_713 : CheckedCard where + required := required_713 + envelope := envelope_713 + height := height_713 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_713 +def height_718_i0 : ℕ := 8 +def childrenH_718_i0 : Fin 4 → ℕ := ![height_44, height_52, height_155, height_341] +theorem height_exact_718_i0 : height_718_i0 = 1 + Finset.univ.sup childrenH_718_i0 := by decide +kernel +theorem required_origin_718_i0 : ∀ x ∈ required_718_i0, + (∃ j, x ∈ childrenC_718_i0 j) ∨ ∀ j, x ∈ childrenD_718_i0 j := by decide +kernel +theorem required_exact_718_i0 : required_718_i0 = + ((Finset.univ.biUnion childrenC_718_i0) ∪ commonEnvelope childrenD_718_i0).erase (6, 5) := by + exact required_eq_combination childrenC_718_i0 childrenD_718_i0 (6, 5) required_718_i0 + (by decide +kernel) child_required_sub_718_i0 common_sub_718_i0 required_origin_718_i0 +theorem envelope_origin_718_i0 : ∀ x ∈ envelope_718_i0, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_718_i0 j := by decide +kernel +theorem envelope_exact_718_i0 : envelope_718_i0 = + insert (6, 5) (Finset.univ.biUnion childrenD_718_i0) := by + exact envelope_eq_combination childrenD_718_i0 (6, 5) envelope_718_i0 + pivot_mem_718_i0 child_envelope_sub_718_i0 envelope_origin_718_i0 +def checked_718_i0 : CheckedCard where + required := required_718_i0 + envelope := envelope_718_i0 + height := height_718_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_718_i0 +def height_718_i1 : ℕ := 13 +def childrenH_718_i1 : Fin 5 → ℕ := ![height_452, height_520, height_587, height_612, height_633] +theorem height_exact_718_i1 : height_718_i1 = 1 + Finset.univ.sup childrenH_718_i1 := by decide +kernel +theorem required_origin_718_i1 : ∀ x ∈ required_718_i1, + (∃ j, x ∈ childrenC_718_i1 j) ∨ ∀ j, x ∈ childrenD_718_i1 j := by decide +kernel +theorem required_exact_718_i1 : required_718_i1 = + ((Finset.univ.biUnion childrenC_718_i1) ∪ commonEnvelope childrenD_718_i1).erase (7, 6) := by + exact required_eq_combination childrenC_718_i1 childrenD_718_i1 (7, 6) required_718_i1 + (by decide +kernel) child_required_sub_718_i1 common_sub_718_i1 required_origin_718_i1 +theorem envelope_origin_718_i1 : ∀ x ∈ envelope_718_i1, + x = (7, 6) ∨ ∃ j, x ∈ childrenD_718_i1 j := by decide +kernel +theorem envelope_exact_718_i1 : envelope_718_i1 = + insert (7, 6) (Finset.univ.biUnion childrenD_718_i1) := by + exact envelope_eq_combination childrenD_718_i1 (7, 6) envelope_718_i1 + pivot_mem_718_i1 child_envelope_sub_718_i1 envelope_origin_718_i1 +def checked_718_i1 : CheckedCard where + required := required_718_i1 + envelope := envelope_718_i1 + height := height_718_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_718_i1 +def height_718_i3 : ℕ := 6 +def childrenH_718_i3 : Fin 4 → ℕ := ![height_52, height_52, height_232, height_232] +theorem height_exact_718_i3 : height_718_i3 = 1 + Finset.univ.sup childrenH_718_i3 := by decide +kernel +theorem required_origin_718_i3 : ∀ x ∈ required_718_i3, + (∃ j, x ∈ childrenC_718_i3 j) ∨ ∀ j, x ∈ childrenD_718_i3 j := by decide +kernel +theorem required_exact_718_i3 : required_718_i3 = + ((Finset.univ.biUnion childrenC_718_i3) ∪ commonEnvelope childrenD_718_i3).erase (6, 6) := by + exact required_eq_combination childrenC_718_i3 childrenD_718_i3 (6, 6) required_718_i3 + (by decide +kernel) child_required_sub_718_i3 common_sub_718_i3 required_origin_718_i3 +theorem envelope_origin_718_i3 : ∀ x ∈ envelope_718_i3, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_718_i3 j := by decide +kernel +theorem envelope_exact_718_i3 : envelope_718_i3 = + insert (6, 6) (Finset.univ.biUnion childrenD_718_i3) := by + exact envelope_eq_combination childrenD_718_i3 (6, 6) envelope_718_i3 + pivot_mem_718_i3 child_envelope_sub_718_i3 envelope_origin_718_i3 +def checked_718_i3 : CheckedCard where + required := required_718_i3 + envelope := envelope_718_i3 + height := height_718_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_718_i3 +def height_718_i5 : ℕ := 5 +def childrenH_718_i5 : Fin 2 → ℕ := ![height_8, height_229] +theorem height_exact_718_i5 : height_718_i5 = 1 + Finset.univ.sup childrenH_718_i5 := by decide +kernel +theorem required_origin_718_i5 : ∀ x ∈ required_718_i5, + (∃ j, x ∈ childrenC_718_i5 j) ∨ ∀ j, x ∈ childrenD_718_i5 j := by decide +kernel +theorem required_exact_718_i5 : required_718_i5 = + ((Finset.univ.biUnion childrenC_718_i5) ∪ commonEnvelope childrenD_718_i5).erase (7, 3) := by + exact required_eq_combination childrenC_718_i5 childrenD_718_i5 (7, 3) required_718_i5 + (by decide +kernel) child_required_sub_718_i5 common_sub_718_i5 required_origin_718_i5 +theorem envelope_origin_718_i5 : ∀ x ∈ envelope_718_i5, + x = (7, 3) ∨ ∃ j, x ∈ childrenD_718_i5 j := by decide +kernel +theorem envelope_exact_718_i5 : envelope_718_i5 = + insert (7, 3) (Finset.univ.biUnion childrenD_718_i5) := by + exact envelope_eq_combination childrenD_718_i5 (7, 3) envelope_718_i5 + pivot_mem_718_i5 child_envelope_sub_718_i5 envelope_origin_718_i5 +def checked_718_i5 : CheckedCard where + required := required_718_i5 + envelope := envelope_718_i5 + height := height_718_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_718_i5 +def height_718_i4 : ℕ := 6 +def childrenH_718_i4 : Fin 5 → ℕ := ![height_12, height_12, height_12, height_377, height_718_i5] +theorem height_exact_718_i4 : height_718_i4 = 1 + Finset.univ.sup childrenH_718_i4 := by decide +kernel +theorem required_origin_718_i4 : ∀ x ∈ required_718_i4, + (∃ j, x ∈ childrenC_718_i4 j) ∨ ∀ j, x ∈ childrenD_718_i4 j := by decide +kernel +theorem required_exact_718_i4 : required_718_i4 = + ((Finset.univ.biUnion childrenC_718_i4) ∪ commonEnvelope childrenD_718_i4).erase (7, 4) := by + exact required_eq_combination childrenC_718_i4 childrenD_718_i4 (7, 4) required_718_i4 + (by decide +kernel) child_required_sub_718_i4 common_sub_718_i4 required_origin_718_i4 +theorem envelope_origin_718_i4 : ∀ x ∈ envelope_718_i4, + x = (7, 4) ∨ ∃ j, x ∈ childrenD_718_i4 j := by decide +kernel +theorem envelope_exact_718_i4 : envelope_718_i4 = + insert (7, 4) (Finset.univ.biUnion childrenD_718_i4) := by + exact envelope_eq_combination childrenD_718_i4 (7, 4) envelope_718_i4 + pivot_mem_718_i4 child_envelope_sub_718_i4 envelope_origin_718_i4 +def checked_718_i4 : CheckedCard where + required := required_718_i4 + envelope := envelope_718_i4 + height := height_718_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_718_i4 +def height_718_i6 : ℕ := 10 +def childrenH_718_i6 : Fin 3 → ℕ := ![height_315, height_317, height_640] +theorem height_exact_718_i6 : height_718_i6 = 1 + Finset.univ.sup childrenH_718_i6 := by decide +kernel +theorem required_origin_718_i6 : ∀ x ∈ required_718_i6, + (∃ j, x ∈ childrenC_718_i6 j) ∨ ∀ j, x ∈ childrenD_718_i6 j := by decide +kernel +theorem required_exact_718_i6 : required_718_i6 = + ((Finset.univ.biUnion childrenC_718_i6) ∪ commonEnvelope childrenD_718_i6).erase (6, 6) := by + exact required_eq_combination childrenC_718_i6 childrenD_718_i6 (6, 6) required_718_i6 + (by decide +kernel) child_required_sub_718_i6 common_sub_718_i6 required_origin_718_i6 +theorem envelope_origin_718_i6 : ∀ x ∈ envelope_718_i6, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_718_i6 j := by decide +kernel +theorem envelope_exact_718_i6 : envelope_718_i6 = + insert (6, 6) (Finset.univ.biUnion childrenD_718_i6) := by + exact envelope_eq_combination childrenD_718_i6 (6, 6) envelope_718_i6 + pivot_mem_718_i6 child_envelope_sub_718_i6 envelope_origin_718_i6 +def checked_718_i6 : CheckedCard where + required := required_718_i6 + envelope := envelope_718_i6 + height := height_718_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_718_i6 +def height_718_i2 : ℕ := 14 +def childrenH_718_i2 : Fin 6 → ℕ := ![height_329, height_452, height_462, height_718_i3, height_718_i4, height_718_i6] +theorem height_exact_718_i2 : height_718_i2 = 1 + Finset.univ.sup childrenH_718_i2 := by decide +kernel +theorem required_origin_718_i2 : ∀ x ∈ required_718_i2, + (∃ j, x ∈ childrenC_718_i2 j) ∨ ∀ j, x ∈ childrenD_718_i2 j := by decide +kernel +theorem required_exact_718_i2 : required_718_i2 = + ((Finset.univ.biUnion childrenC_718_i2) ∪ commonEnvelope childrenD_718_i2).erase (7, 6) := by + exact required_eq_combination childrenC_718_i2 childrenD_718_i2 (7, 6) required_718_i2 + (by decide +kernel) child_required_sub_718_i2 common_sub_718_i2 required_origin_718_i2 +theorem envelope_origin_718_i2 : ∀ x ∈ envelope_718_i2, + x = (7, 6) ∨ ∃ j, x ∈ childrenD_718_i2 j := by decide +kernel +theorem envelope_exact_718_i2 : envelope_718_i2 = + insert (7, 6) (Finset.univ.biUnion childrenD_718_i2) := by + exact envelope_eq_combination childrenD_718_i2 (7, 6) envelope_718_i2 + pivot_mem_718_i2 child_envelope_sub_718_i2 envelope_origin_718_i2 +def checked_718_i2 : CheckedCard where + required := required_718_i2 + envelope := envelope_718_i2 + height := height_718_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_718_i2 +def height_718 : ℕ := 15 +def childrenH_718 : Fin 10 → ℕ := ![height_120, height_276, height_338, height_437, height_611, height_642, height_643, height_718_i0, height_718_i1, height_718_i2] +theorem height_exact_718 : height_718 = 1 + Finset.univ.sup childrenH_718 := by decide +kernel +theorem required_origin_718 : ∀ x ∈ required_718, + (∃ j, x ∈ childrenC_718 j) ∨ ∀ j, x ∈ childrenD_718 j := by decide +kernel +theorem required_exact_718 : required_718 = + ((Finset.univ.biUnion childrenC_718) ∪ commonEnvelope childrenD_718).erase (7, 5) := by + exact required_eq_combination childrenC_718 childrenD_718 (7, 5) required_718 + (by decide +kernel) child_required_sub_718 common_sub_718 required_origin_718 +theorem envelope_origin_718 : ∀ x ∈ envelope_718, + x = (7, 5) ∨ ∃ j, x ∈ childrenD_718 j := by decide +kernel +theorem envelope_exact_718 : envelope_718 = + insert (7, 5) (Finset.univ.biUnion childrenD_718) := by + exact envelope_eq_combination childrenD_718 (7, 5) envelope_718 + pivot_mem_718 child_envelope_sub_718 envelope_origin_718 +def checked_718 : CheckedCard where + required := required_718 + envelope := envelope_718 + height := height_718 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_718 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part04.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part04.lean new file mode 100644 index 0000000..415e543 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part04.lean @@ -0,0 +1,401 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_719_i5 : Finset Cell := ⟨(([(3, 5), (3, 6), (4, 5), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_719_i5 : Finset Cell := ⟨(([(3, 5), (3, 6), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_719_i5 : Fin 2 → Finset Cell := ![(placed21 5 (4, 5) required_5), (placed21 0 (3, 4) required_412)] +def childrenD_719_i5 : Fin 2 → Finset Cell := ![(placed21 5 (4, 5) envelope_5), (placed21 0 (3, 4) envelope_412)] +theorem common_sub_719_i5 : commonEnvelope childrenD_719_i5 ⊆ insert (3, 8) required_719_i5 := by decide +kernel +theorem child_required_sub_719_i5 : ∀ j, childrenC_719_i5 j ⊆ insert (3, 8) required_719_i5 := by decide +kernel +theorem child_envelope_sub_719_i5 : ∀ j, childrenD_719_i5 j ⊆ envelope_719_i5 := by decide +kernel +theorem pivot_mem_719_i5 : (3, 8) ∈ envelope_719_i5 := by decide +kernel +theorem children_work_719_i5 : ∀ j, Template HasSnaky 8 (childrenC_719_i5 j) (childrenD_719_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_412 0 (3, 4)).mono (by decide +kernel) +theorem row_works_719_i5 : Template HasSnaky 9 required_719_i5 envelope_719_i5 := by + refine compose HasSnaky 8 childrenC_719_i5 childrenD_719_i5 children_work_719_i5 (3, 8) + required_719_i5 envelope_719_i5 pivot_mem_719_i5 child_required_sub_719_i5 child_envelope_sub_719_i5 ?_ + intro b hb + exact common_sub_719_i5 (mem_commonEnvelope childrenD_719_i5 b hb) +def required_719_i4 : Finset Cell := ⟨(([(3, 5), (3, 6), (4, 6), (4, 7), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_719_i4 : Finset Cell := ⟨(([(1, 7), (1, 8), (1, 9), (2, 6), (2, 7), (2, 8), (2, 9), (3, 5), (3, 6), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_719_i4 : Fin 3 → Finset Cell := ![(placed21 3 (2, 8) required_45), (placed21 5 (6, 5) required_343), required_719_i5] +def childrenD_719_i4 : Fin 3 → Finset Cell := ![(placed21 3 (2, 8) envelope_45), (placed21 5 (6, 5) envelope_343), envelope_719_i5] +theorem common_sub_719_i4 : commonEnvelope childrenD_719_i4 ⊆ insert (4, 5) required_719_i4 := by decide +kernel +theorem child_required_sub_719_i4 : ∀ j, childrenC_719_i4 j ⊆ insert (4, 5) required_719_i4 := by decide +kernel +theorem child_envelope_sub_719_i4 : ∀ j, childrenD_719_i4 j ⊆ envelope_719_i4 := by decide +kernel +theorem pivot_mem_719_i4 : (4, 5) ∈ envelope_719_i4 := by decide +kernel +theorem children_work_719_i4 : ∀ j, Template HasSnaky 9 (childrenC_719_i4 j) (childrenD_719_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_45 3 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_343 5 (6, 5)).mono (by decide +kernel) + · exact row_works_719_i5.mono (by decide +kernel) +theorem row_works_719_i4 : Template HasSnaky 10 required_719_i4 envelope_719_i4 := by + refine compose HasSnaky 9 childrenC_719_i4 childrenD_719_i4 children_work_719_i4 (4, 5) + required_719_i4 envelope_719_i4 pivot_mem_719_i4 child_required_sub_719_i4 child_envelope_sub_719_i4 ?_ + intro b hb + exact common_sub_719_i4 (mem_commonEnvelope childrenD_719_i4 b hb) +def required_719_i3 : Finset Cell := ⟨(([(3, 5), (3, 6), (4, 6), (4, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_719_i3 : Finset Cell := ⟨(([(1, 7), (1, 8), (1, 9), (2, 6), (2, 7), (2, 8), (2, 9), (3, 5), (3, 6), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_719_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 9) required_0), required_719_i4] +def childrenD_719_i3 : Fin 2 → Finset Cell := ![(placed21 7 (4, 9) envelope_0), envelope_719_i4] +theorem common_sub_719_i3 : commonEnvelope childrenD_719_i3 ⊆ insert (4, 8) required_719_i3 := by decide +kernel +theorem child_required_sub_719_i3 : ∀ j, childrenC_719_i3 j ⊆ insert (4, 8) required_719_i3 := by decide +kernel +theorem child_envelope_sub_719_i3 : ∀ j, childrenD_719_i3 j ⊆ envelope_719_i3 := by decide +kernel +theorem pivot_mem_719_i3 : (4, 8) ∈ envelope_719_i3 := by decide +kernel +theorem children_work_719_i3 : ∀ j, Template HasSnaky 10 (childrenC_719_i3 j) (childrenD_719_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 7 (4, 9)).mono (by decide +kernel) + · exact row_works_719_i4.mono (by decide +kernel) +theorem row_works_719_i3 : Template HasSnaky 11 required_719_i3 envelope_719_i3 := by + refine compose HasSnaky 10 childrenC_719_i3 childrenD_719_i3 children_work_719_i3 (4, 8) + required_719_i3 envelope_719_i3 pivot_mem_719_i3 child_required_sub_719_i3 child_envelope_sub_719_i3 ?_ + intro b hb + exact common_sub_719_i3 (mem_commonEnvelope childrenD_719_i3 b hb) +def required_719_i2 : Finset Cell := ⟨(([(3, 3), (3, 5), (3, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_719_i2 : Finset Cell := ⟨(([(1, 7), (1, 8), (1, 9), (2, 6), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_719_i2 : Fin 2 → Finset Cell := ![(placed21 1 (3, 3) required_1), required_719_i3] +def childrenD_719_i2 : Fin 2 → Finset Cell := ![(placed21 1 (3, 3) envelope_1), envelope_719_i3] +theorem common_sub_719_i2 : commonEnvelope childrenD_719_i2 ⊆ insert (4, 7) required_719_i2 := by decide +kernel +theorem child_required_sub_719_i2 : ∀ j, childrenC_719_i2 j ⊆ insert (4, 7) required_719_i2 := by decide +kernel +theorem child_envelope_sub_719_i2 : ∀ j, childrenD_719_i2 j ⊆ envelope_719_i2 := by decide +kernel +theorem pivot_mem_719_i2 : (4, 7) ∈ envelope_719_i2 := by decide +kernel +theorem children_work_719_i2 : ∀ j, Template HasSnaky 11 (childrenC_719_i2 j) (childrenD_719_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_1 1 (3, 3)).mono (by decide +kernel) + · exact row_works_719_i3.mono (by decide +kernel) +theorem row_works_719_i2 : Template HasSnaky 12 required_719_i2 envelope_719_i2 := by + refine compose HasSnaky 11 childrenC_719_i2 childrenD_719_i2 children_work_719_i2 (4, 7) + required_719_i2 envelope_719_i2 pivot_mem_719_i2 child_required_sub_719_i2 child_envelope_sub_719_i2 ?_ + intro b hb + exact common_sub_719_i2 (mem_commonEnvelope childrenD_719_i2 b hb) +def required_719_i1 : Finset Cell := ⟨(([(2, 5), (3, 3), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_719_i1 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 7), (1, 8), (1, 9), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_719_i1 : Fin 4 → Finset Cell := ![(placed21 1 (0, 5) required_53), (placed21 7 (6, 6) required_53), (placed21 7 (5, 6) required_209), required_719_i2] +def childrenD_719_i1 : Fin 4 → Finset Cell := ![(placed21 1 (0, 5) envelope_53), (placed21 7 (6, 6) envelope_53), (placed21 7 (5, 6) envelope_209), envelope_719_i2] +theorem common_sub_719_i1 : commonEnvelope childrenD_719_i1 ⊆ insert (4, 6) required_719_i1 := by decide +kernel +theorem child_required_sub_719_i1 : ∀ j, childrenC_719_i1 j ⊆ insert (4, 6) required_719_i1 := by decide +kernel +theorem child_envelope_sub_719_i1 : ∀ j, childrenD_719_i1 j ⊆ envelope_719_i1 := by decide +kernel +theorem pivot_mem_719_i1 : (4, 6) ∈ envelope_719_i1 := by decide +kernel +theorem children_work_719_i1 : ∀ j, Template HasSnaky 12 (childrenC_719_i1 j) (childrenD_719_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 1 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_53 7 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_209 7 (5, 6)).mono (by decide +kernel) + · exact row_works_719_i2.mono (by decide +kernel) +theorem row_works_719_i1 : Template HasSnaky 13 required_719_i1 envelope_719_i1 := by + refine compose HasSnaky 12 childrenC_719_i1 childrenD_719_i1 children_work_719_i1 (4, 6) + required_719_i1 envelope_719_i1 pivot_mem_719_i1 child_required_sub_719_i1 child_envelope_sub_719_i1 ?_ + intro b hb + exact common_sub_719_i1 (mem_commonEnvelope childrenD_719_i1 b hb) +def required_719_i0 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 3), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_719_i0 : Finset Cell := ⟨(([(0, 5), (1, 5), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_719_i0 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) required_53), (placed21 6 (3, 8) required_53), (placed21 6 (3, 7) required_209), required_719_i1] +def childrenD_719_i0 : Fin 4 → Finset Cell := ![(placed21 0 (2, 2) envelope_53), (placed21 6 (3, 8) envelope_53), (placed21 6 (3, 7) envelope_209), envelope_719_i1] +theorem common_sub_719_i0 : commonEnvelope childrenD_719_i0 ⊆ insert (3, 6) required_719_i0 := by decide +kernel +theorem child_required_sub_719_i0 : ∀ j, childrenC_719_i0 j ⊆ insert (3, 6) required_719_i0 := by decide +kernel +theorem child_envelope_sub_719_i0 : ∀ j, childrenD_719_i0 j ⊆ envelope_719_i0 := by decide +kernel +theorem pivot_mem_719_i0 : (3, 6) ∈ envelope_719_i0 := by decide +kernel +theorem children_work_719_i0 : ∀ j, Template HasSnaky 13 (childrenC_719_i0 j) (childrenD_719_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_53 6 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_209 6 (3, 7)).mono (by decide +kernel) + · exact row_works_719_i1.mono (by decide +kernel) +theorem row_works_719_i0 : Template HasSnaky 14 required_719_i0 envelope_719_i0 := by + refine compose HasSnaky 13 childrenC_719_i0 childrenD_719_i0 children_work_719_i0 (3, 6) + required_719_i0 envelope_719_i0 pivot_mem_719_i0 child_required_sub_719_i0 child_envelope_sub_719_i0 ?_ + intro b hb + exact common_sub_719_i0 (mem_commonEnvelope childrenD_719_i0 b hb) +def required_719_i6 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 3), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_719_i6 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (1, 1), (1, 2), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_719_i6 : Fin 3 → Finset Cell := ![(placed21 0 (2, 1) required_65), (placed21 1 (0, 3) required_301), (placed21 7 (5, 5) required_417)] +def childrenD_719_i6 : Fin 3 → Finset Cell := ![(placed21 0 (2, 1) envelope_65), (placed21 1 (0, 3) envelope_301), (placed21 7 (5, 5) envelope_417)] +theorem common_sub_719_i6 : commonEnvelope childrenD_719_i6 ⊆ insert (3, 4) required_719_i6 := by decide +kernel +theorem child_required_sub_719_i6 : ∀ j, childrenC_719_i6 j ⊆ insert (3, 4) required_719_i6 := by decide +kernel +theorem child_envelope_sub_719_i6 : ∀ j, childrenD_719_i6 j ⊆ envelope_719_i6 := by decide +kernel +theorem pivot_mem_719_i6 : (3, 4) ∈ envelope_719_i6 := by decide +kernel +theorem children_work_719_i6 : ∀ j, Template HasSnaky 6 (childrenC_719_i6 j) (childrenD_719_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_65 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_301 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_417 7 (5, 5)).mono (by decide +kernel) +theorem row_works_719_i6 : Template HasSnaky 7 required_719_i6 envelope_719_i6 := by + refine compose HasSnaky 6 childrenC_719_i6 childrenD_719_i6 children_work_719_i6 (3, 4) + required_719_i6 envelope_719_i6 pivot_mem_719_i6 child_required_sub_719_i6 child_envelope_sub_719_i6 ?_ + intro b hb + exact common_sub_719_i6 (mem_commonEnvelope childrenD_719_i6 b hb) +def required_719_i7 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 3), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_719_i7 : Finset Cell := ⟨(([(1, 5), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 6), (4, 7), (4, 8), (5, 6), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_719_i7 : Fin 3 → Finset Cell := ![(placed21 2 (3, 2) required_15), (placed21 0 (2, 1) required_65), (placed21 1 (1, 3) required_72)] +def childrenD_719_i7 : Fin 3 → Finset Cell := ![(placed21 2 (3, 2) envelope_15), (placed21 0 (2, 1) envelope_65), (placed21 1 (1, 3) envelope_72)] +theorem common_sub_719_i7 : commonEnvelope childrenD_719_i7 ⊆ insert (3, 4) required_719_i7 := by decide +kernel +theorem child_required_sub_719_i7 : ∀ j, childrenC_719_i7 j ⊆ insert (3, 4) required_719_i7 := by decide +kernel +theorem child_envelope_sub_719_i7 : ∀ j, childrenD_719_i7 j ⊆ envelope_719_i7 := by decide +kernel +theorem pivot_mem_719_i7 : (3, 4) ∈ envelope_719_i7 := by decide +kernel +theorem children_work_719_i7 : ∀ j, Template HasSnaky 5 (childrenC_719_i7 j) (childrenD_719_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 2 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_65 0 (2, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_72 1 (1, 3)).mono (by decide +kernel) +theorem row_works_719_i7 : Template HasSnaky 6 required_719_i7 envelope_719_i7 := by + refine compose HasSnaky 5 childrenC_719_i7 childrenD_719_i7 children_work_719_i7 (3, 4) + required_719_i7 envelope_719_i7 pivot_mem_719_i7 child_required_sub_719_i7 child_envelope_sub_719_i7 ?_ + intro b hb + exact common_sub_719_i7 (mem_commonEnvelope childrenD_719_i7 b hb) +def required_719 : Finset Cell := ⟨(([(2, 4), (2, 5), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_719 : Finset Cell := ⟨(([(0, 1), (0, 2), (0, 5), (1, 0), (1, 1), (1, 2), (1, 5), (1, 7), (1, 8), (1, 9), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_719 : Fin 5 → Finset Cell := ![(placed21 2 (3, 0) required_318), (placed21 4 (2, 7) required_334), required_719_i0, required_719_i6, required_719_i7] +def childrenD_719 : Fin 5 → Finset Cell := ![(placed21 2 (3, 0) envelope_318), (placed21 4 (2, 7) envelope_334), envelope_719_i0, envelope_719_i6, envelope_719_i7] +theorem common_sub_719 : commonEnvelope childrenD_719 ⊆ insert (3, 3) required_719 := by decide +kernel +theorem child_required_sub_719 : ∀ j, childrenC_719 j ⊆ insert (3, 3) required_719 := by decide +kernel +theorem child_envelope_sub_719 : ∀ j, childrenD_719 j ⊆ envelope_719 := by decide +kernel +theorem pivot_mem_719 : (3, 3) ∈ envelope_719 := by decide +kernel +theorem children_work_719 : ∀ j, Template HasSnaky 14 (childrenC_719 j) (childrenD_719 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_318 2 (3, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_334 4 (2, 7)).mono (by decide +kernel) + · exact row_works_719_i0.mono (by decide +kernel) + · exact row_works_719_i6.mono (by decide +kernel) + · exact row_works_719_i7.mono (by decide +kernel) +theorem row_works_719 : Template HasSnaky 15 required_719 envelope_719 := by + refine compose HasSnaky 14 childrenC_719 childrenD_719 children_work_719 (3, 3) + required_719 envelope_719 pivot_mem_719 child_required_sub_719 child_envelope_sub_719 ?_ + intro b hb + exact common_sub_719 (mem_commonEnvelope childrenD_719 b hb) +def height_719_i5 : ℕ := 9 +def childrenH_719_i5 : Fin 2 → ℕ := ![height_5, height_412] +theorem height_exact_719_i5 : height_719_i5 = 1 + Finset.univ.sup childrenH_719_i5 := by decide +kernel +theorem required_origin_719_i5 : ∀ x ∈ required_719_i5, + (∃ j, x ∈ childrenC_719_i5 j) ∨ ∀ j, x ∈ childrenD_719_i5 j := by decide +kernel +theorem required_exact_719_i5 : required_719_i5 = + ((Finset.univ.biUnion childrenC_719_i5) ∪ commonEnvelope childrenD_719_i5).erase (3, 8) := by + exact required_eq_combination childrenC_719_i5 childrenD_719_i5 (3, 8) required_719_i5 + (by decide +kernel) child_required_sub_719_i5 common_sub_719_i5 required_origin_719_i5 +theorem envelope_origin_719_i5 : ∀ x ∈ envelope_719_i5, + x = (3, 8) ∨ ∃ j, x ∈ childrenD_719_i5 j := by decide +kernel +theorem envelope_exact_719_i5 : envelope_719_i5 = + insert (3, 8) (Finset.univ.biUnion childrenD_719_i5) := by + exact envelope_eq_combination childrenD_719_i5 (3, 8) envelope_719_i5 + pivot_mem_719_i5 child_envelope_sub_719_i5 envelope_origin_719_i5 +def checked_719_i5 : CheckedCard where + required := required_719_i5 + envelope := envelope_719_i5 + height := height_719_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_719_i5 +def height_719_i4 : ℕ := 10 +def childrenH_719_i4 : Fin 3 → ℕ := ![height_45, height_343, height_719_i5] +theorem height_exact_719_i4 : height_719_i4 = 1 + Finset.univ.sup childrenH_719_i4 := by decide +kernel +theorem required_origin_719_i4 : ∀ x ∈ required_719_i4, + (∃ j, x ∈ childrenC_719_i4 j) ∨ ∀ j, x ∈ childrenD_719_i4 j := by decide +kernel +theorem required_exact_719_i4 : required_719_i4 = + ((Finset.univ.biUnion childrenC_719_i4) ∪ commonEnvelope childrenD_719_i4).erase (4, 5) := by + exact required_eq_combination childrenC_719_i4 childrenD_719_i4 (4, 5) required_719_i4 + (by decide +kernel) child_required_sub_719_i4 common_sub_719_i4 required_origin_719_i4 +theorem envelope_origin_719_i4 : ∀ x ∈ envelope_719_i4, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_719_i4 j := by decide +kernel +theorem envelope_exact_719_i4 : envelope_719_i4 = + insert (4, 5) (Finset.univ.biUnion childrenD_719_i4) := by + exact envelope_eq_combination childrenD_719_i4 (4, 5) envelope_719_i4 + pivot_mem_719_i4 child_envelope_sub_719_i4 envelope_origin_719_i4 +def checked_719_i4 : CheckedCard where + required := required_719_i4 + envelope := envelope_719_i4 + height := height_719_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_719_i4 +def height_719_i3 : ℕ := 11 +def childrenH_719_i3 : Fin 2 → ℕ := ![height_0, height_719_i4] +theorem height_exact_719_i3 : height_719_i3 = 1 + Finset.univ.sup childrenH_719_i3 := by decide +kernel +theorem required_origin_719_i3 : ∀ x ∈ required_719_i3, + (∃ j, x ∈ childrenC_719_i3 j) ∨ ∀ j, x ∈ childrenD_719_i3 j := by decide +kernel +theorem required_exact_719_i3 : required_719_i3 = + ((Finset.univ.biUnion childrenC_719_i3) ∪ commonEnvelope childrenD_719_i3).erase (4, 8) := by + exact required_eq_combination childrenC_719_i3 childrenD_719_i3 (4, 8) required_719_i3 + (by decide +kernel) child_required_sub_719_i3 common_sub_719_i3 required_origin_719_i3 +theorem envelope_origin_719_i3 : ∀ x ∈ envelope_719_i3, + x = (4, 8) ∨ ∃ j, x ∈ childrenD_719_i3 j := by decide +kernel +theorem envelope_exact_719_i3 : envelope_719_i3 = + insert (4, 8) (Finset.univ.biUnion childrenD_719_i3) := by + exact envelope_eq_combination childrenD_719_i3 (4, 8) envelope_719_i3 + pivot_mem_719_i3 child_envelope_sub_719_i3 envelope_origin_719_i3 +def checked_719_i3 : CheckedCard where + required := required_719_i3 + envelope := envelope_719_i3 + height := height_719_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_719_i3 +def height_719_i2 : ℕ := 12 +def childrenH_719_i2 : Fin 2 → ℕ := ![height_1, height_719_i3] +theorem height_exact_719_i2 : height_719_i2 = 1 + Finset.univ.sup childrenH_719_i2 := by decide +kernel +theorem required_origin_719_i2 : ∀ x ∈ required_719_i2, + (∃ j, x ∈ childrenC_719_i2 j) ∨ ∀ j, x ∈ childrenD_719_i2 j := by decide +kernel +theorem required_exact_719_i2 : required_719_i2 = + ((Finset.univ.biUnion childrenC_719_i2) ∪ commonEnvelope childrenD_719_i2).erase (4, 7) := by + exact required_eq_combination childrenC_719_i2 childrenD_719_i2 (4, 7) required_719_i2 + (by decide +kernel) child_required_sub_719_i2 common_sub_719_i2 required_origin_719_i2 +theorem envelope_origin_719_i2 : ∀ x ∈ envelope_719_i2, + x = (4, 7) ∨ ∃ j, x ∈ childrenD_719_i2 j := by decide +kernel +theorem envelope_exact_719_i2 : envelope_719_i2 = + insert (4, 7) (Finset.univ.biUnion childrenD_719_i2) := by + exact envelope_eq_combination childrenD_719_i2 (4, 7) envelope_719_i2 + pivot_mem_719_i2 child_envelope_sub_719_i2 envelope_origin_719_i2 +def checked_719_i2 : CheckedCard where + required := required_719_i2 + envelope := envelope_719_i2 + height := height_719_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_719_i2 +def height_719_i1 : ℕ := 13 +def childrenH_719_i1 : Fin 4 → ℕ := ![height_53, height_53, height_209, height_719_i2] +theorem height_exact_719_i1 : height_719_i1 = 1 + Finset.univ.sup childrenH_719_i1 := by decide +kernel +theorem required_origin_719_i1 : ∀ x ∈ required_719_i1, + (∃ j, x ∈ childrenC_719_i1 j) ∨ ∀ j, x ∈ childrenD_719_i1 j := by decide +kernel +theorem required_exact_719_i1 : required_719_i1 = + ((Finset.univ.biUnion childrenC_719_i1) ∪ commonEnvelope childrenD_719_i1).erase (4, 6) := by + exact required_eq_combination childrenC_719_i1 childrenD_719_i1 (4, 6) required_719_i1 + (by decide +kernel) child_required_sub_719_i1 common_sub_719_i1 required_origin_719_i1 +theorem envelope_origin_719_i1 : ∀ x ∈ envelope_719_i1, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_719_i1 j := by decide +kernel +theorem envelope_exact_719_i1 : envelope_719_i1 = + insert (4, 6) (Finset.univ.biUnion childrenD_719_i1) := by + exact envelope_eq_combination childrenD_719_i1 (4, 6) envelope_719_i1 + pivot_mem_719_i1 child_envelope_sub_719_i1 envelope_origin_719_i1 +def checked_719_i1 : CheckedCard where + required := required_719_i1 + envelope := envelope_719_i1 + height := height_719_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_719_i1 +def height_719_i0 : ℕ := 14 +def childrenH_719_i0 : Fin 4 → ℕ := ![height_53, height_53, height_209, height_719_i1] +theorem height_exact_719_i0 : height_719_i0 = 1 + Finset.univ.sup childrenH_719_i0 := by decide +kernel +theorem required_origin_719_i0 : ∀ x ∈ required_719_i0, + (∃ j, x ∈ childrenC_719_i0 j) ∨ ∀ j, x ∈ childrenD_719_i0 j := by decide +kernel +theorem required_exact_719_i0 : required_719_i0 = + ((Finset.univ.biUnion childrenC_719_i0) ∪ commonEnvelope childrenD_719_i0).erase (3, 6) := by + exact required_eq_combination childrenC_719_i0 childrenD_719_i0 (3, 6) required_719_i0 + (by decide +kernel) child_required_sub_719_i0 common_sub_719_i0 required_origin_719_i0 +theorem envelope_origin_719_i0 : ∀ x ∈ envelope_719_i0, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_719_i0 j := by decide +kernel +theorem envelope_exact_719_i0 : envelope_719_i0 = + insert (3, 6) (Finset.univ.biUnion childrenD_719_i0) := by + exact envelope_eq_combination childrenD_719_i0 (3, 6) envelope_719_i0 + pivot_mem_719_i0 child_envelope_sub_719_i0 envelope_origin_719_i0 +def checked_719_i0 : CheckedCard where + required := required_719_i0 + envelope := envelope_719_i0 + height := height_719_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_719_i0 +def height_719_i6 : ℕ := 7 +def childrenH_719_i6 : Fin 3 → ℕ := ![height_65, height_301, height_417] +theorem height_exact_719_i6 : height_719_i6 = 1 + Finset.univ.sup childrenH_719_i6 := by decide +kernel +theorem required_origin_719_i6 : ∀ x ∈ required_719_i6, + (∃ j, x ∈ childrenC_719_i6 j) ∨ ∀ j, x ∈ childrenD_719_i6 j := by decide +kernel +theorem required_exact_719_i6 : required_719_i6 = + ((Finset.univ.biUnion childrenC_719_i6) ∪ commonEnvelope childrenD_719_i6).erase (3, 4) := by + exact required_eq_combination childrenC_719_i6 childrenD_719_i6 (3, 4) required_719_i6 + (by decide +kernel) child_required_sub_719_i6 common_sub_719_i6 required_origin_719_i6 +theorem envelope_origin_719_i6 : ∀ x ∈ envelope_719_i6, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_719_i6 j := by decide +kernel +theorem envelope_exact_719_i6 : envelope_719_i6 = + insert (3, 4) (Finset.univ.biUnion childrenD_719_i6) := by + exact envelope_eq_combination childrenD_719_i6 (3, 4) envelope_719_i6 + pivot_mem_719_i6 child_envelope_sub_719_i6 envelope_origin_719_i6 +def checked_719_i6 : CheckedCard where + required := required_719_i6 + envelope := envelope_719_i6 + height := height_719_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_719_i6 +def height_719_i7 : ℕ := 6 +def childrenH_719_i7 : Fin 3 → ℕ := ![height_15, height_65, height_72] +theorem height_exact_719_i7 : height_719_i7 = 1 + Finset.univ.sup childrenH_719_i7 := by decide +kernel +theorem required_origin_719_i7 : ∀ x ∈ required_719_i7, + (∃ j, x ∈ childrenC_719_i7 j) ∨ ∀ j, x ∈ childrenD_719_i7 j := by decide +kernel +theorem required_exact_719_i7 : required_719_i7 = + ((Finset.univ.biUnion childrenC_719_i7) ∪ commonEnvelope childrenD_719_i7).erase (3, 4) := by + exact required_eq_combination childrenC_719_i7 childrenD_719_i7 (3, 4) required_719_i7 + (by decide +kernel) child_required_sub_719_i7 common_sub_719_i7 required_origin_719_i7 +theorem envelope_origin_719_i7 : ∀ x ∈ envelope_719_i7, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_719_i7 j := by decide +kernel +theorem envelope_exact_719_i7 : envelope_719_i7 = + insert (3, 4) (Finset.univ.biUnion childrenD_719_i7) := by + exact envelope_eq_combination childrenD_719_i7 (3, 4) envelope_719_i7 + pivot_mem_719_i7 child_envelope_sub_719_i7 envelope_origin_719_i7 +def checked_719_i7 : CheckedCard where + required := required_719_i7 + envelope := envelope_719_i7 + height := height_719_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_719_i7 +def height_719 : ℕ := 15 +def childrenH_719 : Fin 5 → ℕ := ![height_318, height_334, height_719_i0, height_719_i6, height_719_i7] +theorem height_exact_719 : height_719 = 1 + Finset.univ.sup childrenH_719 := by decide +kernel +theorem required_origin_719 : ∀ x ∈ required_719, + (∃ j, x ∈ childrenC_719 j) ∨ ∀ j, x ∈ childrenD_719 j := by decide +kernel +theorem required_exact_719 : required_719 = + ((Finset.univ.biUnion childrenC_719) ∪ commonEnvelope childrenD_719).erase (3, 3) := by + exact required_eq_combination childrenC_719 childrenD_719 (3, 3) required_719 + (by decide +kernel) child_required_sub_719 common_sub_719 required_origin_719 +theorem envelope_origin_719 : ∀ x ∈ envelope_719, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_719 j := by decide +kernel +theorem envelope_exact_719 : envelope_719 = + insert (3, 3) (Finset.univ.biUnion childrenD_719) := by + exact envelope_eq_combination childrenD_719 (3, 3) envelope_719 + pivot_mem_719 child_envelope_sub_719 envelope_origin_719 +def checked_719 : CheckedCard where + required := required_719 + envelope := envelope_719 + height := height_719 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_719 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part01.lean new file mode 100644 index 0000000..e9944d2 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part01.lean @@ -0,0 +1,930 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_602_i1 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 5), (4, 8), (6, 7), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_602_i1 : Finset Cell := ⟨(([(2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 7), (4, 8), (5, 4), (5, 5), (5, 6), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 4), (7, 5), (7, 6), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_602_i1 : Fin 2 → Finset Cell := ![(placed21 0 (3, 4) required_320), (placed21 3 (2, 8) required_496)] +def childrenD_602_i1 : Fin 2 → Finset Cell := ![(placed21 0 (3, 4) envelope_320), (placed21 3 (2, 8) envelope_496)] +theorem common_sub_602_i1 : commonEnvelope childrenD_602_i1 ⊆ insert (5, 8) required_602_i1 := by decide +kernel +theorem child_required_sub_602_i1 : ∀ j, childrenC_602_i1 j ⊆ insert (5, 8) required_602_i1 := by decide +kernel +theorem child_envelope_sub_602_i1 : ∀ j, childrenD_602_i1 j ⊆ envelope_602_i1 := by decide +kernel +theorem pivot_mem_602_i1 : (5, 8) ∈ envelope_602_i1 := by decide +kernel +theorem children_work_602_i1 : ∀ j, Template HasSnaky 7 (childrenC_602_i1 j) (childrenD_602_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_320 0 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_496 3 (2, 8)).mono (by decide +kernel) +theorem row_works_602_i1 : Template HasSnaky 8 required_602_i1 envelope_602_i1 := by + refine compose HasSnaky 7 childrenC_602_i1 childrenD_602_i1 children_work_602_i1 (5, 8) + required_602_i1 envelope_602_i1 pivot_mem_602_i1 child_required_sub_602_i1 child_envelope_sub_602_i1 ?_ + intro b hb + exact common_sub_602_i1 (mem_commonEnvelope childrenD_602_i1 b hb) +def required_602_i0 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 5), (4, 8), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_602_i0 : Finset Cell := ⟨(([(2, 7), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 8), (10, 9), (10, 10), (11, 8), (11, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_602_i0 : Fin 4 → Finset Cell := ![(placed21 4 (3, 11) required_59), (placed21 3 (2, 8) required_497), required_602_i1, (placed21 0 (3, 3) required_555)] +def childrenD_602_i0 : Fin 4 → Finset Cell := ![(placed21 4 (3, 11) envelope_59), (placed21 3 (2, 8) envelope_497), envelope_602_i1, (placed21 0 (3, 3) envelope_555)] +theorem common_sub_602_i0 : commonEnvelope childrenD_602_i0 ⊆ insert (6, 8) required_602_i0 := by decide +kernel +theorem child_required_sub_602_i0 : ∀ j, childrenC_602_i0 j ⊆ insert (6, 8) required_602_i0 := by decide +kernel +theorem child_envelope_sub_602_i0 : ∀ j, childrenD_602_i0 j ⊆ envelope_602_i0 := by decide +kernel +theorem pivot_mem_602_i0 : (6, 8) ∈ envelope_602_i0 := by decide +kernel +theorem children_work_602_i0 : ∀ j, Template HasSnaky 13 (childrenC_602_i0 j) (childrenD_602_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_59 4 (3, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_497 3 (2, 8)).mono (by decide +kernel) + · exact row_works_602_i1.mono (by decide +kernel) + · exact (placed21_template row_works_555 0 (3, 3)).mono (by decide +kernel) +theorem row_works_602_i0 : Template HasSnaky 14 required_602_i0 envelope_602_i0 := by + refine compose HasSnaky 13 childrenC_602_i0 childrenD_602_i0 children_work_602_i0 (6, 8) + required_602_i0 envelope_602_i0 pivot_mem_602_i0 child_required_sub_602_i0 child_envelope_sub_602_i0 ?_ + intro b hb + exact common_sub_602_i0 (mem_commonEnvelope childrenD_602_i0 b hb) +def required_602_i3 : Finset Cell := ⟨(([(3, 8), (4, 8), (6, 7), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_602_i3 : Finset Cell := ⟨(([(3, 8), (4, 8), (5, 3), (5, 4), (5, 5), (5, 8), (5, 9), (5, 10), (5, 11), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 8), (8, 9), (8, 10), (9, 8), (9, 9), (9, 10), (10, 8), (10, 9), (10, 10), (11, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_602_i3 : Fin 2 → Finset Cell := ![(placed21 4 (3, 8) required_2), (placed21 4 (5, 12) required_545)] +def childrenD_602_i3 : Fin 2 → Finset Cell := ![(placed21 4 (3, 8) envelope_2), (placed21 4 (5, 12) envelope_545)] +theorem common_sub_602_i3 : commonEnvelope childrenD_602_i3 ⊆ insert (6, 8) required_602_i3 := by decide +kernel +theorem child_required_sub_602_i3 : ∀ j, childrenC_602_i3 j ⊆ insert (6, 8) required_602_i3 := by decide +kernel +theorem child_envelope_sub_602_i3 : ∀ j, childrenD_602_i3 j ⊆ envelope_602_i3 := by decide +kernel +theorem pivot_mem_602_i3 : (6, 8) ∈ envelope_602_i3 := by decide +kernel +theorem children_work_602_i3 : ∀ j, Template HasSnaky 10 (childrenC_602_i3 j) (childrenD_602_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_2 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_545 4 (5, 12)).mono (by decide +kernel) +theorem row_works_602_i3 : Template HasSnaky 11 required_602_i3 envelope_602_i3 := by + refine compose HasSnaky 10 childrenC_602_i3 childrenD_602_i3 children_work_602_i3 (6, 8) + required_602_i3 envelope_602_i3 pivot_mem_602_i3 child_required_sub_602_i3 child_envelope_sub_602_i3 ?_ + intro b hb + exact common_sub_602_i3 (mem_commonEnvelope childrenD_602_i3 b hb) +def required_602_i2 : Finset Cell := ⟨(([(3, 8), (4, 8), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_602_i2 : Finset Cell := ⟨(([(3, 8), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (11, 6), (11, 7), (11, 8), (11, 10), (12, 6), (12, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_602_i2 : Fin 4 → Finset Cell := ![(placed21 3 (3, 8) required_107), (placed21 3 (3, 8) required_163), (placed21 4 (3, 11) required_556), required_602_i3] +def childrenD_602_i2 : Fin 4 → Finset Cell := ![(placed21 3 (3, 8) envelope_107), (placed21 3 (3, 8) envelope_163), (placed21 4 (3, 11) envelope_556), envelope_602_i3] +theorem common_sub_602_i2 : commonEnvelope childrenD_602_i2 ⊆ insert (7, 7) required_602_i2 := by decide +kernel +theorem child_required_sub_602_i2 : ∀ j, childrenC_602_i2 j ⊆ insert (7, 7) required_602_i2 := by decide +kernel +theorem child_envelope_sub_602_i2 : ∀ j, childrenD_602_i2 j ⊆ envelope_602_i2 := by decide +kernel +theorem pivot_mem_602_i2 : (7, 7) ∈ envelope_602_i2 := by decide +kernel +theorem children_work_602_i2 : ∀ j, Template HasSnaky 11 (childrenC_602_i2 j) (childrenD_602_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_107 3 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_163 3 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_556 4 (3, 11)).mono (by decide +kernel) + · exact row_works_602_i3.mono (by decide +kernel) +theorem row_works_602_i2 : Template HasSnaky 12 required_602_i2 envelope_602_i2 := by + refine compose HasSnaky 11 childrenC_602_i2 childrenD_602_i2 children_work_602_i2 (7, 7) + required_602_i2 envelope_602_i2 pivot_mem_602_i2 child_required_sub_602_i2 child_envelope_sub_602_i2 ?_ + intro b hb + exact common_sub_602_i2 (mem_commonEnvelope childrenD_602_i2 b hb) +def required_602_i6 : Finset Cell := ⟨(([(3, 5), (4, 5), (4, 8), (5, 5), (6, 7), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_602_i6 : Finset Cell := ⟨(([(2, 4), (2, 6), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 3), (4, 4), (4, 5), (4, 7), (4, 8), (5, 5), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 4), (7, 5), (8, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_602_i6 : Fin 2 → Finset Cell := ![(placed21 0 (3, 4) required_157), (placed21 2 (6, 3) required_383)] +def childrenD_602_i6 : Fin 2 → Finset Cell := ![(placed21 0 (3, 4) envelope_157), (placed21 2 (6, 3) envelope_383)] +theorem common_sub_602_i6 : commonEnvelope childrenD_602_i6 ⊆ insert (6, 5) required_602_i6 := by decide +kernel +theorem child_required_sub_602_i6 : ∀ j, childrenC_602_i6 j ⊆ insert (6, 5) required_602_i6 := by decide +kernel +theorem child_envelope_sub_602_i6 : ∀ j, childrenD_602_i6 j ⊆ envelope_602_i6 := by decide +kernel +theorem pivot_mem_602_i6 : (6, 5) ∈ envelope_602_i6 := by decide +kernel +theorem children_work_602_i6 : ∀ j, Template HasSnaky 5 (childrenC_602_i6 j) (childrenD_602_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_157 0 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_383 2 (6, 3)).mono (by decide +kernel) +theorem row_works_602_i6 : Template HasSnaky 6 required_602_i6 envelope_602_i6 := by + refine compose HasSnaky 5 childrenC_602_i6 childrenD_602_i6 children_work_602_i6 (6, 5) + required_602_i6 envelope_602_i6 pivot_mem_602_i6 child_required_sub_602_i6 child_envelope_sub_602_i6 ?_ + intro b hb + exact common_sub_602_i6 (mem_commonEnvelope childrenD_602_i6 b hb) +def required_602_i7 : Finset Cell := ⟨(([(4, 5), (5, 5), (6, 7), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_602_i7 : Finset Cell := ⟨(([(3, 5), (4, 5), (5, 4), (5, 5), (5, 6), (5, 9), (5, 10), (5, 11), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 5), (7, 9), (7, 10), (7, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_602_i7 : Fin 2 → Finset Cell := ![(placed21 0 (5, 5) required_18), (placed21 7 (7, 8) required_381)] +def childrenD_602_i7 : Fin 2 → Finset Cell := ![(placed21 0 (5, 5) envelope_18), (placed21 7 (7, 8) envelope_381)] +theorem common_sub_602_i7 : commonEnvelope childrenD_602_i7 ⊆ insert (6, 6) required_602_i7 := by decide +kernel +theorem child_required_sub_602_i7 : ∀ j, childrenC_602_i7 j ⊆ insert (6, 6) required_602_i7 := by decide +kernel +theorem child_envelope_sub_602_i7 : ∀ j, childrenD_602_i7 j ⊆ envelope_602_i7 := by decide +kernel +theorem pivot_mem_602_i7 : (6, 6) ∈ envelope_602_i7 := by decide +kernel +theorem children_work_602_i7 : ∀ j, Template HasSnaky 4 (childrenC_602_i7 j) (childrenD_602_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 0 (5, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_381 7 (7, 8)).mono (by decide +kernel) +theorem row_works_602_i7 : Template HasSnaky 5 required_602_i7 envelope_602_i7 := by + refine compose HasSnaky 4 childrenC_602_i7 childrenD_602_i7 children_work_602_i7 (6, 6) + required_602_i7 envelope_602_i7 pivot_mem_602_i7 child_required_sub_602_i7 child_envelope_sub_602_i7 ?_ + intro b hb + exact common_sub_602_i7 (mem_commonEnvelope childrenD_602_i7 b hb) +def required_602_i8 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 5), (4, 8), (5, 5), (6, 7), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_602_i8 : Finset Cell := ⟨(([(2, 6), (3, 5), (3, 6), (3, 7), (3, 8), (4, 4), (4, 5), (4, 7), (4, 8), (5, 4), (5, 5), (5, 6), (5, 7), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_602_i8 : Fin 2 → Finset Cell := ![(placed21 0 (5, 4) required_64), (placed21 3 (2, 8) required_500)] +def childrenD_602_i8 : Fin 2 → Finset Cell := ![(placed21 0 (5, 4) envelope_64), (placed21 3 (2, 8) envelope_500)] +theorem common_sub_602_i8 : commonEnvelope childrenD_602_i8 ⊆ insert (5, 7) required_602_i8 := by decide +kernel +theorem child_required_sub_602_i8 : ∀ j, childrenC_602_i8 j ⊆ insert (5, 7) required_602_i8 := by decide +kernel +theorem child_envelope_sub_602_i8 : ∀ j, childrenD_602_i8 j ⊆ envelope_602_i8 := by decide +kernel +theorem pivot_mem_602_i8 : (5, 7) ∈ envelope_602_i8 := by decide +kernel +theorem children_work_602_i8 : ∀ j, Template HasSnaky 4 (childrenC_602_i8 j) (childrenD_602_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_64 0 (5, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_500 3 (2, 8)).mono (by decide +kernel) +theorem row_works_602_i8 : Template HasSnaky 5 required_602_i8 envelope_602_i8 := by + refine compose HasSnaky 4 childrenC_602_i8 childrenD_602_i8 children_work_602_i8 (5, 7) + required_602_i8 envelope_602_i8 pivot_mem_602_i8 child_required_sub_602_i8 child_envelope_sub_602_i8 ?_ + intro b hb + exact common_sub_602_i8 (mem_commonEnvelope childrenD_602_i8 b hb) +def required_602_i5 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 5), (4, 8), (6, 7), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_602_i5 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 9), (5, 10), (5, 11), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 5), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 3), (8, 4), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_602_i5 : Fin 4 → Finset Cell := ![required_602_i6, required_602_i7, required_602_i8, (placed21 3 (1, 8) required_601)] +def childrenD_602_i5 : Fin 4 → Finset Cell := ![envelope_602_i6, envelope_602_i7, envelope_602_i8, (placed21 3 (1, 8) envelope_601)] +theorem common_sub_602_i5 : commonEnvelope childrenD_602_i5 ⊆ insert (5, 5) required_602_i5 := by decide +kernel +theorem child_required_sub_602_i5 : ∀ j, childrenC_602_i5 j ⊆ insert (5, 5) required_602_i5 := by decide +kernel +theorem child_envelope_sub_602_i5 : ∀ j, childrenD_602_i5 j ⊆ envelope_602_i5 := by decide +kernel +theorem pivot_mem_602_i5 : (5, 5) ∈ envelope_602_i5 := by decide +kernel +theorem children_work_602_i5 : ∀ j, Template HasSnaky 11 (childrenC_602_i5 j) (childrenD_602_i5 j) := by + intro j + fin_cases j + · exact row_works_602_i6.mono (by decide +kernel) + · exact row_works_602_i7.mono (by decide +kernel) + · exact row_works_602_i8.mono (by decide +kernel) + · exact (placed21_template row_works_601 3 (1, 8)).mono (by decide +kernel) +theorem row_works_602_i5 : Template HasSnaky 12 required_602_i5 envelope_602_i5 := by + refine compose HasSnaky 11 childrenC_602_i5 childrenD_602_i5 children_work_602_i5 (5, 5) + required_602_i5 envelope_602_i5 pivot_mem_602_i5 child_required_sub_602_i5 child_envelope_sub_602_i5 ?_ + intro b hb + exact common_sub_602_i5 (mem_commonEnvelope childrenD_602_i5 b hb) +def required_602_i4 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 5), (4, 8), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_602_i4 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 3), (7, 4), (7, 5), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 3), (8, 4), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_602_i4 : Fin 4 → Finset Cell := ![(placed21 0 (3, 5) required_119), (placed21 3 (2, 8) required_497), (placed21 1 (2, 4) required_498), required_602_i5] +def childrenD_602_i4 : Fin 4 → Finset Cell := ![(placed21 0 (3, 5) envelope_119), (placed21 3 (2, 8) envelope_497), (placed21 1 (2, 4) envelope_498), envelope_602_i5] +theorem common_sub_602_i4 : commonEnvelope childrenD_602_i4 ⊆ insert (6, 8) required_602_i4 := by decide +kernel +theorem child_required_sub_602_i4 : ∀ j, childrenC_602_i4 j ⊆ insert (6, 8) required_602_i4 := by decide +kernel +theorem child_envelope_sub_602_i4 : ∀ j, childrenD_602_i4 j ⊆ envelope_602_i4 := by decide +kernel +theorem pivot_mem_602_i4 : (6, 8) ∈ envelope_602_i4 := by decide +kernel +theorem children_work_602_i4 : ∀ j, Template HasSnaky 12 (childrenC_602_i4 j) (childrenD_602_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_119 0 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_497 3 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_498 1 (2, 4)).mono (by decide +kernel) + · exact row_works_602_i5.mono (by decide +kernel) +theorem row_works_602_i4 : Template HasSnaky 13 required_602_i4 envelope_602_i4 := by + refine compose HasSnaky 12 childrenC_602_i4 childrenD_602_i4 children_work_602_i4 (6, 8) + required_602_i4 envelope_602_i4 pivot_mem_602_i4 child_required_sub_602_i4 child_envelope_sub_602_i4 ?_ + intro b hb + exact common_sub_602_i4 (mem_commonEnvelope childrenD_602_i4 b hb) +def required_602 : Finset Cell := ⟨(([(3, 5), (3, 8), (4, 5), (4, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_602 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 7), (1, 3), (1, 4), (1, 7), (2, 1), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (2, 9), (2, 10), (2, 11), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 7), (4, 8), (4, 10), (4, 11), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (10, 1), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (12, 6), (12, 8), (12, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_602 : Fin 12 → Finset Cell := ![(placed21 0 (0, 1) required_553), required_602_i0, required_602_i2, (placed21 0 (2, 2) required_557), (placed21 1 (2, 4) required_564), (placed21 1 (2, 4) required_568), (placed21 3 (0, 8) required_573), (placed21 4 (2, 10) required_574), (placed21 4 (0, 13) required_583), (placed21 4 (0, 12) required_598), (placed21 0 (3, 4) required_599), required_602_i4] +def childrenD_602 : Fin 12 → Finset Cell := ![(placed21 0 (0, 1) envelope_553), envelope_602_i0, envelope_602_i2, (placed21 0 (2, 2) envelope_557), (placed21 1 (2, 4) envelope_564), (placed21 1 (2, 4) envelope_568), (placed21 3 (0, 8) envelope_573), (placed21 4 (2, 10) envelope_574), (placed21 4 (0, 13) envelope_583), (placed21 4 (0, 12) envelope_598), (placed21 0 (3, 4) envelope_599), envelope_602_i4] +theorem common_sub_602 : commonEnvelope childrenD_602 ⊆ insert (6, 7) required_602 := by decide +kernel +theorem child_required_sub_602 : ∀ j, childrenC_602 j ⊆ insert (6, 7) required_602 := by decide +kernel +theorem child_envelope_sub_602 : ∀ j, childrenD_602 j ⊆ envelope_602 := by decide +kernel +theorem pivot_mem_602 : (6, 7) ∈ envelope_602 := by decide +kernel +theorem children_work_602 : ∀ j, Template HasSnaky 15 (childrenC_602 j) (childrenD_602 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_553 0 (0, 1)).mono (by decide +kernel) + · exact row_works_602_i0.mono (by decide +kernel) + · exact row_works_602_i2.mono (by decide +kernel) + · exact (placed21_template row_works_557 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_564 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_568 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_573 3 (0, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_574 4 (2, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_583 4 (0, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_598 4 (0, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_599 0 (3, 4)).mono (by decide +kernel) + · exact row_works_602_i4.mono (by decide +kernel) +theorem row_works_602 : Template HasSnaky 16 required_602 envelope_602 := by + refine compose HasSnaky 15 childrenC_602 childrenD_602 children_work_602 (6, 7) + required_602 envelope_602 pivot_mem_602 child_required_sub_602 child_envelope_sub_602 ?_ + intro b hb + exact common_sub_602 (mem_commonEnvelope childrenD_602 b hb) +def required_627_i0 : Finset Cell := ⟨(([(3, 4), (5, 4), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627_i0 : Finset Cell := ⟨(([(2, 5), (3, 4), (3, 5), (4, 4), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 3), (7, 5), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627_i0 : Fin 2 → Finset Cell := ![(placed21 4 (3, 4) required_5), (placed21 2 (7, 2) required_472)] +def childrenD_627_i0 : Fin 2 → Finset Cell := ![(placed21 4 (3, 4) envelope_5), (placed21 2 (7, 2) envelope_472)] +theorem common_sub_627_i0 : commonEnvelope childrenD_627_i0 ⊆ insert (4, 4) required_627_i0 := by decide +kernel +theorem child_required_sub_627_i0 : ∀ j, childrenC_627_i0 j ⊆ insert (4, 4) required_627_i0 := by decide +kernel +theorem child_envelope_sub_627_i0 : ∀ j, childrenD_627_i0 j ⊆ envelope_627_i0 := by decide +kernel +theorem pivot_mem_627_i0 : (4, 4) ∈ envelope_627_i0 := by decide +kernel +theorem children_work_627_i0 : ∀ j, Template HasSnaky 7 (childrenC_627_i0 j) (childrenD_627_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 4 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_472 2 (7, 2)).mono (by decide +kernel) +theorem row_works_627_i0 : Template HasSnaky 8 required_627_i0 envelope_627_i0 := by + refine compose HasSnaky 7 childrenC_627_i0 childrenD_627_i0 children_work_627_i0 (4, 4) + required_627_i0 envelope_627_i0 pivot_mem_627_i0 child_required_sub_627_i0 child_envelope_sub_627_i0 ?_ + intro b hb + exact common_sub_627_i0 (mem_commonEnvelope childrenD_627_i0 b hb) +def required_627_i3 : Finset Cell := ⟨(([(3, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627_i3 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627_i3 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) required_38), (placed21 6 (6, 7) required_205)] +def childrenD_627_i3 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) envelope_38), (placed21 6 (6, 7) envelope_205)] +theorem common_sub_627_i3 : commonEnvelope childrenD_627_i3 ⊆ insert (5, 3) required_627_i3 := by decide +kernel +theorem child_required_sub_627_i3 : ∀ j, childrenC_627_i3 j ⊆ insert (5, 3) required_627_i3 := by decide +kernel +theorem child_envelope_sub_627_i3 : ∀ j, childrenD_627_i3 j ⊆ envelope_627_i3 := by decide +kernel +theorem pivot_mem_627_i3 : (5, 3) ∈ envelope_627_i3 := by decide +kernel +theorem children_work_627_i3 : ∀ j, Template HasSnaky 3 (childrenC_627_i3 j) (childrenD_627_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_38 7 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_205 6 (6, 7)).mono (by decide +kernel) +theorem row_works_627_i3 : Template HasSnaky 4 required_627_i3 envelope_627_i3 := by + refine compose HasSnaky 3 childrenC_627_i3 childrenD_627_i3 children_work_627_i3 (5, 3) + required_627_i3 envelope_627_i3 pivot_mem_627_i3 child_required_sub_627_i3 child_envelope_sub_627_i3 ?_ + intro b hb + exact common_sub_627_i3 (mem_commonEnvelope childrenD_627_i3 b hb) +def required_627_i2 : Finset Cell := ⟨(([(3, 3), (5, 4), (5, 6), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627_i2 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627_i2 : Fin 2 → Finset Cell := ![(placed21 3 (5, 7) required_0), required_627_i3] +def childrenD_627_i2 : Fin 2 → Finset Cell := ![(placed21 3 (5, 7) envelope_0), envelope_627_i3] +theorem common_sub_627_i2 : commonEnvelope childrenD_627_i2 ⊆ insert (5, 5) required_627_i2 := by decide +kernel +theorem child_required_sub_627_i2 : ∀ j, childrenC_627_i2 j ⊆ insert (5, 5) required_627_i2 := by decide +kernel +theorem child_envelope_sub_627_i2 : ∀ j, childrenD_627_i2 j ⊆ envelope_627_i2 := by decide +kernel +theorem pivot_mem_627_i2 : (5, 5) ∈ envelope_627_i2 := by decide +kernel +theorem children_work_627_i2 : ∀ j, Template HasSnaky 4 (childrenC_627_i2 j) (childrenD_627_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (5, 7)).mono (by decide +kernel) + · exact row_works_627_i3.mono (by decide +kernel) +theorem row_works_627_i2 : Template HasSnaky 5 required_627_i2 envelope_627_i2 := by + refine compose HasSnaky 4 childrenC_627_i2 childrenD_627_i2 children_work_627_i2 (5, 5) + required_627_i2 envelope_627_i2 pivot_mem_627_i2 child_required_sub_627_i2 child_envelope_sub_627_i2 ?_ + intro b hb + exact common_sub_627_i2 (mem_commonEnvelope childrenD_627_i2 b hb) +def required_627_i5 : Finset Cell := ⟨(([(3, 3), (5, 4), (5, 5), (5, 6), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627_i5 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 5), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 4), (6, 6), (6, 7), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627_i5 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) required_38), (placed21 3 (3, 7) required_179)] +def childrenD_627_i5 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) envelope_38), (placed21 3 (3, 7) envelope_179)] +theorem common_sub_627_i5 : commonEnvelope childrenD_627_i5 ⊆ insert (5, 3) required_627_i5 := by decide +kernel +theorem child_required_sub_627_i5 : ∀ j, childrenC_627_i5 j ⊆ insert (5, 3) required_627_i5 := by decide +kernel +theorem child_envelope_sub_627_i5 : ∀ j, childrenD_627_i5 j ⊆ envelope_627_i5 := by decide +kernel +theorem pivot_mem_627_i5 : (5, 3) ∈ envelope_627_i5 := by decide +kernel +theorem children_work_627_i5 : ∀ j, Template HasSnaky 5 (childrenC_627_i5 j) (childrenD_627_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_38 7 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_179 3 (3, 7)).mono (by decide +kernel) +theorem row_works_627_i5 : Template HasSnaky 6 required_627_i5 envelope_627_i5 := by + refine compose HasSnaky 5 childrenC_627_i5 childrenD_627_i5 children_work_627_i5 (5, 3) + required_627_i5 envelope_627_i5 pivot_mem_627_i5 child_required_sub_627_i5 child_envelope_sub_627_i5 ?_ + intro b hb + exact common_sub_627_i5 (mem_commonEnvelope childrenD_627_i5 b hb) +def required_627_i4 : Finset Cell := ⟨(([(3, 3), (5, 4), (5, 6), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627_i4 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 5), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 6), (6, 7), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627_i4 : Fin 2 → Finset Cell := ![(placed21 3 (5, 7) required_0), required_627_i5] +def childrenD_627_i4 : Fin 2 → Finset Cell := ![(placed21 3 (5, 7) envelope_0), envelope_627_i5] +theorem common_sub_627_i4 : commonEnvelope childrenD_627_i4 ⊆ insert (5, 5) required_627_i4 := by decide +kernel +theorem child_required_sub_627_i4 : ∀ j, childrenC_627_i4 j ⊆ insert (5, 5) required_627_i4 := by decide +kernel +theorem child_envelope_sub_627_i4 : ∀ j, childrenD_627_i4 j ⊆ envelope_627_i4 := by decide +kernel +theorem pivot_mem_627_i4 : (5, 5) ∈ envelope_627_i4 := by decide +kernel +theorem children_work_627_i4 : ∀ j, Template HasSnaky 6 (childrenC_627_i4 j) (childrenD_627_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (5, 7)).mono (by decide +kernel) + · exact row_works_627_i5.mono (by decide +kernel) +theorem row_works_627_i4 : Template HasSnaky 7 required_627_i4 envelope_627_i4 := by + refine compose HasSnaky 6 childrenC_627_i4 childrenD_627_i4 children_work_627_i4 (5, 5) + required_627_i4 envelope_627_i4 pivot_mem_627_i4 child_required_sub_627_i4 child_envelope_sub_627_i4 ?_ + intro b hb + exact common_sub_627_i4 (mem_commonEnvelope childrenD_627_i4 b hb) +def required_627_i6 : Finset Cell := ⟨(([(5, 4), (5, 6), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627_i6 : Finset Cell := ⟨(([(0, 7), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (4, 6), (4, 7), (4, 8), (4, 9), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 5), (9, 6), (9, 7), (9, 8), (10, 5), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627_i6 : Fin 6 → Finset Cell := ![(placed21 2 (6, 3) required_50), (placed21 2 (6, 3) required_97), (placed21 0 (5, 3) required_98), (placed21 4 (4, 8) required_454), (placed21 1 (4, 4) required_455), (placed21 5 (10, 3) required_624)] +def childrenD_627_i6 : Fin 6 → Finset Cell := ![(placed21 2 (6, 3) envelope_50), (placed21 2 (6, 3) envelope_97), (placed21 0 (5, 3) envelope_98), (placed21 4 (4, 8) envelope_454), (placed21 1 (4, 4) envelope_455), (placed21 5 (10, 3) envelope_624)] +theorem common_sub_627_i6 : commonEnvelope childrenD_627_i6 ⊆ insert (5, 7) required_627_i6 := by decide +kernel +theorem child_required_sub_627_i6 : ∀ j, childrenC_627_i6 j ⊆ insert (5, 7) required_627_i6 := by decide +kernel +theorem child_envelope_sub_627_i6 : ∀ j, childrenD_627_i6 j ⊆ envelope_627_i6 := by decide +kernel +theorem pivot_mem_627_i6 : (5, 7) ∈ envelope_627_i6 := by decide +kernel +theorem children_work_627_i6 : ∀ j, Template HasSnaky 11 (childrenC_627_i6 j) (childrenD_627_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_50 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_97 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_98 0 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_454 4 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_455 1 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_624 5 (10, 3)).mono (by decide +kernel) +theorem row_works_627_i6 : Template HasSnaky 12 required_627_i6 envelope_627_i6 := by + refine compose HasSnaky 11 childrenC_627_i6 childrenD_627_i6 children_work_627_i6 (5, 7) + required_627_i6 envelope_627_i6 pivot_mem_627_i6 child_required_sub_627_i6 child_envelope_sub_627_i6 ?_ + intro b hb + exact common_sub_627_i6 (mem_commonEnvelope childrenD_627_i6 b hb) +def required_627_i8 : Finset Cell := ⟨(([(3, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627_i8 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 2), (4, 3), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 6), (7, 7), (8, 6), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627_i8 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) required_38), (placed21 0 (4, 2) required_413)] +def childrenD_627_i8 : Fin 2 → Finset Cell := ![(placed21 7 (6, 6) envelope_38), (placed21 0 (4, 2) envelope_413)] +theorem common_sub_627_i8 : commonEnvelope childrenD_627_i8 ⊆ insert (5, 3) required_627_i8 := by decide +kernel +theorem child_required_sub_627_i8 : ∀ j, childrenC_627_i8 j ⊆ insert (5, 3) required_627_i8 := by decide +kernel +theorem child_envelope_sub_627_i8 : ∀ j, childrenD_627_i8 j ⊆ envelope_627_i8 := by decide +kernel +theorem pivot_mem_627_i8 : (5, 3) ∈ envelope_627_i8 := by decide +kernel +theorem children_work_627_i8 : ∀ j, Template HasSnaky 5 (childrenC_627_i8 j) (childrenD_627_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_38 7 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_413 0 (4, 2)).mono (by decide +kernel) +theorem row_works_627_i8 : Template HasSnaky 6 required_627_i8 envelope_627_i8 := by + refine compose HasSnaky 5 childrenC_627_i8 childrenD_627_i8 children_work_627_i8 (5, 3) + required_627_i8 envelope_627_i8 pivot_mem_627_i8 child_required_sub_627_i8 child_envelope_sub_627_i8 ?_ + intro b hb + exact common_sub_627_i8 (mem_commonEnvelope childrenD_627_i8 b hb) +def required_627_i7 : Finset Cell := ⟨(([(3, 3), (5, 4), (5, 6), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627_i7 : Finset Cell := ⟨(([(2, 3), (3, 3), (4, 2), (4, 3), (4, 5), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 6), (7, 7), (8, 6), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627_i7 : Fin 2 → Finset Cell := ![(placed21 3 (5, 7) required_0), required_627_i8] +def childrenD_627_i7 : Fin 2 → Finset Cell := ![(placed21 3 (5, 7) envelope_0), envelope_627_i8] +theorem common_sub_627_i7 : commonEnvelope childrenD_627_i7 ⊆ insert (5, 5) required_627_i7 := by decide +kernel +theorem child_required_sub_627_i7 : ∀ j, childrenC_627_i7 j ⊆ insert (5, 5) required_627_i7 := by decide +kernel +theorem child_envelope_sub_627_i7 : ∀ j, childrenD_627_i7 j ⊆ envelope_627_i7 := by decide +kernel +theorem pivot_mem_627_i7 : (5, 5) ∈ envelope_627_i7 := by decide +kernel +theorem children_work_627_i7 : ∀ j, Template HasSnaky 6 (childrenC_627_i7 j) (childrenD_627_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 3 (5, 7)).mono (by decide +kernel) + · exact row_works_627_i8.mono (by decide +kernel) +theorem row_works_627_i7 : Template HasSnaky 7 required_627_i7 envelope_627_i7 := by + refine compose HasSnaky 6 childrenC_627_i7 childrenD_627_i7 children_work_627_i7 (5, 5) + required_627_i7 envelope_627_i7 pivot_mem_627_i7 child_required_sub_627_i7 child_envelope_sub_627_i7 ?_ + intro b hb + exact common_sub_627_i7 (mem_commonEnvelope childrenD_627_i7 b hb) +def required_627_i9 : Finset Cell := ⟨(([(5, 4), (5, 6), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627_i9 : Finset Cell := ⟨(([(2, 5), (2, 6), (2, 7), (3, 5), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 5), (10, 6), (10, 7), (11, 5), (11, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627_i9 : Fin 4 → Finset Cell := ![(placed21 5 (9, 3) required_59), (placed21 2 (6, 2) required_105), (placed21 3 (2, 7) required_323), (placed21 1 (2, 5) required_603)] +def childrenD_627_i9 : Fin 4 → Finset Cell := ![(placed21 5 (9, 3) envelope_59), (placed21 2 (6, 2) envelope_105), (placed21 3 (2, 7) envelope_323), (placed21 1 (2, 5) envelope_603)] +theorem common_sub_627_i9 : commonEnvelope childrenD_627_i9 ⊆ insert (6, 6) required_627_i9 := by decide +kernel +theorem child_required_sub_627_i9 : ∀ j, childrenC_627_i9 j ⊆ insert (6, 6) required_627_i9 := by decide +kernel +theorem child_envelope_sub_627_i9 : ∀ j, childrenD_627_i9 j ⊆ envelope_627_i9 := by decide +kernel +theorem pivot_mem_627_i9 : (6, 6) ∈ envelope_627_i9 := by decide +kernel +theorem children_work_627_i9 : ∀ j, Template HasSnaky 13 (childrenC_627_i9 j) (childrenD_627_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_59 5 (9, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_105 2 (6, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_323 3 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_603 1 (2, 5)).mono (by decide +kernel) +theorem row_works_627_i9 : Template HasSnaky 14 required_627_i9 envelope_627_i9 := by + refine compose HasSnaky 13 childrenC_627_i9 childrenD_627_i9 children_work_627_i9 (6, 6) + required_627_i9 envelope_627_i9 pivot_mem_627_i9 child_required_sub_627_i9 child_envelope_sub_627_i9 ?_ + intro b hb + exact common_sub_627_i9 (mem_commonEnvelope childrenD_627_i9 b hb) +def required_627_i1 : Finset Cell := ⟨(([(3, 3), (5, 4), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627_i1 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 5), (1, 6), (1, 7), (2, 3), (2, 5), (2, 6), (2, 7), (3, 3), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 2), (7, 3), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 5), (10, 6), (10, 7), (11, 5), (11, 6), (11, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627_i1 : Fin 6 → Finset Cell := ![required_627_i2, required_627_i4, required_627_i6, (placed21 1 (0, 1) required_626), required_627_i7, required_627_i9] +def childrenD_627_i1 : Fin 6 → Finset Cell := ![envelope_627_i2, envelope_627_i4, envelope_627_i6, (placed21 1 (0, 1) envelope_626), envelope_627_i7, envelope_627_i9] +theorem common_sub_627_i1 : commonEnvelope childrenD_627_i1 ⊆ insert (5, 6) required_627_i1 := by decide +kernel +theorem child_required_sub_627_i1 : ∀ j, childrenC_627_i1 j ⊆ insert (5, 6) required_627_i1 := by decide +kernel +theorem child_envelope_sub_627_i1 : ∀ j, childrenD_627_i1 j ⊆ envelope_627_i1 := by decide +kernel +theorem pivot_mem_627_i1 : (5, 6) ∈ envelope_627_i1 := by decide +kernel +theorem children_work_627_i1 : ∀ j, Template HasSnaky 14 (childrenC_627_i1 j) (childrenD_627_i1 j) := by + intro j + fin_cases j + · exact row_works_627_i2.mono (by decide +kernel) + · exact row_works_627_i4.mono (by decide +kernel) + · exact row_works_627_i6.mono (by decide +kernel) + · exact (placed21_template row_works_626 1 (0, 1)).mono (by decide +kernel) + · exact row_works_627_i7.mono (by decide +kernel) + · exact row_works_627_i9.mono (by decide +kernel) +theorem row_works_627_i1 : Template HasSnaky 15 required_627_i1 envelope_627_i1 := by + refine compose HasSnaky 14 childrenC_627_i1 childrenD_627_i1 children_work_627_i1 (5, 6) + required_627_i1 envelope_627_i1 pivot_mem_627_i1 child_required_sub_627_i1 child_envelope_sub_627_i1 ?_ + intro b hb + exact common_sub_627_i1 (mem_commonEnvelope childrenD_627_i1 b hb) +def required_627 : Finset Cell := ⟨(([(3, 3), (3, 4), (6, 3), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_627 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 5), (1, 6), (1, 7), (2, 3), (2, 5), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 2), (7, 3), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (10, 5), (10, 6), (10, 7), (11, 5), (11, 6), (11, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_627 : Fin 4 → Finset Cell := ![(placed21 7 (7, 4) required_34), (placed21 0 (2, 2) required_478), required_627_i0, required_627_i1] +def childrenD_627 : Fin 4 → Finset Cell := ![(placed21 7 (7, 4) envelope_34), (placed21 0 (2, 2) envelope_478), envelope_627_i0, envelope_627_i1] +theorem common_sub_627 : commonEnvelope childrenD_627 ⊆ insert (5, 4) required_627 := by decide +kernel +theorem child_required_sub_627 : ∀ j, childrenC_627 j ⊆ insert (5, 4) required_627 := by decide +kernel +theorem child_envelope_sub_627 : ∀ j, childrenD_627 j ⊆ envelope_627 := by decide +kernel +theorem pivot_mem_627 : (5, 4) ∈ envelope_627 := by decide +kernel +theorem children_work_627 : ∀ j, Template HasSnaky 15 (childrenC_627 j) (childrenD_627 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_34 7 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_478 0 (2, 2)).mono (by decide +kernel) + · exact row_works_627_i0.mono (by decide +kernel) + · exact row_works_627_i1.mono (by decide +kernel) +theorem row_works_627 : Template HasSnaky 16 required_627 envelope_627 := by + refine compose HasSnaky 15 childrenC_627 childrenD_627 children_work_627 (5, 4) + required_627 envelope_627 pivot_mem_627 child_required_sub_627 child_envelope_sub_627 ?_ + intro b hb + exact common_sub_627 (mem_commonEnvelope childrenD_627 b hb) +def height_602_i1 : ℕ := 8 +def childrenH_602_i1 : Fin 2 → ℕ := ![height_320, height_496] +theorem height_exact_602_i1 : height_602_i1 = 1 + Finset.univ.sup childrenH_602_i1 := by decide +kernel +theorem required_origin_602_i1 : ∀ x ∈ required_602_i1, + (∃ j, x ∈ childrenC_602_i1 j) ∨ ∀ j, x ∈ childrenD_602_i1 j := by decide +kernel +theorem required_exact_602_i1 : required_602_i1 = + ((Finset.univ.biUnion childrenC_602_i1) ∪ commonEnvelope childrenD_602_i1).erase (5, 8) := by + exact required_eq_combination childrenC_602_i1 childrenD_602_i1 (5, 8) required_602_i1 + (by decide +kernel) child_required_sub_602_i1 common_sub_602_i1 required_origin_602_i1 +theorem envelope_origin_602_i1 : ∀ x ∈ envelope_602_i1, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_602_i1 j := by decide +kernel +theorem envelope_exact_602_i1 : envelope_602_i1 = + insert (5, 8) (Finset.univ.biUnion childrenD_602_i1) := by + exact envelope_eq_combination childrenD_602_i1 (5, 8) envelope_602_i1 + pivot_mem_602_i1 child_envelope_sub_602_i1 envelope_origin_602_i1 +def checked_602_i1 : CheckedCard where + required := required_602_i1 + envelope := envelope_602_i1 + height := height_602_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_602_i1 +def height_602_i0 : ℕ := 14 +def childrenH_602_i0 : Fin 4 → ℕ := ![height_59, height_497, height_602_i1, height_555] +theorem height_exact_602_i0 : height_602_i0 = 1 + Finset.univ.sup childrenH_602_i0 := by decide +kernel +theorem required_origin_602_i0 : ∀ x ∈ required_602_i0, + (∃ j, x ∈ childrenC_602_i0 j) ∨ ∀ j, x ∈ childrenD_602_i0 j := by decide +kernel +theorem required_exact_602_i0 : required_602_i0 = + ((Finset.univ.biUnion childrenC_602_i0) ∪ commonEnvelope childrenD_602_i0).erase (6, 8) := by + exact required_eq_combination childrenC_602_i0 childrenD_602_i0 (6, 8) required_602_i0 + (by decide +kernel) child_required_sub_602_i0 common_sub_602_i0 required_origin_602_i0 +theorem envelope_origin_602_i0 : ∀ x ∈ envelope_602_i0, + x = (6, 8) ∨ ∃ j, x ∈ childrenD_602_i0 j := by decide +kernel +theorem envelope_exact_602_i0 : envelope_602_i0 = + insert (6, 8) (Finset.univ.biUnion childrenD_602_i0) := by + exact envelope_eq_combination childrenD_602_i0 (6, 8) envelope_602_i0 + pivot_mem_602_i0 child_envelope_sub_602_i0 envelope_origin_602_i0 +def checked_602_i0 : CheckedCard where + required := required_602_i0 + envelope := envelope_602_i0 + height := height_602_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_602_i0 +def height_602_i3 : ℕ := 11 +def childrenH_602_i3 : Fin 2 → ℕ := ![height_2, height_545] +theorem height_exact_602_i3 : height_602_i3 = 1 + Finset.univ.sup childrenH_602_i3 := by decide +kernel +theorem required_origin_602_i3 : ∀ x ∈ required_602_i3, + (∃ j, x ∈ childrenC_602_i3 j) ∨ ∀ j, x ∈ childrenD_602_i3 j := by decide +kernel +theorem required_exact_602_i3 : required_602_i3 = + ((Finset.univ.biUnion childrenC_602_i3) ∪ commonEnvelope childrenD_602_i3).erase (6, 8) := by + exact required_eq_combination childrenC_602_i3 childrenD_602_i3 (6, 8) required_602_i3 + (by decide +kernel) child_required_sub_602_i3 common_sub_602_i3 required_origin_602_i3 +theorem envelope_origin_602_i3 : ∀ x ∈ envelope_602_i3, + x = (6, 8) ∨ ∃ j, x ∈ childrenD_602_i3 j := by decide +kernel +theorem envelope_exact_602_i3 : envelope_602_i3 = + insert (6, 8) (Finset.univ.biUnion childrenD_602_i3) := by + exact envelope_eq_combination childrenD_602_i3 (6, 8) envelope_602_i3 + pivot_mem_602_i3 child_envelope_sub_602_i3 envelope_origin_602_i3 +def checked_602_i3 : CheckedCard where + required := required_602_i3 + envelope := envelope_602_i3 + height := height_602_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_602_i3 +def height_602_i2 : ℕ := 12 +def childrenH_602_i2 : Fin 4 → ℕ := ![height_107, height_163, height_556, height_602_i3] +theorem height_exact_602_i2 : height_602_i2 = 1 + Finset.univ.sup childrenH_602_i2 := by decide +kernel +theorem required_origin_602_i2 : ∀ x ∈ required_602_i2, + (∃ j, x ∈ childrenC_602_i2 j) ∨ ∀ j, x ∈ childrenD_602_i2 j := by decide +kernel +theorem required_exact_602_i2 : required_602_i2 = + ((Finset.univ.biUnion childrenC_602_i2) ∪ commonEnvelope childrenD_602_i2).erase (7, 7) := by + exact required_eq_combination childrenC_602_i2 childrenD_602_i2 (7, 7) required_602_i2 + (by decide +kernel) child_required_sub_602_i2 common_sub_602_i2 required_origin_602_i2 +theorem envelope_origin_602_i2 : ∀ x ∈ envelope_602_i2, + x = (7, 7) ∨ ∃ j, x ∈ childrenD_602_i2 j := by decide +kernel +theorem envelope_exact_602_i2 : envelope_602_i2 = + insert (7, 7) (Finset.univ.biUnion childrenD_602_i2) := by + exact envelope_eq_combination childrenD_602_i2 (7, 7) envelope_602_i2 + pivot_mem_602_i2 child_envelope_sub_602_i2 envelope_origin_602_i2 +def checked_602_i2 : CheckedCard where + required := required_602_i2 + envelope := envelope_602_i2 + height := height_602_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_602_i2 +def height_602_i6 : ℕ := 6 +def childrenH_602_i6 : Fin 2 → ℕ := ![height_157, height_383] +theorem height_exact_602_i6 : height_602_i6 = 1 + Finset.univ.sup childrenH_602_i6 := by decide +kernel +theorem required_origin_602_i6 : ∀ x ∈ required_602_i6, + (∃ j, x ∈ childrenC_602_i6 j) ∨ ∀ j, x ∈ childrenD_602_i6 j := by decide +kernel +theorem required_exact_602_i6 : required_602_i6 = + ((Finset.univ.biUnion childrenC_602_i6) ∪ commonEnvelope childrenD_602_i6).erase (6, 5) := by + exact required_eq_combination childrenC_602_i6 childrenD_602_i6 (6, 5) required_602_i6 + (by decide +kernel) child_required_sub_602_i6 common_sub_602_i6 required_origin_602_i6 +theorem envelope_origin_602_i6 : ∀ x ∈ envelope_602_i6, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_602_i6 j := by decide +kernel +theorem envelope_exact_602_i6 : envelope_602_i6 = + insert (6, 5) (Finset.univ.biUnion childrenD_602_i6) := by + exact envelope_eq_combination childrenD_602_i6 (6, 5) envelope_602_i6 + pivot_mem_602_i6 child_envelope_sub_602_i6 envelope_origin_602_i6 +def checked_602_i6 : CheckedCard where + required := required_602_i6 + envelope := envelope_602_i6 + height := height_602_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_602_i6 +def height_602_i7 : ℕ := 5 +def childrenH_602_i7 : Fin 2 → ℕ := ![height_18, height_381] +theorem height_exact_602_i7 : height_602_i7 = 1 + Finset.univ.sup childrenH_602_i7 := by decide +kernel +theorem required_origin_602_i7 : ∀ x ∈ required_602_i7, + (∃ j, x ∈ childrenC_602_i7 j) ∨ ∀ j, x ∈ childrenD_602_i7 j := by decide +kernel +theorem required_exact_602_i7 : required_602_i7 = + ((Finset.univ.biUnion childrenC_602_i7) ∪ commonEnvelope childrenD_602_i7).erase (6, 6) := by + exact required_eq_combination childrenC_602_i7 childrenD_602_i7 (6, 6) required_602_i7 + (by decide +kernel) child_required_sub_602_i7 common_sub_602_i7 required_origin_602_i7 +theorem envelope_origin_602_i7 : ∀ x ∈ envelope_602_i7, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_602_i7 j := by decide +kernel +theorem envelope_exact_602_i7 : envelope_602_i7 = + insert (6, 6) (Finset.univ.biUnion childrenD_602_i7) := by + exact envelope_eq_combination childrenD_602_i7 (6, 6) envelope_602_i7 + pivot_mem_602_i7 child_envelope_sub_602_i7 envelope_origin_602_i7 +def checked_602_i7 : CheckedCard where + required := required_602_i7 + envelope := envelope_602_i7 + height := height_602_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_602_i7 +def height_602_i8 : ℕ := 5 +def childrenH_602_i8 : Fin 2 → ℕ := ![height_64, height_500] +theorem height_exact_602_i8 : height_602_i8 = 1 + Finset.univ.sup childrenH_602_i8 := by decide +kernel +theorem required_origin_602_i8 : ∀ x ∈ required_602_i8, + (∃ j, x ∈ childrenC_602_i8 j) ∨ ∀ j, x ∈ childrenD_602_i8 j := by decide +kernel +theorem required_exact_602_i8 : required_602_i8 = + ((Finset.univ.biUnion childrenC_602_i8) ∪ commonEnvelope childrenD_602_i8).erase (5, 7) := by + exact required_eq_combination childrenC_602_i8 childrenD_602_i8 (5, 7) required_602_i8 + (by decide +kernel) child_required_sub_602_i8 common_sub_602_i8 required_origin_602_i8 +theorem envelope_origin_602_i8 : ∀ x ∈ envelope_602_i8, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_602_i8 j := by decide +kernel +theorem envelope_exact_602_i8 : envelope_602_i8 = + insert (5, 7) (Finset.univ.biUnion childrenD_602_i8) := by + exact envelope_eq_combination childrenD_602_i8 (5, 7) envelope_602_i8 + pivot_mem_602_i8 child_envelope_sub_602_i8 envelope_origin_602_i8 +def checked_602_i8 : CheckedCard where + required := required_602_i8 + envelope := envelope_602_i8 + height := height_602_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_602_i8 +def height_602_i5 : ℕ := 12 +def childrenH_602_i5 : Fin 4 → ℕ := ![height_602_i6, height_602_i7, height_602_i8, height_601] +theorem height_exact_602_i5 : height_602_i5 = 1 + Finset.univ.sup childrenH_602_i5 := by decide +kernel +theorem required_origin_602_i5 : ∀ x ∈ required_602_i5, + (∃ j, x ∈ childrenC_602_i5 j) ∨ ∀ j, x ∈ childrenD_602_i5 j := by decide +kernel +theorem required_exact_602_i5 : required_602_i5 = + ((Finset.univ.biUnion childrenC_602_i5) ∪ commonEnvelope childrenD_602_i5).erase (5, 5) := by + exact required_eq_combination childrenC_602_i5 childrenD_602_i5 (5, 5) required_602_i5 + (by decide +kernel) child_required_sub_602_i5 common_sub_602_i5 required_origin_602_i5 +theorem envelope_origin_602_i5 : ∀ x ∈ envelope_602_i5, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_602_i5 j := by decide +kernel +theorem envelope_exact_602_i5 : envelope_602_i5 = + insert (5, 5) (Finset.univ.biUnion childrenD_602_i5) := by + exact envelope_eq_combination childrenD_602_i5 (5, 5) envelope_602_i5 + pivot_mem_602_i5 child_envelope_sub_602_i5 envelope_origin_602_i5 +def checked_602_i5 : CheckedCard where + required := required_602_i5 + envelope := envelope_602_i5 + height := height_602_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_602_i5 +def height_602_i4 : ℕ := 13 +def childrenH_602_i4 : Fin 4 → ℕ := ![height_119, height_497, height_498, height_602_i5] +theorem height_exact_602_i4 : height_602_i4 = 1 + Finset.univ.sup childrenH_602_i4 := by decide +kernel +theorem required_origin_602_i4 : ∀ x ∈ required_602_i4, + (∃ j, x ∈ childrenC_602_i4 j) ∨ ∀ j, x ∈ childrenD_602_i4 j := by decide +kernel +theorem required_exact_602_i4 : required_602_i4 = + ((Finset.univ.biUnion childrenC_602_i4) ∪ commonEnvelope childrenD_602_i4).erase (6, 8) := by + exact required_eq_combination childrenC_602_i4 childrenD_602_i4 (6, 8) required_602_i4 + (by decide +kernel) child_required_sub_602_i4 common_sub_602_i4 required_origin_602_i4 +theorem envelope_origin_602_i4 : ∀ x ∈ envelope_602_i4, + x = (6, 8) ∨ ∃ j, x ∈ childrenD_602_i4 j := by decide +kernel +theorem envelope_exact_602_i4 : envelope_602_i4 = + insert (6, 8) (Finset.univ.biUnion childrenD_602_i4) := by + exact envelope_eq_combination childrenD_602_i4 (6, 8) envelope_602_i4 + pivot_mem_602_i4 child_envelope_sub_602_i4 envelope_origin_602_i4 +def checked_602_i4 : CheckedCard where + required := required_602_i4 + envelope := envelope_602_i4 + height := height_602_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_602_i4 +def height_602 : ℕ := 16 +def childrenH_602 : Fin 12 → ℕ := ![height_553, height_602_i0, height_602_i2, height_557, height_564, height_568, height_573, height_574, height_583, height_598, height_599, height_602_i4] +theorem height_exact_602 : height_602 = 1 + Finset.univ.sup childrenH_602 := by decide +kernel +theorem required_origin_602 : ∀ x ∈ required_602, + (∃ j, x ∈ childrenC_602 j) ∨ ∀ j, x ∈ childrenD_602 j := by decide +kernel +theorem required_exact_602 : required_602 = + ((Finset.univ.biUnion childrenC_602) ∪ commonEnvelope childrenD_602).erase (6, 7) := by + exact required_eq_combination childrenC_602 childrenD_602 (6, 7) required_602 + (by decide +kernel) child_required_sub_602 common_sub_602 required_origin_602 +theorem envelope_origin_602 : ∀ x ∈ envelope_602, + x = (6, 7) ∨ ∃ j, x ∈ childrenD_602 j := by decide +kernel +theorem envelope_exact_602 : envelope_602 = + insert (6, 7) (Finset.univ.biUnion childrenD_602) := by + exact envelope_eq_combination childrenD_602 (6, 7) envelope_602 + pivot_mem_602 child_envelope_sub_602 envelope_origin_602 +def checked_602 : CheckedCard where + required := required_602 + envelope := envelope_602 + height := height_602 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_602 +def height_627_i0 : ℕ := 8 +def childrenH_627_i0 : Fin 2 → ℕ := ![height_5, height_472] +theorem height_exact_627_i0 : height_627_i0 = 1 + Finset.univ.sup childrenH_627_i0 := by decide +kernel +theorem required_origin_627_i0 : ∀ x ∈ required_627_i0, + (∃ j, x ∈ childrenC_627_i0 j) ∨ ∀ j, x ∈ childrenD_627_i0 j := by decide +kernel +theorem required_exact_627_i0 : required_627_i0 = + ((Finset.univ.biUnion childrenC_627_i0) ∪ commonEnvelope childrenD_627_i0).erase (4, 4) := by + exact required_eq_combination childrenC_627_i0 childrenD_627_i0 (4, 4) required_627_i0 + (by decide +kernel) child_required_sub_627_i0 common_sub_627_i0 required_origin_627_i0 +theorem envelope_origin_627_i0 : ∀ x ∈ envelope_627_i0, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_627_i0 j := by decide +kernel +theorem envelope_exact_627_i0 : envelope_627_i0 = + insert (4, 4) (Finset.univ.biUnion childrenD_627_i0) := by + exact envelope_eq_combination childrenD_627_i0 (4, 4) envelope_627_i0 + pivot_mem_627_i0 child_envelope_sub_627_i0 envelope_origin_627_i0 +def checked_627_i0 : CheckedCard where + required := required_627_i0 + envelope := envelope_627_i0 + height := height_627_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627_i0 +def height_627_i3 : ℕ := 4 +def childrenH_627_i3 : Fin 2 → ℕ := ![height_38, height_205] +theorem height_exact_627_i3 : height_627_i3 = 1 + Finset.univ.sup childrenH_627_i3 := by decide +kernel +theorem required_origin_627_i3 : ∀ x ∈ required_627_i3, + (∃ j, x ∈ childrenC_627_i3 j) ∨ ∀ j, x ∈ childrenD_627_i3 j := by decide +kernel +theorem required_exact_627_i3 : required_627_i3 = + ((Finset.univ.biUnion childrenC_627_i3) ∪ commonEnvelope childrenD_627_i3).erase (5, 3) := by + exact required_eq_combination childrenC_627_i3 childrenD_627_i3 (5, 3) required_627_i3 + (by decide +kernel) child_required_sub_627_i3 common_sub_627_i3 required_origin_627_i3 +theorem envelope_origin_627_i3 : ∀ x ∈ envelope_627_i3, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_627_i3 j := by decide +kernel +theorem envelope_exact_627_i3 : envelope_627_i3 = + insert (5, 3) (Finset.univ.biUnion childrenD_627_i3) := by + exact envelope_eq_combination childrenD_627_i3 (5, 3) envelope_627_i3 + pivot_mem_627_i3 child_envelope_sub_627_i3 envelope_origin_627_i3 +def checked_627_i3 : CheckedCard where + required := required_627_i3 + envelope := envelope_627_i3 + height := height_627_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627_i3 +def height_627_i2 : ℕ := 5 +def childrenH_627_i2 : Fin 2 → ℕ := ![height_0, height_627_i3] +theorem height_exact_627_i2 : height_627_i2 = 1 + Finset.univ.sup childrenH_627_i2 := by decide +kernel +theorem required_origin_627_i2 : ∀ x ∈ required_627_i2, + (∃ j, x ∈ childrenC_627_i2 j) ∨ ∀ j, x ∈ childrenD_627_i2 j := by decide +kernel +theorem required_exact_627_i2 : required_627_i2 = + ((Finset.univ.biUnion childrenC_627_i2) ∪ commonEnvelope childrenD_627_i2).erase (5, 5) := by + exact required_eq_combination childrenC_627_i2 childrenD_627_i2 (5, 5) required_627_i2 + (by decide +kernel) child_required_sub_627_i2 common_sub_627_i2 required_origin_627_i2 +theorem envelope_origin_627_i2 : ∀ x ∈ envelope_627_i2, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_627_i2 j := by decide +kernel +theorem envelope_exact_627_i2 : envelope_627_i2 = + insert (5, 5) (Finset.univ.biUnion childrenD_627_i2) := by + exact envelope_eq_combination childrenD_627_i2 (5, 5) envelope_627_i2 + pivot_mem_627_i2 child_envelope_sub_627_i2 envelope_origin_627_i2 +def checked_627_i2 : CheckedCard where + required := required_627_i2 + envelope := envelope_627_i2 + height := height_627_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627_i2 +def height_627_i5 : ℕ := 6 +def childrenH_627_i5 : Fin 2 → ℕ := ![height_38, height_179] +theorem height_exact_627_i5 : height_627_i5 = 1 + Finset.univ.sup childrenH_627_i5 := by decide +kernel +theorem required_origin_627_i5 : ∀ x ∈ required_627_i5, + (∃ j, x ∈ childrenC_627_i5 j) ∨ ∀ j, x ∈ childrenD_627_i5 j := by decide +kernel +theorem required_exact_627_i5 : required_627_i5 = + ((Finset.univ.biUnion childrenC_627_i5) ∪ commonEnvelope childrenD_627_i5).erase (5, 3) := by + exact required_eq_combination childrenC_627_i5 childrenD_627_i5 (5, 3) required_627_i5 + (by decide +kernel) child_required_sub_627_i5 common_sub_627_i5 required_origin_627_i5 +theorem envelope_origin_627_i5 : ∀ x ∈ envelope_627_i5, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_627_i5 j := by decide +kernel +theorem envelope_exact_627_i5 : envelope_627_i5 = + insert (5, 3) (Finset.univ.biUnion childrenD_627_i5) := by + exact envelope_eq_combination childrenD_627_i5 (5, 3) envelope_627_i5 + pivot_mem_627_i5 child_envelope_sub_627_i5 envelope_origin_627_i5 +def checked_627_i5 : CheckedCard where + required := required_627_i5 + envelope := envelope_627_i5 + height := height_627_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627_i5 +def height_627_i4 : ℕ := 7 +def childrenH_627_i4 : Fin 2 → ℕ := ![height_0, height_627_i5] +theorem height_exact_627_i4 : height_627_i4 = 1 + Finset.univ.sup childrenH_627_i4 := by decide +kernel +theorem required_origin_627_i4 : ∀ x ∈ required_627_i4, + (∃ j, x ∈ childrenC_627_i4 j) ∨ ∀ j, x ∈ childrenD_627_i4 j := by decide +kernel +theorem required_exact_627_i4 : required_627_i4 = + ((Finset.univ.biUnion childrenC_627_i4) ∪ commonEnvelope childrenD_627_i4).erase (5, 5) := by + exact required_eq_combination childrenC_627_i4 childrenD_627_i4 (5, 5) required_627_i4 + (by decide +kernel) child_required_sub_627_i4 common_sub_627_i4 required_origin_627_i4 +theorem envelope_origin_627_i4 : ∀ x ∈ envelope_627_i4, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_627_i4 j := by decide +kernel +theorem envelope_exact_627_i4 : envelope_627_i4 = + insert (5, 5) (Finset.univ.biUnion childrenD_627_i4) := by + exact envelope_eq_combination childrenD_627_i4 (5, 5) envelope_627_i4 + pivot_mem_627_i4 child_envelope_sub_627_i4 envelope_origin_627_i4 +def checked_627_i4 : CheckedCard where + required := required_627_i4 + envelope := envelope_627_i4 + height := height_627_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627_i4 +def height_627_i6 : ℕ := 12 +def childrenH_627_i6 : Fin 6 → ℕ := ![height_50, height_97, height_98, height_454, height_455, height_624] +theorem height_exact_627_i6 : height_627_i6 = 1 + Finset.univ.sup childrenH_627_i6 := by decide +kernel +theorem required_origin_627_i6 : ∀ x ∈ required_627_i6, + (∃ j, x ∈ childrenC_627_i6 j) ∨ ∀ j, x ∈ childrenD_627_i6 j := by decide +kernel +theorem required_exact_627_i6 : required_627_i6 = + ((Finset.univ.biUnion childrenC_627_i6) ∪ commonEnvelope childrenD_627_i6).erase (5, 7) := by + exact required_eq_combination childrenC_627_i6 childrenD_627_i6 (5, 7) required_627_i6 + (by decide +kernel) child_required_sub_627_i6 common_sub_627_i6 required_origin_627_i6 +theorem envelope_origin_627_i6 : ∀ x ∈ envelope_627_i6, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_627_i6 j := by decide +kernel +theorem envelope_exact_627_i6 : envelope_627_i6 = + insert (5, 7) (Finset.univ.biUnion childrenD_627_i6) := by + exact envelope_eq_combination childrenD_627_i6 (5, 7) envelope_627_i6 + pivot_mem_627_i6 child_envelope_sub_627_i6 envelope_origin_627_i6 +def checked_627_i6 : CheckedCard where + required := required_627_i6 + envelope := envelope_627_i6 + height := height_627_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627_i6 +def height_627_i8 : ℕ := 6 +def childrenH_627_i8 : Fin 2 → ℕ := ![height_38, height_413] +theorem height_exact_627_i8 : height_627_i8 = 1 + Finset.univ.sup childrenH_627_i8 := by decide +kernel +theorem required_origin_627_i8 : ∀ x ∈ required_627_i8, + (∃ j, x ∈ childrenC_627_i8 j) ∨ ∀ j, x ∈ childrenD_627_i8 j := by decide +kernel +theorem required_exact_627_i8 : required_627_i8 = + ((Finset.univ.biUnion childrenC_627_i8) ∪ commonEnvelope childrenD_627_i8).erase (5, 3) := by + exact required_eq_combination childrenC_627_i8 childrenD_627_i8 (5, 3) required_627_i8 + (by decide +kernel) child_required_sub_627_i8 common_sub_627_i8 required_origin_627_i8 +theorem envelope_origin_627_i8 : ∀ x ∈ envelope_627_i8, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_627_i8 j := by decide +kernel +theorem envelope_exact_627_i8 : envelope_627_i8 = + insert (5, 3) (Finset.univ.biUnion childrenD_627_i8) := by + exact envelope_eq_combination childrenD_627_i8 (5, 3) envelope_627_i8 + pivot_mem_627_i8 child_envelope_sub_627_i8 envelope_origin_627_i8 +def checked_627_i8 : CheckedCard where + required := required_627_i8 + envelope := envelope_627_i8 + height := height_627_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627_i8 +def height_627_i7 : ℕ := 7 +def childrenH_627_i7 : Fin 2 → ℕ := ![height_0, height_627_i8] +theorem height_exact_627_i7 : height_627_i7 = 1 + Finset.univ.sup childrenH_627_i7 := by decide +kernel +theorem required_origin_627_i7 : ∀ x ∈ required_627_i7, + (∃ j, x ∈ childrenC_627_i7 j) ∨ ∀ j, x ∈ childrenD_627_i7 j := by decide +kernel +theorem required_exact_627_i7 : required_627_i7 = + ((Finset.univ.biUnion childrenC_627_i7) ∪ commonEnvelope childrenD_627_i7).erase (5, 5) := by + exact required_eq_combination childrenC_627_i7 childrenD_627_i7 (5, 5) required_627_i7 + (by decide +kernel) child_required_sub_627_i7 common_sub_627_i7 required_origin_627_i7 +theorem envelope_origin_627_i7 : ∀ x ∈ envelope_627_i7, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_627_i7 j := by decide +kernel +theorem envelope_exact_627_i7 : envelope_627_i7 = + insert (5, 5) (Finset.univ.biUnion childrenD_627_i7) := by + exact envelope_eq_combination childrenD_627_i7 (5, 5) envelope_627_i7 + pivot_mem_627_i7 child_envelope_sub_627_i7 envelope_origin_627_i7 +def checked_627_i7 : CheckedCard where + required := required_627_i7 + envelope := envelope_627_i7 + height := height_627_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627_i7 +def height_627_i9 : ℕ := 14 +def childrenH_627_i9 : Fin 4 → ℕ := ![height_59, height_105, height_323, height_603] +theorem height_exact_627_i9 : height_627_i9 = 1 + Finset.univ.sup childrenH_627_i9 := by decide +kernel +theorem required_origin_627_i9 : ∀ x ∈ required_627_i9, + (∃ j, x ∈ childrenC_627_i9 j) ∨ ∀ j, x ∈ childrenD_627_i9 j := by decide +kernel +theorem required_exact_627_i9 : required_627_i9 = + ((Finset.univ.biUnion childrenC_627_i9) ∪ commonEnvelope childrenD_627_i9).erase (6, 6) := by + exact required_eq_combination childrenC_627_i9 childrenD_627_i9 (6, 6) required_627_i9 + (by decide +kernel) child_required_sub_627_i9 common_sub_627_i9 required_origin_627_i9 +theorem envelope_origin_627_i9 : ∀ x ∈ envelope_627_i9, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_627_i9 j := by decide +kernel +theorem envelope_exact_627_i9 : envelope_627_i9 = + insert (6, 6) (Finset.univ.biUnion childrenD_627_i9) := by + exact envelope_eq_combination childrenD_627_i9 (6, 6) envelope_627_i9 + pivot_mem_627_i9 child_envelope_sub_627_i9 envelope_origin_627_i9 +def checked_627_i9 : CheckedCard where + required := required_627_i9 + envelope := envelope_627_i9 + height := height_627_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627_i9 +def height_627_i1 : ℕ := 15 +def childrenH_627_i1 : Fin 6 → ℕ := ![height_627_i2, height_627_i4, height_627_i6, height_626, height_627_i7, height_627_i9] +theorem height_exact_627_i1 : height_627_i1 = 1 + Finset.univ.sup childrenH_627_i1 := by decide +kernel +theorem required_origin_627_i1 : ∀ x ∈ required_627_i1, + (∃ j, x ∈ childrenC_627_i1 j) ∨ ∀ j, x ∈ childrenD_627_i1 j := by decide +kernel +theorem required_exact_627_i1 : required_627_i1 = + ((Finset.univ.biUnion childrenC_627_i1) ∪ commonEnvelope childrenD_627_i1).erase (5, 6) := by + exact required_eq_combination childrenC_627_i1 childrenD_627_i1 (5, 6) required_627_i1 + (by decide +kernel) child_required_sub_627_i1 common_sub_627_i1 required_origin_627_i1 +theorem envelope_origin_627_i1 : ∀ x ∈ envelope_627_i1, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_627_i1 j := by decide +kernel +theorem envelope_exact_627_i1 : envelope_627_i1 = + insert (5, 6) (Finset.univ.biUnion childrenD_627_i1) := by + exact envelope_eq_combination childrenD_627_i1 (5, 6) envelope_627_i1 + pivot_mem_627_i1 child_envelope_sub_627_i1 envelope_origin_627_i1 +def checked_627_i1 : CheckedCard where + required := required_627_i1 + envelope := envelope_627_i1 + height := height_627_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627_i1 +def height_627 : ℕ := 16 +def childrenH_627 : Fin 4 → ℕ := ![height_34, height_478, height_627_i0, height_627_i1] +theorem height_exact_627 : height_627 = 1 + Finset.univ.sup childrenH_627 := by decide +kernel +theorem required_origin_627 : ∀ x ∈ required_627, + (∃ j, x ∈ childrenC_627 j) ∨ ∀ j, x ∈ childrenD_627 j := by decide +kernel +theorem required_exact_627 : required_627 = + ((Finset.univ.biUnion childrenC_627) ∪ commonEnvelope childrenD_627).erase (5, 4) := by + exact required_eq_combination childrenC_627 childrenD_627 (5, 4) required_627 + (by decide +kernel) child_required_sub_627 common_sub_627 required_origin_627 +theorem envelope_origin_627 : ∀ x ∈ envelope_627, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_627 j := by decide +kernel +theorem envelope_exact_627 : envelope_627 = + insert (5, 4) (Finset.univ.biUnion childrenD_627) := by + exact envelope_eq_combination childrenD_627 (5, 4) envelope_627 + pivot_mem_627 child_envelope_sub_627 envelope_origin_627 +def checked_627 : CheckedCard where + required := required_627 + envelope := envelope_627 + height := height_627 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_627 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part02.lean new file mode 100644 index 0000000..b568fad --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part02.lean @@ -0,0 +1,631 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_683_i0 : Finset Cell := ⟨(([(1, 4), (1, 5), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_683_i0 : Finset Cell := ⟨(([(0, 4), (0, 6), (1, 4), (1, 5), (1, 6), (2, 5), (2, 6), (3, 5), (4, 4), (4, 5), (5, 4), (5, 5), (6, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_683_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) required_5), (placed21 3 (0, 6) required_9)] +def childrenD_683_i0 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) envelope_5), (placed21 3 (0, 6) envelope_9)] +theorem common_sub_683_i0 : commonEnvelope childrenD_683_i0 ⊆ insert (2, 5) required_683_i0 := by decide +kernel +theorem child_required_sub_683_i0 : ∀ j, childrenC_683_i0 j ⊆ insert (2, 5) required_683_i0 := by decide +kernel +theorem child_envelope_sub_683_i0 : ∀ j, childrenD_683_i0 j ⊆ envelope_683_i0 := by decide +kernel +theorem pivot_mem_683_i0 : (2, 5) ∈ envelope_683_i0 := by decide +kernel +theorem children_work_683_i0 : ∀ j, Template HasSnaky 3 (childrenC_683_i0 j) (childrenD_683_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_9 3 (0, 6)).mono (by decide +kernel) +theorem row_works_683_i0 : Template HasSnaky 4 required_683_i0 envelope_683_i0 := by + refine compose HasSnaky 3 childrenC_683_i0 childrenD_683_i0 children_work_683_i0 (2, 5) + required_683_i0 envelope_683_i0 pivot_mem_683_i0 child_required_sub_683_i0 child_envelope_sub_683_i0 ?_ + intro b hb + exact common_sub_683_i0 (mem_commonEnvelope childrenD_683_i0 b hb) +def required_683_i1 : Finset Cell := ⟨(([(1, 4), (1, 5), (3, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_683_i1 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 5), (2, 5), (2, 6), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (6, 7), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_683_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) required_5), (placed21 0 (1, 2) required_604)] +def childrenD_683_i1 : Fin 2 → Finset Cell := ![(placed21 6 (4, 5) envelope_5), (placed21 0 (1, 2) envelope_604)] +theorem common_sub_683_i1 : commonEnvelope childrenD_683_i1 ⊆ insert (2, 5) required_683_i1 := by decide +kernel +theorem child_required_sub_683_i1 : ∀ j, childrenC_683_i1 j ⊆ insert (2, 5) required_683_i1 := by decide +kernel +theorem child_envelope_sub_683_i1 : ∀ j, childrenD_683_i1 j ⊆ envelope_683_i1 := by decide +kernel +theorem pivot_mem_683_i1 : (2, 5) ∈ envelope_683_i1 := by decide +kernel +theorem children_work_683_i1 : ∀ j, Template HasSnaky 8 (childrenC_683_i1 j) (childrenD_683_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 6 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_604 0 (1, 2)).mono (by decide +kernel) +theorem row_works_683_i1 : Template HasSnaky 9 required_683_i1 envelope_683_i1 := by + refine compose HasSnaky 8 childrenC_683_i1 childrenD_683_i1 children_work_683_i1 (2, 5) + required_683_i1 envelope_683_i1 pivot_mem_683_i1 child_required_sub_683_i1 child_envelope_sub_683_i1 ?_ + intro b hb + exact common_sub_683_i1 (mem_commonEnvelope childrenD_683_i1 b hb) +def required_683 : Finset Cell := ⟨(([(1, 4), (1, 5), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_683 : Finset Cell := ⟨(([(0, 4), (0, 6), (0, 7), (0, 8), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 3), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_683 : Fin 5 → Finset Cell := ![(placed21 1 (0, 4) required_50), (placed21 1 (0, 4) required_150), required_683_i0, required_683_i1, (placed21 4 (0, 10) required_682)] +def childrenD_683 : Fin 5 → Finset Cell := ![(placed21 1 (0, 4) envelope_50), (placed21 1 (0, 4) envelope_150), envelope_683_i0, envelope_683_i1, (placed21 4 (0, 10) envelope_682)] +theorem common_sub_683 : commonEnvelope childrenD_683 ⊆ insert (3, 5) required_683 := by decide +kernel +theorem child_required_sub_683 : ∀ j, childrenC_683 j ⊆ insert (3, 5) required_683 := by decide +kernel +theorem child_envelope_sub_683 : ∀ j, childrenD_683 j ⊆ envelope_683 := by decide +kernel +theorem pivot_mem_683 : (3, 5) ∈ envelope_683 := by decide +kernel +theorem children_work_683 : ∀ j, Template HasSnaky 15 (childrenC_683 j) (childrenD_683 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_50 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_150 1 (0, 4)).mono (by decide +kernel) + · exact row_works_683_i0.mono (by decide +kernel) + · exact row_works_683_i1.mono (by decide +kernel) + · exact (placed21_template row_works_682 4 (0, 10)).mono (by decide +kernel) +theorem row_works_683 : Template HasSnaky 16 required_683 envelope_683 := by + refine compose HasSnaky 15 childrenC_683 childrenD_683 children_work_683 (3, 5) + required_683 envelope_683 pivot_mem_683 child_required_sub_683 child_envelope_sub_683 ?_ + intro b hb + exact common_sub_683 (mem_commonEnvelope childrenD_683 b hb) +def required_706_i2 : Finset Cell := ⟨(([(3, 4), (4, 4), (5, 4), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706_i2 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 3), (4, 4), (5, 4), (6, 3), (6, 4), (6, 5), (7, 3), (7, 4), (7, 5), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706_i2 : Fin 2 → Finset Cell := ![(placed21 4 (3, 4) required_4), (placed21 1 (2, 3) required_9)] +def childrenD_706_i2 : Fin 2 → Finset Cell := ![(placed21 4 (3, 4) envelope_4), (placed21 1 (2, 3) envelope_9)] +theorem common_sub_706_i2 : commonEnvelope childrenD_706_i2 ⊆ insert (6, 4) required_706_i2 := by decide +kernel +theorem child_required_sub_706_i2 : ∀ j, childrenC_706_i2 j ⊆ insert (6, 4) required_706_i2 := by decide +kernel +theorem child_envelope_sub_706_i2 : ∀ j, childrenD_706_i2 j ⊆ envelope_706_i2 := by decide +kernel +theorem pivot_mem_706_i2 : (6, 4) ∈ envelope_706_i2 := by decide +kernel +theorem children_work_706_i2 : ∀ j, Template HasSnaky 3 (childrenC_706_i2 j) (childrenD_706_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_4 4 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (2, 3)).mono (by decide +kernel) +theorem row_works_706_i2 : Template HasSnaky 4 required_706_i2 envelope_706_i2 := by + refine compose HasSnaky 3 childrenC_706_i2 childrenD_706_i2 children_work_706_i2 (6, 4) + required_706_i2 envelope_706_i2 pivot_mem_706_i2 child_required_sub_706_i2 child_envelope_sub_706_i2 ?_ + intro b hb + exact common_sub_706_i2 (mem_commonEnvelope childrenD_706_i2 b hb) +def required_706_i3 : Finset Cell := ⟨(([(3, 4), (4, 4), (4, 5), (5, 4), (5, 5), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706_i3 : Finset Cell := ⟨(([(3, 4), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 3), (6, 5), (6, 6), (7, 3), (7, 5), (8, 3), (8, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706_i3 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) required_154), (placed21 4 (3, 6) required_159)] +def childrenD_706_i3 : Fin 2 → Finset Cell := ![(placed21 3 (3, 4) envelope_154), (placed21 4 (3, 6) envelope_159)] +theorem common_sub_706_i3 : commonEnvelope childrenD_706_i3 ⊆ insert (5, 3) required_706_i3 := by decide +kernel +theorem child_required_sub_706_i3 : ∀ j, childrenC_706_i3 j ⊆ insert (5, 3) required_706_i3 := by decide +kernel +theorem child_envelope_sub_706_i3 : ∀ j, childrenD_706_i3 j ⊆ envelope_706_i3 := by decide +kernel +theorem pivot_mem_706_i3 : (5, 3) ∈ envelope_706_i3 := by decide +kernel +theorem children_work_706_i3 : ∀ j, Template HasSnaky 3 (childrenC_706_i3 j) (childrenD_706_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_154 3 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_159 4 (3, 6)).mono (by decide +kernel) +theorem row_works_706_i3 : Template HasSnaky 4 required_706_i3 envelope_706_i3 := by + refine compose HasSnaky 3 childrenC_706_i3 childrenD_706_i3 children_work_706_i3 (5, 3) + required_706_i3 envelope_706_i3 pivot_mem_706_i3 child_required_sub_706_i3 child_envelope_sub_706_i3 ?_ + intro b hb + exact common_sub_706_i3 (mem_commonEnvelope childrenD_706_i3 b hb) +def required_706_i4 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 4), (5, 5), (7, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706_i4 : Finset Cell := ⟨(([(3, 4), (4, 4), (4, 5), (5, 4), (5, 5), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706_i4 : Fin 3 → Finset Cell := ![(placed21 3 (3, 5) required_22), (placed21 2 (8, 2) required_152), (placed21 0 (4, 1) required_166)] +def childrenD_706_i4 : Fin 3 → Finset Cell := ![(placed21 3 (3, 5) envelope_22), (placed21 2 (8, 2) envelope_152), (placed21 0 (4, 1) envelope_166)] +theorem common_sub_706_i4 : commonEnvelope childrenD_706_i4 ⊆ insert (7, 5) required_706_i4 := by decide +kernel +theorem child_required_sub_706_i4 : ∀ j, childrenC_706_i4 j ⊆ insert (7, 5) required_706_i4 := by decide +kernel +theorem child_envelope_sub_706_i4 : ∀ j, childrenD_706_i4 j ⊆ envelope_706_i4 := by decide +kernel +theorem pivot_mem_706_i4 : (7, 5) ∈ envelope_706_i4 := by decide +kernel +theorem children_work_706_i4 : ∀ j, Template HasSnaky 6 (childrenC_706_i4 j) (childrenD_706_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 3 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_152 2 (8, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_166 0 (4, 1)).mono (by decide +kernel) +theorem row_works_706_i4 : Template HasSnaky 7 required_706_i4 envelope_706_i4 := by + refine compose HasSnaky 6 childrenC_706_i4 childrenD_706_i4 children_work_706_i4 (7, 5) + required_706_i4 envelope_706_i4 pivot_mem_706_i4 child_required_sub_706_i4 child_envelope_sub_706_i4 ?_ + intro b hb + exact common_sub_706_i4 (mem_commonEnvelope childrenD_706_i4 b hb) +def required_706_i1 : Finset Cell := ⟨(([(3, 4), (4, 4), (4, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706_i1 : Finset Cell := ⟨(([(2, 3), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706_i1 : Fin 4 → Finset Cell := ![(placed21 3 (3, 4) required_261), required_706_i2, required_706_i3, required_706_i4] +def childrenD_706_i1 : Fin 4 → Finset Cell := ![(placed21 3 (3, 4) envelope_261), envelope_706_i2, envelope_706_i3, envelope_706_i4] +theorem common_sub_706_i1 : commonEnvelope childrenD_706_i1 ⊆ insert (7, 3) required_706_i1 := by decide +kernel +theorem child_required_sub_706_i1 : ∀ j, childrenC_706_i1 j ⊆ insert (7, 3) required_706_i1 := by decide +kernel +theorem child_envelope_sub_706_i1 : ∀ j, childrenD_706_i1 j ⊆ envelope_706_i1 := by decide +kernel +theorem pivot_mem_706_i1 : (7, 3) ∈ envelope_706_i1 := by decide +kernel +theorem children_work_706_i1 : ∀ j, Template HasSnaky 7 (childrenC_706_i1 j) (childrenD_706_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_261 3 (3, 4)).mono (by decide +kernel) + · exact row_works_706_i2.mono (by decide +kernel) + · exact row_works_706_i3.mono (by decide +kernel) + · exact row_works_706_i4.mono (by decide +kernel) +theorem row_works_706_i1 : Template HasSnaky 8 required_706_i1 envelope_706_i1 := by + refine compose HasSnaky 7 childrenC_706_i1 childrenD_706_i1 children_work_706_i1 (7, 3) + required_706_i1 envelope_706_i1 pivot_mem_706_i1 child_required_sub_706_i1 child_envelope_sub_706_i1 ?_ + intro b hb + exact common_sub_706_i1 (mem_commonEnvelope childrenD_706_i1 b hb) +def required_706_i0 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706_i0 : Finset Cell := ⟨(([(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706_i0 : Fin 3 → Finset Cell := ![(placed21 1 (2, 4) required_15), (placed21 3 (1, 5) required_65), required_706_i1] +def childrenD_706_i0 : Fin 3 → Finset Cell := ![(placed21 1 (2, 4) envelope_15), (placed21 3 (1, 5) envelope_65), envelope_706_i1] +theorem common_sub_706_i0 : commonEnvelope childrenD_706_i0 ⊆ insert (3, 4) required_706_i0 := by decide +kernel +theorem child_required_sub_706_i0 : ∀ j, childrenC_706_i0 j ⊆ insert (3, 4) required_706_i0 := by decide +kernel +theorem child_envelope_sub_706_i0 : ∀ j, childrenD_706_i0 j ⊆ envelope_706_i0 := by decide +kernel +theorem pivot_mem_706_i0 : (3, 4) ∈ envelope_706_i0 := by decide +kernel +theorem children_work_706_i0 : ∀ j, Template HasSnaky 8 (childrenC_706_i0 j) (childrenD_706_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_15 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_65 3 (1, 5)).mono (by decide +kernel) + · exact row_works_706_i1.mono (by decide +kernel) +theorem row_works_706_i0 : Template HasSnaky 9 required_706_i0 envelope_706_i0 := by + refine compose HasSnaky 8 childrenC_706_i0 childrenD_706_i0 children_work_706_i0 (3, 4) + required_706_i0 envelope_706_i0 pivot_mem_706_i0 child_required_sub_706_i0 child_envelope_sub_706_i0 ?_ + intro b hb + exact common_sub_706_i0 (mem_commonEnvelope childrenD_706_i0 b hb) +def required_706_i6 : Finset Cell := ⟨(([(4, 4), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706_i6 : Finset Cell := ⟨(([(0, 3), (0, 5), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (9, 1), (9, 3), (9, 4), (9, 5), (10, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706_i6 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) required_318), (placed21 7 (7, 4) required_334), (placed21 3 (3, 5) required_379)] +def childrenD_706_i6 : Fin 3 → Finset Cell := ![(placed21 1 (0, 3) envelope_318), (placed21 7 (7, 4) envelope_334), (placed21 3 (3, 5) envelope_379)] +theorem common_sub_706_i6 : commonEnvelope childrenD_706_i6 ⊆ insert (3, 3) required_706_i6 := by decide +kernel +theorem child_required_sub_706_i6 : ∀ j, childrenC_706_i6 j ⊆ insert (3, 3) required_706_i6 := by decide +kernel +theorem child_envelope_sub_706_i6 : ∀ j, childrenD_706_i6 j ⊆ envelope_706_i6 := by decide +kernel +theorem pivot_mem_706_i6 : (3, 3) ∈ envelope_706_i6 := by decide +kernel +theorem children_work_706_i6 : ∀ j, Template HasSnaky 7 (childrenC_706_i6 j) (childrenD_706_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_318 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_334 7 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_379 3 (3, 5)).mono (by decide +kernel) +theorem row_works_706_i6 : Template HasSnaky 8 required_706_i6 envelope_706_i6 := by + refine compose HasSnaky 7 childrenC_706_i6 childrenD_706_i6 children_work_706_i6 (3, 3) + required_706_i6 envelope_706_i6 pivot_mem_706_i6 child_required_sub_706_i6 child_envelope_sub_706_i6 ?_ + intro b hb + exact common_sub_706_i6 (mem_commonEnvelope childrenD_706_i6 b hb) +def required_706_i7 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 3), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706_i7 : Finset Cell := ⟨(([(1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 1), (3, 2), (3, 3), (3, 4), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 3), (6, 4), (7, 3), (7, 4), (7, 5), (8, 3), (8, 4), (8, 5), (9, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706_i7 : Fin 3 → Finset Cell := ![(placed21 7 (6, 5) required_66), (placed21 7 (6, 6) required_238), (placed21 3 (2, 5) required_394)] +def childrenD_706_i7 : Fin 3 → Finset Cell := ![(placed21 7 (6, 5) envelope_66), (placed21 7 (6, 6) envelope_238), (placed21 3 (2, 5) envelope_394)] +theorem common_sub_706_i7 : commonEnvelope childrenD_706_i7 ⊆ insert (3, 4) required_706_i7 := by decide +kernel +theorem child_required_sub_706_i7 : ∀ j, childrenC_706_i7 j ⊆ insert (3, 4) required_706_i7 := by decide +kernel +theorem child_envelope_sub_706_i7 : ∀ j, childrenD_706_i7 j ⊆ envelope_706_i7 := by decide +kernel +theorem pivot_mem_706_i7 : (3, 4) ∈ envelope_706_i7 := by decide +kernel +theorem children_work_706_i7 : ∀ j, Template HasSnaky 7 (childrenC_706_i7 j) (childrenD_706_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_66 7 (6, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_238 7 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_394 3 (2, 5)).mono (by decide +kernel) +theorem row_works_706_i7 : Template HasSnaky 8 required_706_i7 envelope_706_i7 := by + refine compose HasSnaky 7 childrenC_706_i7 childrenD_706_i7 children_work_706_i7 (3, 4) + required_706_i7 envelope_706_i7 pivot_mem_706_i7 child_required_sub_706_i7 child_envelope_sub_706_i7 ?_ + intro b hb + exact common_sub_706_i7 (mem_commonEnvelope childrenD_706_i7 b hb) +def required_706_i5 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706_i5 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (9, 1), (9, 3), (9, 4), (9, 5), (10, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706_i5 : Fin 6 → Finset Cell := ![(placed21 7 (7, 5) required_417), (placed21 7 (6, 5) required_420), (placed21 7 (6, 5) required_526), (placed21 3 (0, 6) required_532), required_706_i6, required_706_i7] +def childrenD_706_i5 : Fin 6 → Finset Cell := ![(placed21 7 (7, 5) envelope_417), (placed21 7 (6, 5) envelope_420), (placed21 7 (6, 5) envelope_526), (placed21 3 (0, 6) envelope_532), envelope_706_i6, envelope_706_i7] +theorem common_sub_706_i5 : commonEnvelope childrenD_706_i5 ⊆ insert (5, 3) required_706_i5 := by decide +kernel +theorem child_required_sub_706_i5 : ∀ j, childrenC_706_i5 j ⊆ insert (5, 3) required_706_i5 := by decide +kernel +theorem child_envelope_sub_706_i5 : ∀ j, childrenD_706_i5 j ⊆ envelope_706_i5 := by decide +kernel +theorem pivot_mem_706_i5 : (5, 3) ∈ envelope_706_i5 := by decide +kernel +theorem children_work_706_i5 : ∀ j, Template HasSnaky 8 (childrenC_706_i5 j) (childrenD_706_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_417 7 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_420 7 (6, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_526 7 (6, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_532 3 (0, 6)).mono (by decide +kernel) + · exact row_works_706_i6.mono (by decide +kernel) + · exact row_works_706_i7.mono (by decide +kernel) +theorem row_works_706_i5 : Template HasSnaky 9 required_706_i5 envelope_706_i5 := by + refine compose HasSnaky 8 childrenC_706_i5 childrenD_706_i5 children_work_706_i5 (5, 3) + required_706_i5 envelope_706_i5 pivot_mem_706_i5 child_required_sub_706_i5 child_envelope_sub_706_i5 ?_ + intro b hb + exact common_sub_706_i5 (mem_commonEnvelope childrenD_706_i5 b hb) +def required_706_i9 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 4), (5, 5), (7, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706_i9 : Finset Cell := ⟨(([(3, 4), (4, 4), (4, 5), (5, 4), (5, 5), (6, 1), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (11, 5), (11, 6), (11, 7), (11, 8), (12, 5), (12, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706_i9 : Fin 4 → Finset Cell := ![(placed21 1 (4, 4) required_30), (placed21 0 (4, 1) required_59), (placed21 3 (3, 6) required_296), (placed21 0 (6, 1) required_603)] +def childrenD_706_i9 : Fin 4 → Finset Cell := ![(placed21 1 (4, 4) envelope_30), (placed21 0 (4, 1) envelope_59), (placed21 3 (3, 6) envelope_296), (placed21 0 (6, 1) envelope_603)] +theorem common_sub_706_i9 : commonEnvelope childrenD_706_i9 ⊆ insert (7, 4) required_706_i9 := by decide +kernel +theorem child_required_sub_706_i9 : ∀ j, childrenC_706_i9 j ⊆ insert (7, 4) required_706_i9 := by decide +kernel +theorem child_envelope_sub_706_i9 : ∀ j, childrenD_706_i9 j ⊆ envelope_706_i9 := by decide +kernel +theorem pivot_mem_706_i9 : (7, 4) ∈ envelope_706_i9 := by decide +kernel +theorem children_work_706_i9 : ∀ j, Template HasSnaky 13 (childrenC_706_i9 j) (childrenD_706_i9 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_30 1 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_59 0 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_296 3 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_603 0 (6, 1)).mono (by decide +kernel) +theorem row_works_706_i9 : Template HasSnaky 14 required_706_i9 envelope_706_i9 := by + refine compose HasSnaky 13 childrenC_706_i9 childrenD_706_i9 children_work_706_i9 (7, 4) + required_706_i9 envelope_706_i9 pivot_mem_706_i9 child_required_sub_706_i9 child_envelope_sub_706_i9 ?_ + intro b hb + exact common_sub_706_i9 (mem_commonEnvelope childrenD_706_i9 b hb) +def required_706_i8 : Finset Cell := ⟨(([(4, 4), (4, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706_i8 : Finset Cell := ⟨(([(3, 4), (4, 4), (4, 5), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (11, 5), (11, 6), (11, 7), (11, 8), (12, 5), (12, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706_i8 : Fin 4 → Finset Cell := ![(placed21 3 (3, 5) required_22), (placed21 3 (4, 5) required_74), (placed21 4 (3, 9) required_325), required_706_i9] +def childrenD_706_i8 : Fin 4 → Finset Cell := ![(placed21 3 (3, 5) envelope_22), (placed21 3 (4, 5) envelope_74), (placed21 4 (3, 9) envelope_325), envelope_706_i9] +theorem common_sub_706_i8 : commonEnvelope childrenD_706_i8 ⊆ insert (7, 5) required_706_i8 := by decide +kernel +theorem child_required_sub_706_i8 : ∀ j, childrenC_706_i8 j ⊆ insert (7, 5) required_706_i8 := by decide +kernel +theorem child_envelope_sub_706_i8 : ∀ j, childrenD_706_i8 j ⊆ envelope_706_i8 := by decide +kernel +theorem pivot_mem_706_i8 : (7, 5) ∈ envelope_706_i8 := by decide +kernel +theorem children_work_706_i8 : ∀ j, Template HasSnaky 14 (childrenC_706_i8 j) (childrenD_706_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_22 3 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_74 3 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_325 4 (3, 9)).mono (by decide +kernel) + · exact row_works_706_i9.mono (by decide +kernel) +theorem row_works_706_i8 : Template HasSnaky 15 required_706_i8 envelope_706_i8 := by + refine compose HasSnaky 14 childrenC_706_i8 childrenD_706_i8 children_work_706_i8 (7, 5) + required_706_i8 envelope_706_i8 pivot_mem_706_i8 child_required_sub_706_i8 child_envelope_sub_706_i8 ?_ + intro b hb + exact common_sub_706_i8 (mem_commonEnvelope childrenD_706_i8 b hb) +def required_706 : Finset Cell := ⟨(([(4, 5), (5, 4), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_706 : Finset Cell := ⟨(([(0, 1), (0, 3), (0, 5), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 1), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (11, 5), (11, 6), (11, 7), (11, 8), (12, 5), (12, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_706 : Fin 7 → Finset Cell := ![(placed21 7 (8, 6) required_512), (placed21 3 (1, 6) required_517), (placed21 7 (8, 6) required_527), (placed21 7 (8, 6) required_537), required_706_i0, required_706_i5, required_706_i8] +def childrenD_706 : Fin 7 → Finset Cell := ![(placed21 7 (8, 6) envelope_512), (placed21 3 (1, 6) envelope_517), (placed21 7 (8, 6) envelope_527), (placed21 7 (8, 6) envelope_537), envelope_706_i0, envelope_706_i5, envelope_706_i8] +theorem common_sub_706 : commonEnvelope childrenD_706 ⊆ insert (4, 4) required_706 := by decide +kernel +theorem child_required_sub_706 : ∀ j, childrenC_706 j ⊆ insert (4, 4) required_706 := by decide +kernel +theorem child_envelope_sub_706 : ∀ j, childrenD_706 j ⊆ envelope_706 := by decide +kernel +theorem pivot_mem_706 : (4, 4) ∈ envelope_706 := by decide +kernel +theorem children_work_706 : ∀ j, Template HasSnaky 15 (childrenC_706 j) (childrenD_706 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_512 7 (8, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_517 3 (1, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_527 7 (8, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_537 7 (8, 6)).mono (by decide +kernel) + · exact row_works_706_i0.mono (by decide +kernel) + · exact row_works_706_i5.mono (by decide +kernel) + · exact row_works_706_i8.mono (by decide +kernel) +theorem row_works_706 : Template HasSnaky 16 required_706 envelope_706 := by + refine compose HasSnaky 15 childrenC_706 childrenD_706 children_work_706 (4, 4) + required_706 envelope_706 pivot_mem_706 child_required_sub_706 child_envelope_sub_706 ?_ + intro b hb + exact common_sub_706 (mem_commonEnvelope childrenD_706 b hb) +def height_683_i0 : ℕ := 4 +def childrenH_683_i0 : Fin 2 → ℕ := ![height_5, height_9] +theorem height_exact_683_i0 : height_683_i0 = 1 + Finset.univ.sup childrenH_683_i0 := by decide +kernel +theorem required_origin_683_i0 : ∀ x ∈ required_683_i0, + (∃ j, x ∈ childrenC_683_i0 j) ∨ ∀ j, x ∈ childrenD_683_i0 j := by decide +kernel +theorem required_exact_683_i0 : required_683_i0 = + ((Finset.univ.biUnion childrenC_683_i0) ∪ commonEnvelope childrenD_683_i0).erase (2, 5) := by + exact required_eq_combination childrenC_683_i0 childrenD_683_i0 (2, 5) required_683_i0 + (by decide +kernel) child_required_sub_683_i0 common_sub_683_i0 required_origin_683_i0 +theorem envelope_origin_683_i0 : ∀ x ∈ envelope_683_i0, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_683_i0 j := by decide +kernel +theorem envelope_exact_683_i0 : envelope_683_i0 = + insert (2, 5) (Finset.univ.biUnion childrenD_683_i0) := by + exact envelope_eq_combination childrenD_683_i0 (2, 5) envelope_683_i0 + pivot_mem_683_i0 child_envelope_sub_683_i0 envelope_origin_683_i0 +def checked_683_i0 : CheckedCard where + required := required_683_i0 + envelope := envelope_683_i0 + height := height_683_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_683_i0 +def height_683_i1 : ℕ := 9 +def childrenH_683_i1 : Fin 2 → ℕ := ![height_5, height_604] +theorem height_exact_683_i1 : height_683_i1 = 1 + Finset.univ.sup childrenH_683_i1 := by decide +kernel +theorem required_origin_683_i1 : ∀ x ∈ required_683_i1, + (∃ j, x ∈ childrenC_683_i1 j) ∨ ∀ j, x ∈ childrenD_683_i1 j := by decide +kernel +theorem required_exact_683_i1 : required_683_i1 = + ((Finset.univ.biUnion childrenC_683_i1) ∪ commonEnvelope childrenD_683_i1).erase (2, 5) := by + exact required_eq_combination childrenC_683_i1 childrenD_683_i1 (2, 5) required_683_i1 + (by decide +kernel) child_required_sub_683_i1 common_sub_683_i1 required_origin_683_i1 +theorem envelope_origin_683_i1 : ∀ x ∈ envelope_683_i1, + x = (2, 5) ∨ ∃ j, x ∈ childrenD_683_i1 j := by decide +kernel +theorem envelope_exact_683_i1 : envelope_683_i1 = + insert (2, 5) (Finset.univ.biUnion childrenD_683_i1) := by + exact envelope_eq_combination childrenD_683_i1 (2, 5) envelope_683_i1 + pivot_mem_683_i1 child_envelope_sub_683_i1 envelope_origin_683_i1 +def checked_683_i1 : CheckedCard where + required := required_683_i1 + envelope := envelope_683_i1 + height := height_683_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_683_i1 +def height_683 : ℕ := 16 +def childrenH_683 : Fin 5 → ℕ := ![height_50, height_150, height_683_i0, height_683_i1, height_682] +theorem height_exact_683 : height_683 = 1 + Finset.univ.sup childrenH_683 := by decide +kernel +theorem required_origin_683 : ∀ x ∈ required_683, + (∃ j, x ∈ childrenC_683 j) ∨ ∀ j, x ∈ childrenD_683 j := by decide +kernel +theorem required_exact_683 : required_683 = + ((Finset.univ.biUnion childrenC_683) ∪ commonEnvelope childrenD_683).erase (3, 5) := by + exact required_eq_combination childrenC_683 childrenD_683 (3, 5) required_683 + (by decide +kernel) child_required_sub_683 common_sub_683 required_origin_683 +theorem envelope_origin_683 : ∀ x ∈ envelope_683, + x = (3, 5) ∨ ∃ j, x ∈ childrenD_683 j := by decide +kernel +theorem envelope_exact_683 : envelope_683 = + insert (3, 5) (Finset.univ.biUnion childrenD_683) := by + exact envelope_eq_combination childrenD_683 (3, 5) envelope_683 + pivot_mem_683 child_envelope_sub_683 envelope_origin_683 +def checked_683 : CheckedCard where + required := required_683 + envelope := envelope_683 + height := height_683 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_683 +def height_706_i2 : ℕ := 4 +def childrenH_706_i2 : Fin 2 → ℕ := ![height_4, height_9] +theorem height_exact_706_i2 : height_706_i2 = 1 + Finset.univ.sup childrenH_706_i2 := by decide +kernel +theorem required_origin_706_i2 : ∀ x ∈ required_706_i2, + (∃ j, x ∈ childrenC_706_i2 j) ∨ ∀ j, x ∈ childrenD_706_i2 j := by decide +kernel +theorem required_exact_706_i2 : required_706_i2 = + ((Finset.univ.biUnion childrenC_706_i2) ∪ commonEnvelope childrenD_706_i2).erase (6, 4) := by + exact required_eq_combination childrenC_706_i2 childrenD_706_i2 (6, 4) required_706_i2 + (by decide +kernel) child_required_sub_706_i2 common_sub_706_i2 required_origin_706_i2 +theorem envelope_origin_706_i2 : ∀ x ∈ envelope_706_i2, + x = (6, 4) ∨ ∃ j, x ∈ childrenD_706_i2 j := by decide +kernel +theorem envelope_exact_706_i2 : envelope_706_i2 = + insert (6, 4) (Finset.univ.biUnion childrenD_706_i2) := by + exact envelope_eq_combination childrenD_706_i2 (6, 4) envelope_706_i2 + pivot_mem_706_i2 child_envelope_sub_706_i2 envelope_origin_706_i2 +def checked_706_i2 : CheckedCard where + required := required_706_i2 + envelope := envelope_706_i2 + height := height_706_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706_i2 +def height_706_i3 : ℕ := 4 +def childrenH_706_i3 : Fin 2 → ℕ := ![height_154, height_159] +theorem height_exact_706_i3 : height_706_i3 = 1 + Finset.univ.sup childrenH_706_i3 := by decide +kernel +theorem required_origin_706_i3 : ∀ x ∈ required_706_i3, + (∃ j, x ∈ childrenC_706_i3 j) ∨ ∀ j, x ∈ childrenD_706_i3 j := by decide +kernel +theorem required_exact_706_i3 : required_706_i3 = + ((Finset.univ.biUnion childrenC_706_i3) ∪ commonEnvelope childrenD_706_i3).erase (5, 3) := by + exact required_eq_combination childrenC_706_i3 childrenD_706_i3 (5, 3) required_706_i3 + (by decide +kernel) child_required_sub_706_i3 common_sub_706_i3 required_origin_706_i3 +theorem envelope_origin_706_i3 : ∀ x ∈ envelope_706_i3, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_706_i3 j := by decide +kernel +theorem envelope_exact_706_i3 : envelope_706_i3 = + insert (5, 3) (Finset.univ.biUnion childrenD_706_i3) := by + exact envelope_eq_combination childrenD_706_i3 (5, 3) envelope_706_i3 + pivot_mem_706_i3 child_envelope_sub_706_i3 envelope_origin_706_i3 +def checked_706_i3 : CheckedCard where + required := required_706_i3 + envelope := envelope_706_i3 + height := height_706_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706_i3 +def height_706_i4 : ℕ := 7 +def childrenH_706_i4 : Fin 3 → ℕ := ![height_22, height_152, height_166] +theorem height_exact_706_i4 : height_706_i4 = 1 + Finset.univ.sup childrenH_706_i4 := by decide +kernel +theorem required_origin_706_i4 : ∀ x ∈ required_706_i4, + (∃ j, x ∈ childrenC_706_i4 j) ∨ ∀ j, x ∈ childrenD_706_i4 j := by decide +kernel +theorem required_exact_706_i4 : required_706_i4 = + ((Finset.univ.biUnion childrenC_706_i4) ∪ commonEnvelope childrenD_706_i4).erase (7, 5) := by + exact required_eq_combination childrenC_706_i4 childrenD_706_i4 (7, 5) required_706_i4 + (by decide +kernel) child_required_sub_706_i4 common_sub_706_i4 required_origin_706_i4 +theorem envelope_origin_706_i4 : ∀ x ∈ envelope_706_i4, + x = (7, 5) ∨ ∃ j, x ∈ childrenD_706_i4 j := by decide +kernel +theorem envelope_exact_706_i4 : envelope_706_i4 = + insert (7, 5) (Finset.univ.biUnion childrenD_706_i4) := by + exact envelope_eq_combination childrenD_706_i4 (7, 5) envelope_706_i4 + pivot_mem_706_i4 child_envelope_sub_706_i4 envelope_origin_706_i4 +def checked_706_i4 : CheckedCard where + required := required_706_i4 + envelope := envelope_706_i4 + height := height_706_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706_i4 +def height_706_i1 : ℕ := 8 +def childrenH_706_i1 : Fin 4 → ℕ := ![height_261, height_706_i2, height_706_i3, height_706_i4] +theorem height_exact_706_i1 : height_706_i1 = 1 + Finset.univ.sup childrenH_706_i1 := by decide +kernel +theorem required_origin_706_i1 : ∀ x ∈ required_706_i1, + (∃ j, x ∈ childrenC_706_i1 j) ∨ ∀ j, x ∈ childrenD_706_i1 j := by decide +kernel +theorem required_exact_706_i1 : required_706_i1 = + ((Finset.univ.biUnion childrenC_706_i1) ∪ commonEnvelope childrenD_706_i1).erase (7, 3) := by + exact required_eq_combination childrenC_706_i1 childrenD_706_i1 (7, 3) required_706_i1 + (by decide +kernel) child_required_sub_706_i1 common_sub_706_i1 required_origin_706_i1 +theorem envelope_origin_706_i1 : ∀ x ∈ envelope_706_i1, + x = (7, 3) ∨ ∃ j, x ∈ childrenD_706_i1 j := by decide +kernel +theorem envelope_exact_706_i1 : envelope_706_i1 = + insert (7, 3) (Finset.univ.biUnion childrenD_706_i1) := by + exact envelope_eq_combination childrenD_706_i1 (7, 3) envelope_706_i1 + pivot_mem_706_i1 child_envelope_sub_706_i1 envelope_origin_706_i1 +def checked_706_i1 : CheckedCard where + required := required_706_i1 + envelope := envelope_706_i1 + height := height_706_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706_i1 +def height_706_i0 : ℕ := 9 +def childrenH_706_i0 : Fin 3 → ℕ := ![height_15, height_65, height_706_i1] +theorem height_exact_706_i0 : height_706_i0 = 1 + Finset.univ.sup childrenH_706_i0 := by decide +kernel +theorem required_origin_706_i0 : ∀ x ∈ required_706_i0, + (∃ j, x ∈ childrenC_706_i0 j) ∨ ∀ j, x ∈ childrenD_706_i0 j := by decide +kernel +theorem required_exact_706_i0 : required_706_i0 = + ((Finset.univ.biUnion childrenC_706_i0) ∪ commonEnvelope childrenD_706_i0).erase (3, 4) := by + exact required_eq_combination childrenC_706_i0 childrenD_706_i0 (3, 4) required_706_i0 + (by decide +kernel) child_required_sub_706_i0 common_sub_706_i0 required_origin_706_i0 +theorem envelope_origin_706_i0 : ∀ x ∈ envelope_706_i0, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_706_i0 j := by decide +kernel +theorem envelope_exact_706_i0 : envelope_706_i0 = + insert (3, 4) (Finset.univ.biUnion childrenD_706_i0) := by + exact envelope_eq_combination childrenD_706_i0 (3, 4) envelope_706_i0 + pivot_mem_706_i0 child_envelope_sub_706_i0 envelope_origin_706_i0 +def checked_706_i0 : CheckedCard where + required := required_706_i0 + envelope := envelope_706_i0 + height := height_706_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706_i0 +def height_706_i6 : ℕ := 8 +def childrenH_706_i6 : Fin 3 → ℕ := ![height_318, height_334, height_379] +theorem height_exact_706_i6 : height_706_i6 = 1 + Finset.univ.sup childrenH_706_i6 := by decide +kernel +theorem required_origin_706_i6 : ∀ x ∈ required_706_i6, + (∃ j, x ∈ childrenC_706_i6 j) ∨ ∀ j, x ∈ childrenD_706_i6 j := by decide +kernel +theorem required_exact_706_i6 : required_706_i6 = + ((Finset.univ.biUnion childrenC_706_i6) ∪ commonEnvelope childrenD_706_i6).erase (3, 3) := by + exact required_eq_combination childrenC_706_i6 childrenD_706_i6 (3, 3) required_706_i6 + (by decide +kernel) child_required_sub_706_i6 common_sub_706_i6 required_origin_706_i6 +theorem envelope_origin_706_i6 : ∀ x ∈ envelope_706_i6, + x = (3, 3) ∨ ∃ j, x ∈ childrenD_706_i6 j := by decide +kernel +theorem envelope_exact_706_i6 : envelope_706_i6 = + insert (3, 3) (Finset.univ.biUnion childrenD_706_i6) := by + exact envelope_eq_combination childrenD_706_i6 (3, 3) envelope_706_i6 + pivot_mem_706_i6 child_envelope_sub_706_i6 envelope_origin_706_i6 +def checked_706_i6 : CheckedCard where + required := required_706_i6 + envelope := envelope_706_i6 + height := height_706_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706_i6 +def height_706_i7 : ℕ := 8 +def childrenH_706_i7 : Fin 3 → ℕ := ![height_66, height_238, height_394] +theorem height_exact_706_i7 : height_706_i7 = 1 + Finset.univ.sup childrenH_706_i7 := by decide +kernel +theorem required_origin_706_i7 : ∀ x ∈ required_706_i7, + (∃ j, x ∈ childrenC_706_i7 j) ∨ ∀ j, x ∈ childrenD_706_i7 j := by decide +kernel +theorem required_exact_706_i7 : required_706_i7 = + ((Finset.univ.biUnion childrenC_706_i7) ∪ commonEnvelope childrenD_706_i7).erase (3, 4) := by + exact required_eq_combination childrenC_706_i7 childrenD_706_i7 (3, 4) required_706_i7 + (by decide +kernel) child_required_sub_706_i7 common_sub_706_i7 required_origin_706_i7 +theorem envelope_origin_706_i7 : ∀ x ∈ envelope_706_i7, + x = (3, 4) ∨ ∃ j, x ∈ childrenD_706_i7 j := by decide +kernel +theorem envelope_exact_706_i7 : envelope_706_i7 = + insert (3, 4) (Finset.univ.biUnion childrenD_706_i7) := by + exact envelope_eq_combination childrenD_706_i7 (3, 4) envelope_706_i7 + pivot_mem_706_i7 child_envelope_sub_706_i7 envelope_origin_706_i7 +def checked_706_i7 : CheckedCard where + required := required_706_i7 + envelope := envelope_706_i7 + height := height_706_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706_i7 +def height_706_i5 : ℕ := 9 +def childrenH_706_i5 : Fin 6 → ℕ := ![height_417, height_420, height_526, height_532, height_706_i6, height_706_i7] +theorem height_exact_706_i5 : height_706_i5 = 1 + Finset.univ.sup childrenH_706_i5 := by decide +kernel +theorem required_origin_706_i5 : ∀ x ∈ required_706_i5, + (∃ j, x ∈ childrenC_706_i5 j) ∨ ∀ j, x ∈ childrenD_706_i5 j := by decide +kernel +theorem required_exact_706_i5 : required_706_i5 = + ((Finset.univ.biUnion childrenC_706_i5) ∪ commonEnvelope childrenD_706_i5).erase (5, 3) := by + exact required_eq_combination childrenC_706_i5 childrenD_706_i5 (5, 3) required_706_i5 + (by decide +kernel) child_required_sub_706_i5 common_sub_706_i5 required_origin_706_i5 +theorem envelope_origin_706_i5 : ∀ x ∈ envelope_706_i5, + x = (5, 3) ∨ ∃ j, x ∈ childrenD_706_i5 j := by decide +kernel +theorem envelope_exact_706_i5 : envelope_706_i5 = + insert (5, 3) (Finset.univ.biUnion childrenD_706_i5) := by + exact envelope_eq_combination childrenD_706_i5 (5, 3) envelope_706_i5 + pivot_mem_706_i5 child_envelope_sub_706_i5 envelope_origin_706_i5 +def checked_706_i5 : CheckedCard where + required := required_706_i5 + envelope := envelope_706_i5 + height := height_706_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706_i5 +def height_706_i9 : ℕ := 14 +def childrenH_706_i9 : Fin 4 → ℕ := ![height_30, height_59, height_296, height_603] +theorem height_exact_706_i9 : height_706_i9 = 1 + Finset.univ.sup childrenH_706_i9 := by decide +kernel +theorem required_origin_706_i9 : ∀ x ∈ required_706_i9, + (∃ j, x ∈ childrenC_706_i9 j) ∨ ∀ j, x ∈ childrenD_706_i9 j := by decide +kernel +theorem required_exact_706_i9 : required_706_i9 = + ((Finset.univ.biUnion childrenC_706_i9) ∪ commonEnvelope childrenD_706_i9).erase (7, 4) := by + exact required_eq_combination childrenC_706_i9 childrenD_706_i9 (7, 4) required_706_i9 + (by decide +kernel) child_required_sub_706_i9 common_sub_706_i9 required_origin_706_i9 +theorem envelope_origin_706_i9 : ∀ x ∈ envelope_706_i9, + x = (7, 4) ∨ ∃ j, x ∈ childrenD_706_i9 j := by decide +kernel +theorem envelope_exact_706_i9 : envelope_706_i9 = + insert (7, 4) (Finset.univ.biUnion childrenD_706_i9) := by + exact envelope_eq_combination childrenD_706_i9 (7, 4) envelope_706_i9 + pivot_mem_706_i9 child_envelope_sub_706_i9 envelope_origin_706_i9 +def checked_706_i9 : CheckedCard where + required := required_706_i9 + envelope := envelope_706_i9 + height := height_706_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706_i9 +def height_706_i8 : ℕ := 15 +def childrenH_706_i8 : Fin 4 → ℕ := ![height_22, height_74, height_325, height_706_i9] +theorem height_exact_706_i8 : height_706_i8 = 1 + Finset.univ.sup childrenH_706_i8 := by decide +kernel +theorem required_origin_706_i8 : ∀ x ∈ required_706_i8, + (∃ j, x ∈ childrenC_706_i8 j) ∨ ∀ j, x ∈ childrenD_706_i8 j := by decide +kernel +theorem required_exact_706_i8 : required_706_i8 = + ((Finset.univ.biUnion childrenC_706_i8) ∪ commonEnvelope childrenD_706_i8).erase (7, 5) := by + exact required_eq_combination childrenC_706_i8 childrenD_706_i8 (7, 5) required_706_i8 + (by decide +kernel) child_required_sub_706_i8 common_sub_706_i8 required_origin_706_i8 +theorem envelope_origin_706_i8 : ∀ x ∈ envelope_706_i8, + x = (7, 5) ∨ ∃ j, x ∈ childrenD_706_i8 j := by decide +kernel +theorem envelope_exact_706_i8 : envelope_706_i8 = + insert (7, 5) (Finset.univ.biUnion childrenD_706_i8) := by + exact envelope_eq_combination childrenD_706_i8 (7, 5) envelope_706_i8 + pivot_mem_706_i8 child_envelope_sub_706_i8 envelope_origin_706_i8 +def checked_706_i8 : CheckedCard where + required := required_706_i8 + envelope := envelope_706_i8 + height := height_706_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706_i8 +def height_706 : ℕ := 16 +def childrenH_706 : Fin 7 → ℕ := ![height_512, height_517, height_527, height_537, height_706_i0, height_706_i5, height_706_i8] +theorem height_exact_706 : height_706 = 1 + Finset.univ.sup childrenH_706 := by decide +kernel +theorem required_origin_706 : ∀ x ∈ required_706, + (∃ j, x ∈ childrenC_706 j) ∨ ∀ j, x ∈ childrenD_706 j := by decide +kernel +theorem required_exact_706 : required_706 = + ((Finset.univ.biUnion childrenC_706) ∪ commonEnvelope childrenD_706).erase (4, 4) := by + exact required_eq_combination childrenC_706 childrenD_706 (4, 4) required_706 + (by decide +kernel) child_required_sub_706 common_sub_706 required_origin_706 +theorem envelope_origin_706 : ∀ x ∈ envelope_706, + x = (4, 4) ∨ ∃ j, x ∈ childrenD_706 j := by decide +kernel +theorem envelope_exact_706 : envelope_706 = + insert (4, 4) (Finset.univ.biUnion childrenD_706) := by + exact envelope_eq_combination childrenD_706 (4, 4) envelope_706 + pivot_mem_706 child_envelope_sub_706 envelope_origin_706 +def checked_706 : CheckedCard where + required := required_706 + envelope := envelope_706 + height := height_706 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_706 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part03.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part03.lean new file mode 100644 index 0000000..d18334a --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part03.lean @@ -0,0 +1,465 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part04 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_724_i0 : Finset Cell := ⟨(([(5, 7), (5, 8), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_724_i0 : Finset Cell := ⟨(([(0, 7), (1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9), (3, 8), (3, 9), (4, 7), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 7), (9, 8), (9, 9), (9, 10), (10, 7), (10, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_724_i0 : Fin 4 → Finset Cell := ![(placed21 0 (3, 5) required_57), (placed21 2 (7, 5) required_111), (placed21 5 (10, 7) required_390), (placed21 0 (4, 5) required_397)] +def childrenD_724_i0 : Fin 4 → Finset Cell := ![(placed21 0 (3, 5) envelope_57), (placed21 2 (7, 5) envelope_111), (placed21 5 (10, 7) envelope_390), (placed21 0 (4, 5) envelope_397)] +theorem common_sub_724_i0 : commonEnvelope childrenD_724_i0 ⊆ insert (4, 8) required_724_i0 := by decide +kernel +theorem child_required_sub_724_i0 : ∀ j, childrenC_724_i0 j ⊆ insert (4, 8) required_724_i0 := by decide +kernel +theorem child_envelope_sub_724_i0 : ∀ j, childrenD_724_i0 j ⊆ envelope_724_i0 := by decide +kernel +theorem pivot_mem_724_i0 : (4, 8) ∈ envelope_724_i0 := by decide +kernel +theorem children_work_724_i0 : ∀ j, Template HasSnaky 9 (childrenC_724_i0 j) (childrenD_724_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_57 0 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_111 2 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_390 5 (10, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_397 0 (4, 5)).mono (by decide +kernel) +theorem row_works_724_i0 : Template HasSnaky 10 required_724_i0 envelope_724_i0 := by + refine compose HasSnaky 9 childrenC_724_i0 childrenD_724_i0 children_work_724_i0 (4, 8) + required_724_i0 envelope_724_i0 pivot_mem_724_i0 child_required_sub_724_i0 child_envelope_sub_724_i0 ?_ + intro b hb + exact common_sub_724_i0 (mem_commonEnvelope childrenD_724_i0 b hb) +def required_724_i2 : Finset Cell := ⟨(([(5, 8), (6, 8), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_724_i2 : Finset Cell := ⟨(([(1, 7), (1, 9), (2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9), (4, 8), (5, 8), (5, 9), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 7), (8, 9), (8, 10), (8, 11), (8, 12), (9, 10), (10, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_724_i2 : Fin 3 → Finset Cell := ![(placed21 5 (8, 7) required_19), (placed21 7 (8, 9) required_19), (placed21 0 (4, 6) required_395)] +def childrenD_724_i2 : Fin 3 → Finset Cell := ![(placed21 5 (8, 7) envelope_19), (placed21 7 (8, 9) envelope_19), (placed21 0 (4, 6) envelope_395)] +theorem common_sub_724_i2 : commonEnvelope childrenD_724_i2 ⊆ insert (4, 8) required_724_i2 := by decide +kernel +theorem child_required_sub_724_i2 : ∀ j, childrenC_724_i2 j ⊆ insert (4, 8) required_724_i2 := by decide +kernel +theorem child_envelope_sub_724_i2 : ∀ j, childrenD_724_i2 j ⊆ envelope_724_i2 := by decide +kernel +theorem pivot_mem_724_i2 : (4, 8) ∈ envelope_724_i2 := by decide +kernel +theorem children_work_724_i2 : ∀ j, Template HasSnaky 8 (childrenC_724_i2 j) (childrenD_724_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 5 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_19 7 (8, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_395 0 (4, 6)).mono (by decide +kernel) +theorem row_works_724_i2 : Template HasSnaky 9 required_724_i2 envelope_724_i2 := by + refine compose HasSnaky 8 childrenC_724_i2 childrenD_724_i2 children_work_724_i2 (4, 8) + required_724_i2 envelope_724_i2 pivot_mem_724_i2 child_required_sub_724_i2 child_envelope_sub_724_i2 ?_ + intro b hb + exact common_sub_724_i2 (mem_commonEnvelope childrenD_724_i2 b hb) +def required_724_i3 : Finset Cell := ⟨(([(5, 7), (5, 8), (6, 8), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_724_i3 : Finset Cell := ⟨(([(1, 7), (1, 9), (2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 7), (7, 8), (7, 9), (8, 7), (8, 8), (9, 7), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_724_i3 : Fin 3 → Finset Cell := ![(placed21 5 (8, 7) required_19), (placed21 2 (7, 5) required_231), (placed21 0 (4, 5) required_279)] +def childrenD_724_i3 : Fin 3 → Finset Cell := ![(placed21 5 (8, 7) envelope_19), (placed21 2 (7, 5) envelope_231), (placed21 0 (4, 5) envelope_279)] +theorem common_sub_724_i3 : commonEnvelope childrenD_724_i3 ⊆ insert (4, 8) required_724_i3 := by decide +kernel +theorem child_required_sub_724_i3 : ∀ j, childrenC_724_i3 j ⊆ insert (4, 8) required_724_i3 := by decide +kernel +theorem child_envelope_sub_724_i3 : ∀ j, childrenD_724_i3 j ⊆ envelope_724_i3 := by decide +kernel +theorem pivot_mem_724_i3 : (4, 8) ∈ envelope_724_i3 := by decide +kernel +theorem children_work_724_i3 : ∀ j, Template HasSnaky 5 (childrenC_724_i3 j) (childrenD_724_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_19 5 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_231 2 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_279 0 (4, 5)).mono (by decide +kernel) +theorem row_works_724_i3 : Template HasSnaky 6 required_724_i3 envelope_724_i3 := by + refine compose HasSnaky 5 childrenC_724_i3 childrenD_724_i3 children_work_724_i3 (4, 8) + required_724_i3 envelope_724_i3 pivot_mem_724_i3 child_required_sub_724_i3 child_envelope_sub_724_i3 ?_ + intro b hb + exact common_sub_724_i3 (mem_commonEnvelope childrenD_724_i3 b hb) +def required_724_i4 : Finset Cell := ⟨(([(5, 7), (5, 8), (6, 8), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_724_i4 : Finset Cell := ⟨(([(4, 8), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 8), (8, 9), (8, 10), (8, 11), (9, 7), (9, 8), (9, 9), (9, 10), (10, 7), (10, 8), (10, 9), (10, 10), (11, 7), (11, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_724_i4 : Fin 2 → Finset Cell := ![(placed21 6 (6, 11) required_53), (placed21 0 (4, 6) required_637)] +def childrenD_724_i4 : Fin 2 → Finset Cell := ![(placed21 6 (6, 11) envelope_53), (placed21 0 (4, 6) envelope_637)] +theorem common_sub_724_i4 : commonEnvelope childrenD_724_i4 ⊆ insert (6, 9) required_724_i4 := by decide +kernel +theorem child_required_sub_724_i4 : ∀ j, childrenC_724_i4 j ⊆ insert (6, 9) required_724_i4 := by decide +kernel +theorem child_envelope_sub_724_i4 : ∀ j, childrenD_724_i4 j ⊆ envelope_724_i4 := by decide +kernel +theorem pivot_mem_724_i4 : (6, 9) ∈ envelope_724_i4 := by decide +kernel +theorem children_work_724_i4 : ∀ j, Template HasSnaky 7 (childrenC_724_i4 j) (childrenD_724_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 6 (6, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_637 0 (4, 6)).mono (by decide +kernel) +theorem row_works_724_i4 : Template HasSnaky 8 required_724_i4 envelope_724_i4 := by + refine compose HasSnaky 7 childrenC_724_i4 childrenD_724_i4 children_work_724_i4 (6, 9) + required_724_i4 envelope_724_i4 pivot_mem_724_i4 child_required_sub_724_i4 child_envelope_sub_724_i4 ?_ + intro b hb + exact common_sub_724_i4 (mem_commonEnvelope childrenD_724_i4 b hb) +def required_724_i1 : Finset Cell := ⟨(([(5, 7), (5, 8), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_724_i1 : Finset Cell := ⟨(([(1, 7), (1, 9), (2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (10, 7), (10, 8), (10, 9), (10, 10), (11, 7), (11, 9), (11, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_724_i1 : Fin 6 → Finset Cell := ![(placed21 1 (3, 6) required_188), (placed21 3 (3, 10) required_188), (placed21 0 (5, 5) required_258), required_724_i2, required_724_i3, required_724_i4] +def childrenD_724_i1 : Fin 6 → Finset Cell := ![(placed21 1 (3, 6) envelope_188), (placed21 3 (3, 10) envelope_188), (placed21 0 (5, 5) envelope_258), envelope_724_i2, envelope_724_i3, envelope_724_i4] +theorem common_sub_724_i1 : commonEnvelope childrenD_724_i1 ⊆ insert (7, 8) required_724_i1 := by decide +kernel +theorem child_required_sub_724_i1 : ∀ j, childrenC_724_i1 j ⊆ insert (7, 8) required_724_i1 := by decide +kernel +theorem child_envelope_sub_724_i1 : ∀ j, childrenD_724_i1 j ⊆ envelope_724_i1 := by decide +kernel +theorem pivot_mem_724_i1 : (7, 8) ∈ envelope_724_i1 := by decide +kernel +theorem children_work_724_i1 : ∀ j, Template HasSnaky 9 (childrenC_724_i1 j) (childrenD_724_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_188 1 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_188 3 (3, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_258 0 (5, 5)).mono (by decide +kernel) + · exact row_works_724_i2.mono (by decide +kernel) + · exact row_works_724_i3.mono (by decide +kernel) + · exact row_works_724_i4.mono (by decide +kernel) +theorem row_works_724_i1 : Template HasSnaky 10 required_724_i1 envelope_724_i1 := by + refine compose HasSnaky 9 childrenC_724_i1 childrenD_724_i1 children_work_724_i1 (7, 8) + required_724_i1 envelope_724_i1 pivot_mem_724_i1 child_required_sub_724_i1 child_envelope_sub_724_i1 ?_ + intro b hb + exact common_sub_724_i1 (mem_commonEnvelope childrenD_724_i1 b hb) +def required_724_i5 : Finset Cell := ⟨(([(5, 7), (5, 8), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_724_i5 : Finset Cell := ⟨(([(0, 4), (0, 6), (0, 11), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 9), (1, 10), (1, 11), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 9), (2, 10), (2, 11), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 9), (3, 10), (3, 11), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 10), (4, 11), (4, 12), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 3), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (7, 4), (7, 5), (7, 6), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (8, 4), (8, 5), (8, 6), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (9, 4), (9, 5), (9, 6), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (10, 4), (10, 9), (10, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_724_i5 : Fin 4 → Finset Cell := ![(placed21 7 (8, 8) required_53), (placed21 1 (2, 7) required_53), (placed21 7 (10, 12) required_720), (placed21 1 (0, 3) required_720)] +def childrenD_724_i5 : Fin 4 → Finset Cell := ![(placed21 7 (8, 8) envelope_53), (placed21 1 (2, 7) envelope_53), (placed21 7 (10, 12) envelope_720), (placed21 1 (0, 3) envelope_720)] +theorem common_sub_724_i5 : commonEnvelope childrenD_724_i5 ⊆ insert (4, 7) required_724_i5 := by decide +kernel +theorem child_required_sub_724_i5 : ∀ j, childrenC_724_i5 j ⊆ insert (4, 7) required_724_i5 := by decide +kernel +theorem child_envelope_sub_724_i5 : ∀ j, childrenD_724_i5 j ⊆ envelope_724_i5 := by decide +kernel +theorem pivot_mem_724_i5 : (4, 7) ∈ envelope_724_i5 := by decide +kernel +theorem children_work_724_i5 : ∀ j, Template HasSnaky 13 (childrenC_724_i5 j) (childrenD_724_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_53 7 (8, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_53 1 (2, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_720 7 (10, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_720 1 (0, 3)).mono (by decide +kernel) +theorem row_works_724_i5 : Template HasSnaky 14 required_724_i5 envelope_724_i5 := by + refine compose HasSnaky 13 childrenC_724_i5 childrenD_724_i5 children_work_724_i5 (4, 7) + required_724_i5 envelope_724_i5 pivot_mem_724_i5 child_required_sub_724_i5 child_envelope_sub_724_i5 ?_ + intro b hb + exact common_sub_724_i5 (mem_commonEnvelope childrenD_724_i5 b hb) +def required_724_i6 : Finset Cell := ⟨(([(5, 7), (5, 8), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_724_i6 : Finset Cell := ⟨(([(2, 6), (2, 7), (3, 6), (3, 7), (3, 11), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 10), (4, 11), (4, 12), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (10, 9), (10, 10), (10, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_724_i6 : Fin 5 → Finset Cell := ![(placed21 0 (4, 4) required_512), (placed21 3 (2, 10) required_600), (placed21 6 (9, 11) required_621), (placed21 1 (3, 6) required_702), (placed21 2 (8, 3) required_714)] +def childrenD_724_i6 : Fin 5 → Finset Cell := ![(placed21 0 (4, 4) envelope_512), (placed21 3 (2, 10) envelope_600), (placed21 6 (9, 11) envelope_621), (placed21 1 (3, 6) envelope_702), (placed21 2 (8, 3) envelope_714)] +theorem common_sub_724_i6 : commonEnvelope childrenD_724_i6 ⊆ insert (6, 7) required_724_i6 := by decide +kernel +theorem child_required_sub_724_i6 : ∀ j, childrenC_724_i6 j ⊆ insert (6, 7) required_724_i6 := by decide +kernel +theorem child_envelope_sub_724_i6 : ∀ j, childrenD_724_i6 j ⊆ envelope_724_i6 := by decide +kernel +theorem pivot_mem_724_i6 : (6, 7) ∈ envelope_724_i6 := by decide +kernel +theorem children_work_724_i6 : ∀ j, Template HasSnaky 10 (childrenC_724_i6 j) (childrenD_724_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_512 0 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_600 3 (2, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_621 6 (9, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_702 1 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_714 2 (8, 3)).mono (by decide +kernel) +theorem row_works_724_i6 : Template HasSnaky 11 required_724_i6 envelope_724_i6 := by + refine compose HasSnaky 10 childrenC_724_i6 childrenD_724_i6 children_work_724_i6 (6, 7) + required_724_i6 envelope_724_i6 pivot_mem_724_i6 child_required_sub_724_i6 child_envelope_sub_724_i6 ?_ + intro b hb + exact common_sub_724_i6 (mem_commonEnvelope childrenD_724_i6 b hb) +def required_724_i8 : Finset Cell := ⟨(([(4, 8), (5, 8), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_724_i8 : Finset Cell := ⟨(([(3, 7), (4, 7), (4, 8), (5, 7), (5, 8), (5, 9), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 7), (9, 9), (9, 10), (10, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_724_i8 : Fin 3 → Finset Cell := ![(placed21 3 (3, 8) required_7), (placed21 1 (3, 7) required_9), (placed21 0 (4, 5) required_604)] +def childrenD_724_i8 : Fin 3 → Finset Cell := ![(placed21 3 (3, 8) envelope_7), (placed21 1 (3, 7) envelope_9), (placed21 0 (4, 5) envelope_604)] +theorem common_sub_724_i8 : commonEnvelope childrenD_724_i8 ⊆ insert (7, 8) required_724_i8 := by decide +kernel +theorem child_required_sub_724_i8 : ∀ j, childrenC_724_i8 j ⊆ insert (7, 8) required_724_i8 := by decide +kernel +theorem child_envelope_sub_724_i8 : ∀ j, childrenD_724_i8 j ⊆ envelope_724_i8 := by decide +kernel +theorem pivot_mem_724_i8 : (7, 8) ∈ envelope_724_i8 := by decide +kernel +theorem children_work_724_i8 : ∀ j, Template HasSnaky 8 (childrenC_724_i8 j) (childrenD_724_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 3 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_9 1 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_604 0 (4, 5)).mono (by decide +kernel) +theorem row_works_724_i8 : Template HasSnaky 9 required_724_i8 envelope_724_i8 := by + refine compose HasSnaky 8 childrenC_724_i8 childrenD_724_i8 children_work_724_i8 (7, 8) + required_724_i8 envelope_724_i8 pivot_mem_724_i8 child_required_sub_724_i8 child_envelope_sub_724_i8 ?_ + intro b hb + exact common_sub_724_i8 (mem_commonEnvelope childrenD_724_i8 b hb) +def required_724_i7 : Finset Cell := ⟨(([(5, 7), (5, 8), (6, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_724_i7 : Finset Cell := ⟨(([(0, 7), (1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 6), (4, 7), (4, 8), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 7), (9, 9), (9, 10), (10, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_724_i7 : Fin 4 → Finset Cell := ![(placed21 0 (3, 5) required_88), (placed21 2 (7, 5) required_231), (placed21 5 (8, 6) required_267), required_724_i8] +def childrenD_724_i7 : Fin 4 → Finset Cell := ![(placed21 0 (3, 5) envelope_88), (placed21 2 (7, 5) envelope_231), (placed21 5 (8, 6) envelope_267), envelope_724_i8] +theorem common_sub_724_i7 : commonEnvelope childrenD_724_i7 ⊆ insert (4, 8) required_724_i7 := by decide +kernel +theorem child_required_sub_724_i7 : ∀ j, childrenC_724_i7 j ⊆ insert (4, 8) required_724_i7 := by decide +kernel +theorem child_envelope_sub_724_i7 : ∀ j, childrenD_724_i7 j ⊆ envelope_724_i7 := by decide +kernel +theorem pivot_mem_724_i7 : (4, 8) ∈ envelope_724_i7 := by decide +kernel +theorem children_work_724_i7 : ∀ j, Template HasSnaky 9 (childrenC_724_i7 j) (childrenD_724_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_88 0 (3, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_231 2 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_267 5 (8, 6)).mono (by decide +kernel) + · exact row_works_724_i8.mono (by decide +kernel) +theorem row_works_724_i7 : Template HasSnaky 10 required_724_i7 envelope_724_i7 := by + refine compose HasSnaky 9 childrenC_724_i7 childrenD_724_i7 children_work_724_i7 (4, 8) + required_724_i7 envelope_724_i7 pivot_mem_724_i7 child_required_sub_724_i7 child_envelope_sub_724_i7 ?_ + intro b hb + exact common_sub_724_i7 (mem_commonEnvelope childrenD_724_i7 b hb) +def required_724 : Finset Cell := ⟨(([(5, 7), (5, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_724 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (0, 7), (0, 11), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 10), (4, 11), (4, 12), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 3), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (10, 4), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (11, 7), (11, 9), (11, 10), (11, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_724 : Fin 10 → Finset Cell := ![(placed21 5 (9, 5) required_523), (placed21 5 (9, 5) required_524), (placed21 1 (1, 5) required_677), required_724_i0, required_724_i1, (placed21 7 (10, 10) required_719), required_724_i5, required_724_i6, required_724_i7, (placed21 6 (8, 13) required_723)] +def childrenD_724 : Fin 10 → Finset Cell := ![(placed21 5 (9, 5) envelope_523), (placed21 5 (9, 5) envelope_524), (placed21 1 (1, 5) envelope_677), envelope_724_i0, envelope_724_i1, (placed21 7 (10, 10) envelope_719), envelope_724_i5, envelope_724_i6, envelope_724_i7, (placed21 6 (8, 13) envelope_723)] +theorem common_sub_724 : commonEnvelope childrenD_724 ⊆ insert (6, 8) required_724 := by decide +kernel +theorem child_required_sub_724 : ∀ j, childrenC_724 j ⊆ insert (6, 8) required_724 := by decide +kernel +theorem child_envelope_sub_724 : ∀ j, childrenD_724 j ⊆ envelope_724 := by decide +kernel +theorem pivot_mem_724 : (6, 8) ∈ envelope_724 := by decide +kernel +theorem children_work_724 : ∀ j, Template HasSnaky 15 (childrenC_724 j) (childrenD_724 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_523 5 (9, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_524 5 (9, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_677 1 (1, 5)).mono (by decide +kernel) + · exact row_works_724_i0.mono (by decide +kernel) + · exact row_works_724_i1.mono (by decide +kernel) + · exact (placed21_template row_works_719 7 (10, 10)).mono (by decide +kernel) + · exact row_works_724_i5.mono (by decide +kernel) + · exact row_works_724_i6.mono (by decide +kernel) + · exact row_works_724_i7.mono (by decide +kernel) + · exact (placed21_template row_works_723 6 (8, 13)).mono (by decide +kernel) +theorem row_works_724 : Template HasSnaky 16 required_724 envelope_724 := by + refine compose HasSnaky 15 childrenC_724 childrenD_724 children_work_724 (6, 8) + required_724 envelope_724 pivot_mem_724 child_required_sub_724 child_envelope_sub_724 ?_ + intro b hb + exact common_sub_724 (mem_commonEnvelope childrenD_724 b hb) +def height_724_i0 : ℕ := 10 +def childrenH_724_i0 : Fin 4 → ℕ := ![height_57, height_111, height_390, height_397] +theorem height_exact_724_i0 : height_724_i0 = 1 + Finset.univ.sup childrenH_724_i0 := by decide +kernel +theorem required_origin_724_i0 : ∀ x ∈ required_724_i0, + (∃ j, x ∈ childrenC_724_i0 j) ∨ ∀ j, x ∈ childrenD_724_i0 j := by decide +kernel +theorem required_exact_724_i0 : required_724_i0 = + ((Finset.univ.biUnion childrenC_724_i0) ∪ commonEnvelope childrenD_724_i0).erase (4, 8) := by + exact required_eq_combination childrenC_724_i0 childrenD_724_i0 (4, 8) required_724_i0 + (by decide +kernel) child_required_sub_724_i0 common_sub_724_i0 required_origin_724_i0 +theorem envelope_origin_724_i0 : ∀ x ∈ envelope_724_i0, + x = (4, 8) ∨ ∃ j, x ∈ childrenD_724_i0 j := by decide +kernel +theorem envelope_exact_724_i0 : envelope_724_i0 = + insert (4, 8) (Finset.univ.biUnion childrenD_724_i0) := by + exact envelope_eq_combination childrenD_724_i0 (4, 8) envelope_724_i0 + pivot_mem_724_i0 child_envelope_sub_724_i0 envelope_origin_724_i0 +def checked_724_i0 : CheckedCard where + required := required_724_i0 + envelope := envelope_724_i0 + height := height_724_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_724_i0 +def height_724_i2 : ℕ := 9 +def childrenH_724_i2 : Fin 3 → ℕ := ![height_19, height_19, height_395] +theorem height_exact_724_i2 : height_724_i2 = 1 + Finset.univ.sup childrenH_724_i2 := by decide +kernel +theorem required_origin_724_i2 : ∀ x ∈ required_724_i2, + (∃ j, x ∈ childrenC_724_i2 j) ∨ ∀ j, x ∈ childrenD_724_i2 j := by decide +kernel +theorem required_exact_724_i2 : required_724_i2 = + ((Finset.univ.biUnion childrenC_724_i2) ∪ commonEnvelope childrenD_724_i2).erase (4, 8) := by + exact required_eq_combination childrenC_724_i2 childrenD_724_i2 (4, 8) required_724_i2 + (by decide +kernel) child_required_sub_724_i2 common_sub_724_i2 required_origin_724_i2 +theorem envelope_origin_724_i2 : ∀ x ∈ envelope_724_i2, + x = (4, 8) ∨ ∃ j, x ∈ childrenD_724_i2 j := by decide +kernel +theorem envelope_exact_724_i2 : envelope_724_i2 = + insert (4, 8) (Finset.univ.biUnion childrenD_724_i2) := by + exact envelope_eq_combination childrenD_724_i2 (4, 8) envelope_724_i2 + pivot_mem_724_i2 child_envelope_sub_724_i2 envelope_origin_724_i2 +def checked_724_i2 : CheckedCard where + required := required_724_i2 + envelope := envelope_724_i2 + height := height_724_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_724_i2 +def height_724_i3 : ℕ := 6 +def childrenH_724_i3 : Fin 3 → ℕ := ![height_19, height_231, height_279] +theorem height_exact_724_i3 : height_724_i3 = 1 + Finset.univ.sup childrenH_724_i3 := by decide +kernel +theorem required_origin_724_i3 : ∀ x ∈ required_724_i3, + (∃ j, x ∈ childrenC_724_i3 j) ∨ ∀ j, x ∈ childrenD_724_i3 j := by decide +kernel +theorem required_exact_724_i3 : required_724_i3 = + ((Finset.univ.biUnion childrenC_724_i3) ∪ commonEnvelope childrenD_724_i3).erase (4, 8) := by + exact required_eq_combination childrenC_724_i3 childrenD_724_i3 (4, 8) required_724_i3 + (by decide +kernel) child_required_sub_724_i3 common_sub_724_i3 required_origin_724_i3 +theorem envelope_origin_724_i3 : ∀ x ∈ envelope_724_i3, + x = (4, 8) ∨ ∃ j, x ∈ childrenD_724_i3 j := by decide +kernel +theorem envelope_exact_724_i3 : envelope_724_i3 = + insert (4, 8) (Finset.univ.biUnion childrenD_724_i3) := by + exact envelope_eq_combination childrenD_724_i3 (4, 8) envelope_724_i3 + pivot_mem_724_i3 child_envelope_sub_724_i3 envelope_origin_724_i3 +def checked_724_i3 : CheckedCard where + required := required_724_i3 + envelope := envelope_724_i3 + height := height_724_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_724_i3 +def height_724_i4 : ℕ := 8 +def childrenH_724_i4 : Fin 2 → ℕ := ![height_53, height_637] +theorem height_exact_724_i4 : height_724_i4 = 1 + Finset.univ.sup childrenH_724_i4 := by decide +kernel +theorem required_origin_724_i4 : ∀ x ∈ required_724_i4, + (∃ j, x ∈ childrenC_724_i4 j) ∨ ∀ j, x ∈ childrenD_724_i4 j := by decide +kernel +theorem required_exact_724_i4 : required_724_i4 = + ((Finset.univ.biUnion childrenC_724_i4) ∪ commonEnvelope childrenD_724_i4).erase (6, 9) := by + exact required_eq_combination childrenC_724_i4 childrenD_724_i4 (6, 9) required_724_i4 + (by decide +kernel) child_required_sub_724_i4 common_sub_724_i4 required_origin_724_i4 +theorem envelope_origin_724_i4 : ∀ x ∈ envelope_724_i4, + x = (6, 9) ∨ ∃ j, x ∈ childrenD_724_i4 j := by decide +kernel +theorem envelope_exact_724_i4 : envelope_724_i4 = + insert (6, 9) (Finset.univ.biUnion childrenD_724_i4) := by + exact envelope_eq_combination childrenD_724_i4 (6, 9) envelope_724_i4 + pivot_mem_724_i4 child_envelope_sub_724_i4 envelope_origin_724_i4 +def checked_724_i4 : CheckedCard where + required := required_724_i4 + envelope := envelope_724_i4 + height := height_724_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_724_i4 +def height_724_i1 : ℕ := 10 +def childrenH_724_i1 : Fin 6 → ℕ := ![height_188, height_188, height_258, height_724_i2, height_724_i3, height_724_i4] +theorem height_exact_724_i1 : height_724_i1 = 1 + Finset.univ.sup childrenH_724_i1 := by decide +kernel +theorem required_origin_724_i1 : ∀ x ∈ required_724_i1, + (∃ j, x ∈ childrenC_724_i1 j) ∨ ∀ j, x ∈ childrenD_724_i1 j := by decide +kernel +theorem required_exact_724_i1 : required_724_i1 = + ((Finset.univ.biUnion childrenC_724_i1) ∪ commonEnvelope childrenD_724_i1).erase (7, 8) := by + exact required_eq_combination childrenC_724_i1 childrenD_724_i1 (7, 8) required_724_i1 + (by decide +kernel) child_required_sub_724_i1 common_sub_724_i1 required_origin_724_i1 +theorem envelope_origin_724_i1 : ∀ x ∈ envelope_724_i1, + x = (7, 8) ∨ ∃ j, x ∈ childrenD_724_i1 j := by decide +kernel +theorem envelope_exact_724_i1 : envelope_724_i1 = + insert (7, 8) (Finset.univ.biUnion childrenD_724_i1) := by + exact envelope_eq_combination childrenD_724_i1 (7, 8) envelope_724_i1 + pivot_mem_724_i1 child_envelope_sub_724_i1 envelope_origin_724_i1 +def checked_724_i1 : CheckedCard where + required := required_724_i1 + envelope := envelope_724_i1 + height := height_724_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_724_i1 +def height_724_i5 : ℕ := 14 +def childrenH_724_i5 : Fin 4 → ℕ := ![height_53, height_53, height_720, height_720] +theorem height_exact_724_i5 : height_724_i5 = 1 + Finset.univ.sup childrenH_724_i5 := by decide +kernel +theorem required_origin_724_i5 : ∀ x ∈ required_724_i5, + (∃ j, x ∈ childrenC_724_i5 j) ∨ ∀ j, x ∈ childrenD_724_i5 j := by decide +kernel +theorem required_exact_724_i5 : required_724_i5 = + ((Finset.univ.biUnion childrenC_724_i5) ∪ commonEnvelope childrenD_724_i5).erase (4, 7) := by + exact required_eq_combination childrenC_724_i5 childrenD_724_i5 (4, 7) required_724_i5 + (by decide +kernel) child_required_sub_724_i5 common_sub_724_i5 required_origin_724_i5 +theorem envelope_origin_724_i5 : ∀ x ∈ envelope_724_i5, + x = (4, 7) ∨ ∃ j, x ∈ childrenD_724_i5 j := by decide +kernel +theorem envelope_exact_724_i5 : envelope_724_i5 = + insert (4, 7) (Finset.univ.biUnion childrenD_724_i5) := by + exact envelope_eq_combination childrenD_724_i5 (4, 7) envelope_724_i5 + pivot_mem_724_i5 child_envelope_sub_724_i5 envelope_origin_724_i5 +def checked_724_i5 : CheckedCard where + required := required_724_i5 + envelope := envelope_724_i5 + height := height_724_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_724_i5 +def height_724_i6 : ℕ := 11 +def childrenH_724_i6 : Fin 5 → ℕ := ![height_512, height_600, height_621, height_702, height_714] +theorem height_exact_724_i6 : height_724_i6 = 1 + Finset.univ.sup childrenH_724_i6 := by decide +kernel +theorem required_origin_724_i6 : ∀ x ∈ required_724_i6, + (∃ j, x ∈ childrenC_724_i6 j) ∨ ∀ j, x ∈ childrenD_724_i6 j := by decide +kernel +theorem required_exact_724_i6 : required_724_i6 = + ((Finset.univ.biUnion childrenC_724_i6) ∪ commonEnvelope childrenD_724_i6).erase (6, 7) := by + exact required_eq_combination childrenC_724_i6 childrenD_724_i6 (6, 7) required_724_i6 + (by decide +kernel) child_required_sub_724_i6 common_sub_724_i6 required_origin_724_i6 +theorem envelope_origin_724_i6 : ∀ x ∈ envelope_724_i6, + x = (6, 7) ∨ ∃ j, x ∈ childrenD_724_i6 j := by decide +kernel +theorem envelope_exact_724_i6 : envelope_724_i6 = + insert (6, 7) (Finset.univ.biUnion childrenD_724_i6) := by + exact envelope_eq_combination childrenD_724_i6 (6, 7) envelope_724_i6 + pivot_mem_724_i6 child_envelope_sub_724_i6 envelope_origin_724_i6 +def checked_724_i6 : CheckedCard where + required := required_724_i6 + envelope := envelope_724_i6 + height := height_724_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_724_i6 +def height_724_i8 : ℕ := 9 +def childrenH_724_i8 : Fin 3 → ℕ := ![height_7, height_9, height_604] +theorem height_exact_724_i8 : height_724_i8 = 1 + Finset.univ.sup childrenH_724_i8 := by decide +kernel +theorem required_origin_724_i8 : ∀ x ∈ required_724_i8, + (∃ j, x ∈ childrenC_724_i8 j) ∨ ∀ j, x ∈ childrenD_724_i8 j := by decide +kernel +theorem required_exact_724_i8 : required_724_i8 = + ((Finset.univ.biUnion childrenC_724_i8) ∪ commonEnvelope childrenD_724_i8).erase (7, 8) := by + exact required_eq_combination childrenC_724_i8 childrenD_724_i8 (7, 8) required_724_i8 + (by decide +kernel) child_required_sub_724_i8 common_sub_724_i8 required_origin_724_i8 +theorem envelope_origin_724_i8 : ∀ x ∈ envelope_724_i8, + x = (7, 8) ∨ ∃ j, x ∈ childrenD_724_i8 j := by decide +kernel +theorem envelope_exact_724_i8 : envelope_724_i8 = + insert (7, 8) (Finset.univ.biUnion childrenD_724_i8) := by + exact envelope_eq_combination childrenD_724_i8 (7, 8) envelope_724_i8 + pivot_mem_724_i8 child_envelope_sub_724_i8 envelope_origin_724_i8 +def checked_724_i8 : CheckedCard where + required := required_724_i8 + envelope := envelope_724_i8 + height := height_724_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_724_i8 +def height_724_i7 : ℕ := 10 +def childrenH_724_i7 : Fin 4 → ℕ := ![height_88, height_231, height_267, height_724_i8] +theorem height_exact_724_i7 : height_724_i7 = 1 + Finset.univ.sup childrenH_724_i7 := by decide +kernel +theorem required_origin_724_i7 : ∀ x ∈ required_724_i7, + (∃ j, x ∈ childrenC_724_i7 j) ∨ ∀ j, x ∈ childrenD_724_i7 j := by decide +kernel +theorem required_exact_724_i7 : required_724_i7 = + ((Finset.univ.biUnion childrenC_724_i7) ∪ commonEnvelope childrenD_724_i7).erase (4, 8) := by + exact required_eq_combination childrenC_724_i7 childrenD_724_i7 (4, 8) required_724_i7 + (by decide +kernel) child_required_sub_724_i7 common_sub_724_i7 required_origin_724_i7 +theorem envelope_origin_724_i7 : ∀ x ∈ envelope_724_i7, + x = (4, 8) ∨ ∃ j, x ∈ childrenD_724_i7 j := by decide +kernel +theorem envelope_exact_724_i7 : envelope_724_i7 = + insert (4, 8) (Finset.univ.biUnion childrenD_724_i7) := by + exact envelope_eq_combination childrenD_724_i7 (4, 8) envelope_724_i7 + pivot_mem_724_i7 child_envelope_sub_724_i7 envelope_origin_724_i7 +def checked_724_i7 : CheckedCard where + required := required_724_i7 + envelope := envelope_724_i7 + height := height_724_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_724_i7 +def height_724 : ℕ := 16 +def childrenH_724 : Fin 10 → ℕ := ![height_523, height_524, height_677, height_724_i0, height_724_i1, height_719, height_724_i5, height_724_i6, height_724_i7, height_723] +theorem height_exact_724 : height_724 = 1 + Finset.univ.sup childrenH_724 := by decide +kernel +theorem required_origin_724 : ∀ x ∈ required_724, + (∃ j, x ∈ childrenC_724 j) ∨ ∀ j, x ∈ childrenD_724 j := by decide +kernel +theorem required_exact_724 : required_724 = + ((Finset.univ.biUnion childrenC_724) ∪ commonEnvelope childrenD_724).erase (6, 8) := by + exact required_eq_combination childrenC_724 childrenD_724 (6, 8) required_724 + (by decide +kernel) child_required_sub_724 common_sub_724 required_origin_724 +theorem envelope_origin_724 : ∀ x ∈ envelope_724, + x = (6, 8) ∨ ∃ j, x ∈ childrenD_724 j := by decide +kernel +theorem envelope_exact_724 : envelope_724 = + insert (6, 8) (Finset.univ.biUnion childrenD_724) := by + exact envelope_eq_combination childrenD_724 (6, 8) envelope_724 + pivot_mem_724 child_envelope_sub_724 envelope_origin_724 +def checked_724 : CheckedCard where + required := required_724 + envelope := envelope_724 + height := height_724 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_724 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part01.lean new file mode 100644 index 0000000..691a17c --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part01.lean @@ -0,0 +1,701 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_623_i0 : Finset Cell := ⟨(([(5, 6), (5, 7), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_623_i0 : Finset Cell := ⟨(([(2, 7), (3, 7), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 3), (8, 4), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3), (9, 4), (9, 5), (9, 6), (9, 9), (10, 3)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_623_i0 : Fin 4 → Finset Cell := ![(placed21 2 (7, 3) required_188), (placed21 0 (4, 4) required_444), (placed21 4 (4, 9) required_606), (placed21 4 (4, 9) required_610)] +def childrenD_623_i0 : Fin 4 → Finset Cell := ![(placed21 2 (7, 3) envelope_188), (placed21 0 (4, 4) envelope_444), (placed21 4 (4, 9) envelope_606), (placed21 4 (4, 9) envelope_610)] +theorem common_sub_623_i0 : commonEnvelope childrenD_623_i0 ⊆ insert (5, 5) required_623_i0 := by decide +kernel +theorem child_required_sub_623_i0 : ∀ j, childrenC_623_i0 j ⊆ insert (5, 5) required_623_i0 := by decide +kernel +theorem child_envelope_sub_623_i0 : ∀ j, childrenD_623_i0 j ⊆ envelope_623_i0 := by decide +kernel +theorem pivot_mem_623_i0 : (5, 5) ∈ envelope_623_i0 := by decide +kernel +theorem children_work_623_i0 : ∀ j, Template HasSnaky 10 (childrenC_623_i0 j) (childrenD_623_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_188 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_444 0 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_606 4 (4, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_610 4 (4, 9)).mono (by decide +kernel) +theorem row_works_623_i0 : Template HasSnaky 11 required_623_i0 envelope_623_i0 := by + refine compose HasSnaky 10 childrenC_623_i0 childrenD_623_i0 children_work_623_i0 (5, 5) + required_623_i0 envelope_623_i0 pivot_mem_623_i0 child_required_sub_623_i0 child_envelope_sub_623_i0 ?_ + intro b hb + exact common_sub_623_i0 (mem_commonEnvelope childrenD_623_i0 b hb) +def required_623_i1 : Finset Cell := ⟨(([(5, 6), (5, 7), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_623_i1 : Finset Cell := ⟨(([(2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5), (3, 6), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (8, 6), (8, 7), (8, 8), (8, 9), (9, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_623_i1 : Fin 5 → Finset Cell := ![(placed21 7 (7, 8) required_137), (placed21 7 (7, 8) required_181), (placed21 6 (8, 9) required_363), (placed21 7 (7, 8) required_474), (placed21 4 (4, 9) required_606)] +def childrenD_623_i1 : Fin 5 → Finset Cell := ![(placed21 7 (7, 8) envelope_137), (placed21 7 (7, 8) envelope_181), (placed21 6 (8, 9) envelope_363), (placed21 7 (7, 8) envelope_474), (placed21 4 (4, 9) envelope_606)] +theorem common_sub_623_i1 : commonEnvelope childrenD_623_i1 ⊆ insert (5, 5) required_623_i1 := by decide +kernel +theorem child_required_sub_623_i1 : ∀ j, childrenC_623_i1 j ⊆ insert (5, 5) required_623_i1 := by decide +kernel +theorem child_envelope_sub_623_i1 : ∀ j, childrenD_623_i1 j ⊆ envelope_623_i1 := by decide +kernel +theorem pivot_mem_623_i1 : (5, 5) ∈ envelope_623_i1 := by decide +kernel +theorem children_work_623_i1 : ∀ j, Template HasSnaky 9 (childrenC_623_i1 j) (childrenD_623_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_137 7 (7, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_181 7 (7, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_363 6 (8, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_474 7 (7, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_606 4 (4, 9)).mono (by decide +kernel) +theorem row_works_623_i1 : Template HasSnaky 10 required_623_i1 envelope_623_i1 := by + refine compose HasSnaky 9 childrenC_623_i1 childrenD_623_i1 children_work_623_i1 (5, 5) + required_623_i1 envelope_623_i1 pivot_mem_623_i1 child_required_sub_623_i1 child_envelope_sub_623_i1 ?_ + intro b hb + exact common_sub_623_i1 (mem_commonEnvelope childrenD_623_i1 b hb) +def required_623_i4 : Finset Cell := ⟨(([(5, 6), (5, 7), (5, 8), (5, 9), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_623_i4 : Finset Cell := ⟨(([(4, 6), (4, 7), (4, 8), (4, 10), (4, 11), (4, 12), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 5), (6, 6), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_623_i4 : Fin 2 → Finset Cell := ![(placed21 2 (5, 6) required_27), (placed21 3 (4, 9) required_35)] +def childrenD_623_i4 : Fin 2 → Finset Cell := ![(placed21 2 (5, 6) envelope_27), (placed21 3 (4, 9) envelope_35)] +theorem common_sub_623_i4 : commonEnvelope childrenD_623_i4 ⊆ insert (4, 7) required_623_i4 := by decide +kernel +theorem child_required_sub_623_i4 : ∀ j, childrenC_623_i4 j ⊆ insert (4, 7) required_623_i4 := by decide +kernel +theorem child_envelope_sub_623_i4 : ∀ j, childrenD_623_i4 j ⊆ envelope_623_i4 := by decide +kernel +theorem pivot_mem_623_i4 : (4, 7) ∈ envelope_623_i4 := by decide +kernel +theorem children_work_623_i4 : ∀ j, Template HasSnaky 4 (childrenC_623_i4 j) (childrenD_623_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_27 2 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_35 3 (4, 9)).mono (by decide +kernel) +theorem row_works_623_i4 : Template HasSnaky 5 required_623_i4 envelope_623_i4 := by + refine compose HasSnaky 4 childrenC_623_i4 childrenD_623_i4 children_work_623_i4 (4, 7) + required_623_i4 envelope_623_i4 pivot_mem_623_i4 child_required_sub_623_i4 child_envelope_sub_623_i4 ?_ + intro b hb + exact common_sub_623_i4 (mem_commonEnvelope childrenD_623_i4 b hb) +def required_623_i3 : Finset Cell := ⟨(([(5, 6), (5, 7), (5, 8), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_623_i3 : Finset Cell := ⟨(([(4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 4), (6, 5), (6, 6), (7, 6), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_623_i3 : Fin 5 → Finset Cell := ![(placed21 4 (4, 10) required_9), (placed21 2 (8, 5) required_151), (placed21 2 (6, 4) required_186), (placed21 2 (5, 4) required_187), required_623_i4] +def childrenD_623_i3 : Fin 5 → Finset Cell := ![(placed21 4 (4, 10) envelope_9), (placed21 2 (8, 5) envelope_151), (placed21 2 (6, 4) envelope_186), (placed21 2 (5, 4) envelope_187), envelope_623_i4] +theorem common_sub_623_i3 : commonEnvelope childrenD_623_i3 ⊆ insert (5, 9) required_623_i3 := by decide +kernel +theorem child_required_sub_623_i3 : ∀ j, childrenC_623_i3 j ⊆ insert (5, 9) required_623_i3 := by decide +kernel +theorem child_envelope_sub_623_i3 : ∀ j, childrenD_623_i3 j ⊆ envelope_623_i3 := by decide +kernel +theorem pivot_mem_623_i3 : (5, 9) ∈ envelope_623_i3 := by decide +kernel +theorem children_work_623_i3 : ∀ j, Template HasSnaky 5 (childrenC_623_i3 j) (childrenD_623_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 4 (4, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_151 2 (8, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_186 2 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_187 2 (5, 4)).mono (by decide +kernel) + · exact row_works_623_i4.mono (by decide +kernel) +theorem row_works_623_i3 : Template HasSnaky 6 required_623_i3 envelope_623_i3 := by + refine compose HasSnaky 5 childrenC_623_i3 childrenD_623_i3 children_work_623_i3 (5, 9) + required_623_i3 envelope_623_i3 pivot_mem_623_i3 child_required_sub_623_i3 child_envelope_sub_623_i3 ?_ + intro b hb + exact common_sub_623_i3 (mem_commonEnvelope childrenD_623_i3 b hb) +def required_623_i5 : Finset Cell := ⟨(([(5, 6), (5, 7), (5, 8), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_623_i5 : Finset Cell := ⟨(([(3, 7), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 8), (6, 9), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6), (8, 7), (8, 8), (8, 9), (9, 5), (9, 6), (9, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_623_i5 : Fin 3 → Finset Cell := ![(placed21 3 (3, 9) required_179), (placed21 3 (4, 8) required_371), (placed21 4 (4, 9) required_443)] +def childrenD_623_i5 : Fin 3 → Finset Cell := ![(placed21 3 (3, 9) envelope_179), (placed21 3 (4, 8) envelope_371), (placed21 4 (4, 9) envelope_443)] +theorem common_sub_623_i5 : commonEnvelope childrenD_623_i5 ⊆ insert (5, 5) required_623_i5 := by decide +kernel +theorem child_required_sub_623_i5 : ∀ j, childrenC_623_i5 j ⊆ insert (5, 5) required_623_i5 := by decide +kernel +theorem child_envelope_sub_623_i5 : ∀ j, childrenD_623_i5 j ⊆ envelope_623_i5 := by decide +kernel +theorem pivot_mem_623_i5 : (5, 5) ∈ envelope_623_i5 := by decide +kernel +theorem children_work_623_i5 : ∀ j, Template HasSnaky 9 (childrenC_623_i5 j) (childrenD_623_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_179 3 (3, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_371 3 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_443 4 (4, 9)).mono (by decide +kernel) +theorem row_works_623_i5 : Template HasSnaky 10 required_623_i5 envelope_623_i5 := by + refine compose HasSnaky 9 childrenC_623_i5 childrenD_623_i5 children_work_623_i5 (5, 5) + required_623_i5 envelope_623_i5 pivot_mem_623_i5 child_required_sub_623_i5 child_envelope_sub_623_i5 ?_ + intro b hb + exact common_sub_623_i5 (mem_commonEnvelope childrenD_623_i5 b hb) +def required_623_i2 : Finset Cell := ⟨(([(5, 6), (5, 7), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_623_i2 : Finset Cell := ⟨(([(2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9), (4, 2), (4, 3), (4, 4), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 5), (9, 6), (9, 8), (9, 9), (9, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_623_i2 : Fin 7 → Finset Cell := ![(placed21 2 (6, 4) required_12), (placed21 2 (7, 4) required_188), (placed21 2 (8, 4) required_211), required_623_i3, (placed21 1 (2, 5) required_619), required_623_i5, (placed21 2 (8, 2) required_620)] +def childrenD_623_i2 : Fin 7 → Finset Cell := ![(placed21 2 (6, 4) envelope_12), (placed21 2 (7, 4) envelope_188), (placed21 2 (8, 4) envelope_211), envelope_623_i3, (placed21 1 (2, 5) envelope_619), envelope_623_i5, (placed21 2 (8, 2) envelope_620)] +theorem common_sub_623_i2 : commonEnvelope childrenD_623_i2 ⊆ insert (5, 8) required_623_i2 := by decide +kernel +theorem child_required_sub_623_i2 : ∀ j, childrenC_623_i2 j ⊆ insert (5, 8) required_623_i2 := by decide +kernel +theorem child_envelope_sub_623_i2 : ∀ j, childrenD_623_i2 j ⊆ envelope_623_i2 := by decide +kernel +theorem pivot_mem_623_i2 : (5, 8) ∈ envelope_623_i2 := by decide +kernel +theorem children_work_623_i2 : ∀ j, Template HasSnaky 10 (childrenC_623_i2 j) (childrenD_623_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 2 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_188 2 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_211 2 (8, 4)).mono (by decide +kernel) + · exact row_works_623_i3.mono (by decide +kernel) + · exact (placed21_template row_works_619 1 (2, 5)).mono (by decide +kernel) + · exact row_works_623_i5.mono (by decide +kernel) + · exact (placed21_template row_works_620 2 (8, 2)).mono (by decide +kernel) +theorem row_works_623_i2 : Template HasSnaky 11 required_623_i2 envelope_623_i2 := by + refine compose HasSnaky 10 childrenC_623_i2 childrenD_623_i2 children_work_623_i2 (5, 8) + required_623_i2 envelope_623_i2 pivot_mem_623_i2 child_required_sub_623_i2 child_envelope_sub_623_i2 ?_ + intro b hb + exact common_sub_623_i2 (mem_commonEnvelope childrenD_623_i2 b hb) +def required_623_i7 : Finset Cell := ⟨(([(5, 6), (5, 7), (5, 8), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_623_i7 : Finset Cell := ⟨(([(3, 7), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (6, 4), (6, 6), (6, 8), (6, 9), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 9), (9, 10), (9, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_623_i7 : Fin 3 → Finset Cell := ![(placed21 3 (3, 9) required_179), (placed21 3 (4, 8) required_197), (placed21 0 (4, 4) required_465)] +def childrenD_623_i7 : Fin 3 → Finset Cell := ![(placed21 3 (3, 9) envelope_179), (placed21 3 (4, 8) envelope_197), (placed21 0 (4, 4) envelope_465)] +theorem common_sub_623_i7 : commonEnvelope childrenD_623_i7 ⊆ insert (5, 5) required_623_i7 := by decide +kernel +theorem child_required_sub_623_i7 : ∀ j, childrenC_623_i7 j ⊆ insert (5, 5) required_623_i7 := by decide +kernel +theorem child_envelope_sub_623_i7 : ∀ j, childrenD_623_i7 j ⊆ envelope_623_i7 := by decide +kernel +theorem pivot_mem_623_i7 : (5, 5) ∈ envelope_623_i7 := by decide +kernel +theorem children_work_623_i7 : ∀ j, Template HasSnaky 6 (childrenC_623_i7 j) (childrenD_623_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_179 3 (3, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_197 3 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_465 0 (4, 4)).mono (by decide +kernel) +theorem row_works_623_i7 : Template HasSnaky 7 required_623_i7 envelope_623_i7 := by + refine compose HasSnaky 6 childrenC_623_i7 childrenD_623_i7 children_work_623_i7 (5, 5) + required_623_i7 envelope_623_i7 pivot_mem_623_i7 child_required_sub_623_i7 child_envelope_sub_623_i7 ?_ + intro b hb + exact common_sub_623_i7 (mem_commonEnvelope childrenD_623_i7 b hb) +def required_623_i6 : Finset Cell := ⟨(([(5, 6), (5, 7), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_623_i6 : Finset Cell := ⟨(([(1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 6), (6, 8), (6, 9), (6, 10), (6, 11), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 8), (9, 9), (9, 10), (9, 11), (10, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_623_i6 : Fin 6 → Finset Cell := ![(placed21 0 (4, 4) required_12), (placed21 1 (1, 5) required_322), (placed21 4 (4, 11) required_369), (placed21 1 (2, 5) required_435), required_623_i7, (placed21 6 (8, 11) required_622)] +def childrenD_623_i6 : Fin 6 → Finset Cell := ![(placed21 0 (4, 4) envelope_12), (placed21 1 (1, 5) envelope_322), (placed21 4 (4, 11) envelope_369), (placed21 1 (2, 5) envelope_435), envelope_623_i7, (placed21 6 (8, 11) envelope_622)] +theorem common_sub_623_i6 : commonEnvelope childrenD_623_i6 ⊆ insert (5, 8) required_623_i6 := by decide +kernel +theorem child_required_sub_623_i6 : ∀ j, childrenC_623_i6 j ⊆ insert (5, 8) required_623_i6 := by decide +kernel +theorem child_envelope_sub_623_i6 : ∀ j, childrenD_623_i6 j ⊆ envelope_623_i6 := by decide +kernel +theorem pivot_mem_623_i6 : (5, 8) ∈ envelope_623_i6 := by decide +kernel +theorem children_work_623_i6 : ∀ j, Template HasSnaky 9 (childrenC_623_i6 j) (childrenD_623_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 0 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_322 1 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_369 4 (4, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_435 1 (2, 5)).mono (by decide +kernel) + · exact row_works_623_i7.mono (by decide +kernel) + · exact (placed21_template row_works_622 6 (8, 11)).mono (by decide +kernel) +theorem row_works_623_i6 : Template HasSnaky 10 required_623_i6 envelope_623_i6 := by + refine compose HasSnaky 9 childrenC_623_i6 childrenD_623_i6 children_work_623_i6 (5, 8) + required_623_i6 envelope_623_i6 pivot_mem_623_i6 child_required_sub_623_i6 child_envelope_sub_623_i6 ?_ + intro b hb + exact common_sub_623_i6 (mem_commonEnvelope childrenD_623_i6 b hb) +def required_623 : Finset Cell := ⟨(([(5, 7), (8, 6), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_623 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (8, 3), (8, 4), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (9, 3), (9, 4), (9, 5), (9, 6), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (10, 3), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (14, 10), (14, 12)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_623 : Fin 11 → Finset Cell := ![(placed21 6 (9, 11) required_467), (placed21 1 (0, 3) required_602), (placed21 2 (6, 3) required_603), (placed21 5 (8, 4) required_605), (placed21 6 (9, 11) required_607), (placed21 6 (9, 11) required_608), required_623_i0, (placed21 6 (10, 10) required_618), required_623_i1, required_623_i2, required_623_i6] +def childrenD_623 : Fin 11 → Finset Cell := ![(placed21 6 (9, 11) envelope_467), (placed21 1 (0, 3) envelope_602), (placed21 2 (6, 3) envelope_603), (placed21 5 (8, 4) envelope_605), (placed21 6 (9, 11) envelope_607), (placed21 6 (9, 11) envelope_608), envelope_623_i0, (placed21 6 (10, 10) envelope_618), envelope_623_i1, envelope_623_i2, envelope_623_i6] +theorem common_sub_623 : commonEnvelope childrenD_623 ⊆ insert (5, 6) required_623 := by decide +kernel +theorem child_required_sub_623 : ∀ j, childrenC_623 j ⊆ insert (5, 6) required_623 := by decide +kernel +theorem child_envelope_sub_623 : ∀ j, childrenD_623 j ⊆ envelope_623 := by decide +kernel +theorem pivot_mem_623 : (5, 6) ∈ envelope_623 := by decide +kernel +theorem children_work_623 : ∀ j, Template HasSnaky 16 (childrenC_623 j) (childrenD_623 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_467 6 (9, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_602 1 (0, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_603 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_605 5 (8, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_607 6 (9, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_608 6 (9, 11)).mono (by decide +kernel) + · exact row_works_623_i0.mono (by decide +kernel) + · exact (placed21_template row_works_618 6 (10, 10)).mono (by decide +kernel) + · exact row_works_623_i1.mono (by decide +kernel) + · exact row_works_623_i2.mono (by decide +kernel) + · exact row_works_623_i6.mono (by decide +kernel) +theorem row_works_623 : Template HasSnaky 17 required_623 envelope_623 := by + refine compose HasSnaky 16 childrenC_623 childrenD_623 children_work_623 (5, 6) + required_623 envelope_623 pivot_mem_623 child_required_sub_623 child_envelope_sub_623 ?_ + intro b hb + exact common_sub_623 (mem_commonEnvelope childrenD_623 b hb) +def required_630_i0 : Finset Cell := ⟨(([(4, 6), (4, 7), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_630_i0 : Finset Cell := ⟨(([(1, 8), (1, 9), (2, 8), (2, 9), (3, 3), (3, 4), (3, 5), (3, 6), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (5, 3), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 8), (8, 9), (8, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_630_i0 : Fin 7 → Finset Cell := ![(placed21 0 (3, 4) required_12), (placed21 6 (5, 10) required_13), (placed21 6 (7, 9) required_355), (placed21 6 (7, 10) required_356), (placed21 2 (8, 5) required_434), (placed21 5 (7, 5) required_435), (placed21 4 (3, 10) required_441)] +def childrenD_630_i0 : Fin 7 → Finset Cell := ![(placed21 0 (3, 4) envelope_12), (placed21 6 (5, 10) envelope_13), (placed21 6 (7, 9) envelope_355), (placed21 6 (7, 10) envelope_356), (placed21 2 (8, 5) envelope_434), (placed21 5 (7, 5) envelope_435), (placed21 4 (3, 10) envelope_441)] +theorem common_sub_630_i0 : commonEnvelope childrenD_630_i0 ⊆ insert (4, 8) required_630_i0 := by decide +kernel +theorem child_required_sub_630_i0 : ∀ j, childrenC_630_i0 j ⊆ insert (4, 8) required_630_i0 := by decide +kernel +theorem child_envelope_sub_630_i0 : ∀ j, childrenD_630_i0 j ⊆ envelope_630_i0 := by decide +kernel +theorem pivot_mem_630_i0 : (4, 8) ∈ envelope_630_i0 := by decide +kernel +theorem children_work_630_i0 : ∀ j, Template HasSnaky 9 (childrenC_630_i0 j) (childrenD_630_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 0 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_13 6 (5, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_355 6 (7, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_356 6 (7, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_434 2 (8, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_441 4 (3, 10)).mono (by decide +kernel) +theorem row_works_630_i0 : Template HasSnaky 10 required_630_i0 envelope_630_i0 := by + refine compose HasSnaky 9 childrenC_630_i0 childrenD_630_i0 children_work_630_i0 (4, 8) + required_630_i0 envelope_630_i0 pivot_mem_630_i0 child_required_sub_630_i0 child_envelope_sub_630_i0 ?_ + intro b hb + exact common_sub_630_i0 (mem_commonEnvelope childrenD_630_i0 b hb) +def required_630_i1 : Finset Cell := ⟨(([(4, 6), (4, 7), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_630_i1 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 8), (3, 9), (3, 10), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 6), (7, 7), (7, 8), (7, 9), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_630_i1 : Fin 4 → Finset Cell := ![(placed21 0 (3, 3) required_13), (placed21 0 (3, 4) required_112), (placed21 6 (7, 9) required_363), (placed21 6 (7, 9) required_364)] +def childrenD_630_i1 : Fin 4 → Finset Cell := ![(placed21 0 (3, 3) envelope_13), (placed21 0 (3, 4) envelope_112), (placed21 6 (7, 9) envelope_363), (placed21 6 (7, 9) envelope_364)] +theorem common_sub_630_i1 : commonEnvelope childrenD_630_i1 ⊆ insert (4, 5) required_630_i1 := by decide +kernel +theorem child_required_sub_630_i1 : ∀ j, childrenC_630_i1 j ⊆ insert (4, 5) required_630_i1 := by decide +kernel +theorem child_envelope_sub_630_i1 : ∀ j, childrenD_630_i1 j ⊆ envelope_630_i1 := by decide +kernel +theorem pivot_mem_630_i1 : (4, 5) ∈ envelope_630_i1 := by decide +kernel +theorem children_work_630_i1 : ∀ j, Template HasSnaky 6 (childrenC_630_i1 j) (childrenD_630_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_112 0 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_363 6 (7, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_364 6 (7, 9)).mono (by decide +kernel) +theorem row_works_630_i1 : Template HasSnaky 7 required_630_i1 envelope_630_i1 := by + refine compose HasSnaky 6 childrenC_630_i1 childrenD_630_i1 children_work_630_i1 (4, 5) + required_630_i1 envelope_630_i1 pivot_mem_630_i1 child_required_sub_630_i1 child_envelope_sub_630_i1 ?_ + intro b hb + exact common_sub_630_i1 (mem_commonEnvelope childrenD_630_i1 b hb) +def required_630_i2 : Finset Cell := ⟨(([(4, 6), (4, 7), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_630_i2 : Finset Cell := ⟨(([(1, 8), (2, 5), (2, 8), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 8), (3, 9), (3, 10), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 4), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 6), (8, 9), (8, 10), (8, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_630_i2 : Fin 5 → Finset Cell := ![(placed21 0 (3, 4) required_112), (placed21 5 (6, 4) required_181), (placed21 3 (2, 8) required_181), (placed21 6 (8, 8) required_295), (placed21 0 (3, 4) required_466)] +def childrenD_630_i2 : Fin 5 → Finset Cell := ![(placed21 0 (3, 4) envelope_112), (placed21 5 (6, 4) envelope_181), (placed21 3 (2, 8) envelope_181), (placed21 6 (8, 8) envelope_295), (placed21 0 (3, 4) envelope_466)] +theorem common_sub_630_i2 : commonEnvelope childrenD_630_i2 ⊆ insert (4, 5) required_630_i2 := by decide +kernel +theorem child_required_sub_630_i2 : ∀ j, childrenC_630_i2 j ⊆ insert (4, 5) required_630_i2 := by decide +kernel +theorem child_envelope_sub_630_i2 : ∀ j, childrenD_630_i2 j ⊆ envelope_630_i2 := by decide +kernel +theorem pivot_mem_630_i2 : (4, 5) ∈ envelope_630_i2 := by decide +kernel +theorem children_work_630_i2 : ∀ j, Template HasSnaky 7 (childrenC_630_i2 j) (childrenD_630_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_112 0 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_181 5 (6, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_181 3 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_295 6 (8, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_466 0 (3, 4)).mono (by decide +kernel) +theorem row_works_630_i2 : Template HasSnaky 8 required_630_i2 envelope_630_i2 := by + refine compose HasSnaky 7 childrenC_630_i2 childrenD_630_i2 children_work_630_i2 (4, 5) + required_630_i2 envelope_630_i2 pivot_mem_630_i2 child_required_sub_630_i2 child_envelope_sub_630_i2 ?_ + intro b hb + exact common_sub_630_i2 (mem_commonEnvelope childrenD_630_i2 b hb) +def required_630_i4 : Finset Cell := ⟨(([(4, 5), (4, 6), (4, 7), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_630_i4 : Finset Cell := ⟨(([(3, 2), (3, 3), (3, 4), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 7), (5, 8), (6, 7), (7, 6), (7, 7), (8, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_630_i4 : Fin 2 → Finset Cell := ![(placed21 6 (5, 8) required_10), (placed21 3 (3, 7) required_34)] +def childrenD_630_i4 : Fin 2 → Finset Cell := ![(placed21 6 (5, 8) envelope_10), (placed21 3 (3, 7) envelope_34)] +theorem common_sub_630_i4 : commonEnvelope childrenD_630_i4 ⊆ insert (5, 7) required_630_i4 := by decide +kernel +theorem child_required_sub_630_i4 : ∀ j, childrenC_630_i4 j ⊆ insert (5, 7) required_630_i4 := by decide +kernel +theorem child_envelope_sub_630_i4 : ∀ j, childrenD_630_i4 j ⊆ envelope_630_i4 := by decide +kernel +theorem pivot_mem_630_i4 : (5, 7) ∈ envelope_630_i4 := by decide +kernel +theorem children_work_630_i4 : ∀ j, Template HasSnaky 4 (childrenC_630_i4 j) (childrenD_630_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 6 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_34 3 (3, 7)).mono (by decide +kernel) +theorem row_works_630_i4 : Template HasSnaky 5 required_630_i4 envelope_630_i4 := by + refine compose HasSnaky 4 childrenC_630_i4 childrenD_630_i4 children_work_630_i4 (5, 7) + required_630_i4 envelope_630_i4 pivot_mem_630_i4 child_required_sub_630_i4 child_envelope_sub_630_i4 ?_ + intro b hb + exact common_sub_630_i4 (mem_commonEnvelope childrenD_630_i4 b hb) +def required_630_i3 : Finset Cell := ⟨(([(4, 6), (4, 7), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_630_i3 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 3), (7, 4), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 3), (8, 4), (8, 5), (8, 6), (9, 5), (9, 6), (9, 7), (10, 5), (10, 6), (10, 7), (11, 5), (11, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_630_i3 : Fin 5 → Finset Cell := ![(placed21 0 (3, 4) required_112), (placed21 3 (1, 8) required_257), (placed21 7 (7, 7) required_398), required_630_i4, (placed21 0 (3, 3) required_628)] +def childrenD_630_i3 : Fin 5 → Finset Cell := ![(placed21 0 (3, 4) envelope_112), (placed21 3 (1, 8) envelope_257), (placed21 7 (7, 7) envelope_398), envelope_630_i4, (placed21 0 (3, 3) envelope_628)] +theorem common_sub_630_i3 : commonEnvelope childrenD_630_i3 ⊆ insert (4, 5) required_630_i3 := by decide +kernel +theorem child_required_sub_630_i3 : ∀ j, childrenC_630_i3 j ⊆ insert (4, 5) required_630_i3 := by decide +kernel +theorem child_envelope_sub_630_i3 : ∀ j, childrenD_630_i3 j ⊆ envelope_630_i3 := by decide +kernel +theorem pivot_mem_630_i3 : (4, 5) ∈ envelope_630_i3 := by decide +kernel +theorem children_work_630_i3 : ∀ j, Template HasSnaky 9 (childrenC_630_i3 j) (childrenD_630_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_112 0 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_257 3 (1, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_398 7 (7, 7)).mono (by decide +kernel) + · exact row_works_630_i4.mono (by decide +kernel) + · exact (placed21_template row_works_628 0 (3, 3)).mono (by decide +kernel) +theorem row_works_630_i3 : Template HasSnaky 10 required_630_i3 envelope_630_i3 := by + refine compose HasSnaky 9 childrenC_630_i3 childrenD_630_i3 children_work_630_i3 (4, 5) + required_630_i3 envelope_630_i3 pivot_mem_630_i3 child_required_sub_630_i3 child_envelope_sub_630_i3 ?_ + intro b hb + exact common_sub_630_i3 (mem_commonEnvelope childrenD_630_i3 b hb) +def required_630 : Finset Cell := ⟨(([(4, 7), (7, 6), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_630 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (1, 8), (1, 9), (1, 10), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 8), (2, 9), (2, 10), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 3), (7, 4), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (8, 3), (8, 4), (8, 5), (8, 6), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (11, 5), (11, 7), (11, 8), (11, 9), (11, 10), (12, 8), (12, 9), (12, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_630 : Fin 9 → Finset Cell := ![(placed21 2 (8, 3) required_368), (placed21 6 (8, 10) required_368), required_630_i0, (placed21 6 (8, 11) required_467), (placed21 0 (1, 3) required_627), required_630_i1, required_630_i2, (placed21 4 (1, 10) required_629), required_630_i3] +def childrenD_630 : Fin 9 → Finset Cell := ![(placed21 2 (8, 3) envelope_368), (placed21 6 (8, 10) envelope_368), envelope_630_i0, (placed21 6 (8, 11) envelope_467), (placed21 0 (1, 3) envelope_627), envelope_630_i1, envelope_630_i2, (placed21 4 (1, 10) envelope_629), envelope_630_i3] +theorem common_sub_630 : commonEnvelope childrenD_630 ⊆ insert (4, 6) required_630 := by decide +kernel +theorem child_required_sub_630 : ∀ j, childrenC_630 j ⊆ insert (4, 6) required_630 := by decide +kernel +theorem child_envelope_sub_630 : ∀ j, childrenD_630 j ⊆ envelope_630 := by decide +kernel +theorem pivot_mem_630 : (4, 6) ∈ envelope_630 := by decide +kernel +theorem children_work_630 : ∀ j, Template HasSnaky 16 (childrenC_630 j) (childrenD_630 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_368 2 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_368 6 (8, 10)).mono (by decide +kernel) + · exact row_works_630_i0.mono (by decide +kernel) + · exact (placed21_template row_works_467 6 (8, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_627 0 (1, 3)).mono (by decide +kernel) + · exact row_works_630_i1.mono (by decide +kernel) + · exact row_works_630_i2.mono (by decide +kernel) + · exact (placed21_template row_works_629 4 (1, 10)).mono (by decide +kernel) + · exact row_works_630_i3.mono (by decide +kernel) +theorem row_works_630 : Template HasSnaky 17 required_630 envelope_630 := by + refine compose HasSnaky 16 childrenC_630 childrenD_630 children_work_630 (4, 6) + required_630 envelope_630 pivot_mem_630 child_required_sub_630 child_envelope_sub_630 ?_ + intro b hb + exact common_sub_630 (mem_commonEnvelope childrenD_630 b hb) +def height_623_i0 : ℕ := 11 +def childrenH_623_i0 : Fin 4 → ℕ := ![height_188, height_444, height_606, height_610] +theorem height_exact_623_i0 : height_623_i0 = 1 + Finset.univ.sup childrenH_623_i0 := by decide +kernel +theorem required_origin_623_i0 : ∀ x ∈ required_623_i0, + (∃ j, x ∈ childrenC_623_i0 j) ∨ ∀ j, x ∈ childrenD_623_i0 j := by decide +kernel +theorem required_exact_623_i0 : required_623_i0 = + ((Finset.univ.biUnion childrenC_623_i0) ∪ commonEnvelope childrenD_623_i0).erase (5, 5) := by + exact required_eq_combination childrenC_623_i0 childrenD_623_i0 (5, 5) required_623_i0 + (by decide +kernel) child_required_sub_623_i0 common_sub_623_i0 required_origin_623_i0 +theorem envelope_origin_623_i0 : ∀ x ∈ envelope_623_i0, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_623_i0 j := by decide +kernel +theorem envelope_exact_623_i0 : envelope_623_i0 = + insert (5, 5) (Finset.univ.biUnion childrenD_623_i0) := by + exact envelope_eq_combination childrenD_623_i0 (5, 5) envelope_623_i0 + pivot_mem_623_i0 child_envelope_sub_623_i0 envelope_origin_623_i0 +def checked_623_i0 : CheckedCard where + required := required_623_i0 + envelope := envelope_623_i0 + height := height_623_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_623_i0 +def height_623_i1 : ℕ := 10 +def childrenH_623_i1 : Fin 5 → ℕ := ![height_137, height_181, height_363, height_474, height_606] +theorem height_exact_623_i1 : height_623_i1 = 1 + Finset.univ.sup childrenH_623_i1 := by decide +kernel +theorem required_origin_623_i1 : ∀ x ∈ required_623_i1, + (∃ j, x ∈ childrenC_623_i1 j) ∨ ∀ j, x ∈ childrenD_623_i1 j := by decide +kernel +theorem required_exact_623_i1 : required_623_i1 = + ((Finset.univ.biUnion childrenC_623_i1) ∪ commonEnvelope childrenD_623_i1).erase (5, 5) := by + exact required_eq_combination childrenC_623_i1 childrenD_623_i1 (5, 5) required_623_i1 + (by decide +kernel) child_required_sub_623_i1 common_sub_623_i1 required_origin_623_i1 +theorem envelope_origin_623_i1 : ∀ x ∈ envelope_623_i1, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_623_i1 j := by decide +kernel +theorem envelope_exact_623_i1 : envelope_623_i1 = + insert (5, 5) (Finset.univ.biUnion childrenD_623_i1) := by + exact envelope_eq_combination childrenD_623_i1 (5, 5) envelope_623_i1 + pivot_mem_623_i1 child_envelope_sub_623_i1 envelope_origin_623_i1 +def checked_623_i1 : CheckedCard where + required := required_623_i1 + envelope := envelope_623_i1 + height := height_623_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_623_i1 +def height_623_i4 : ℕ := 5 +def childrenH_623_i4 : Fin 2 → ℕ := ![height_27, height_35] +theorem height_exact_623_i4 : height_623_i4 = 1 + Finset.univ.sup childrenH_623_i4 := by decide +kernel +theorem required_origin_623_i4 : ∀ x ∈ required_623_i4, + (∃ j, x ∈ childrenC_623_i4 j) ∨ ∀ j, x ∈ childrenD_623_i4 j := by decide +kernel +theorem required_exact_623_i4 : required_623_i4 = + ((Finset.univ.biUnion childrenC_623_i4) ∪ commonEnvelope childrenD_623_i4).erase (4, 7) := by + exact required_eq_combination childrenC_623_i4 childrenD_623_i4 (4, 7) required_623_i4 + (by decide +kernel) child_required_sub_623_i4 common_sub_623_i4 required_origin_623_i4 +theorem envelope_origin_623_i4 : ∀ x ∈ envelope_623_i4, + x = (4, 7) ∨ ∃ j, x ∈ childrenD_623_i4 j := by decide +kernel +theorem envelope_exact_623_i4 : envelope_623_i4 = + insert (4, 7) (Finset.univ.biUnion childrenD_623_i4) := by + exact envelope_eq_combination childrenD_623_i4 (4, 7) envelope_623_i4 + pivot_mem_623_i4 child_envelope_sub_623_i4 envelope_origin_623_i4 +def checked_623_i4 : CheckedCard where + required := required_623_i4 + envelope := envelope_623_i4 + height := height_623_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_623_i4 +def height_623_i3 : ℕ := 6 +def childrenH_623_i3 : Fin 5 → ℕ := ![height_9, height_151, height_186, height_187, height_623_i4] +theorem height_exact_623_i3 : height_623_i3 = 1 + Finset.univ.sup childrenH_623_i3 := by decide +kernel +theorem required_origin_623_i3 : ∀ x ∈ required_623_i3, + (∃ j, x ∈ childrenC_623_i3 j) ∨ ∀ j, x ∈ childrenD_623_i3 j := by decide +kernel +theorem required_exact_623_i3 : required_623_i3 = + ((Finset.univ.biUnion childrenC_623_i3) ∪ commonEnvelope childrenD_623_i3).erase (5, 9) := by + exact required_eq_combination childrenC_623_i3 childrenD_623_i3 (5, 9) required_623_i3 + (by decide +kernel) child_required_sub_623_i3 common_sub_623_i3 required_origin_623_i3 +theorem envelope_origin_623_i3 : ∀ x ∈ envelope_623_i3, + x = (5, 9) ∨ ∃ j, x ∈ childrenD_623_i3 j := by decide +kernel +theorem envelope_exact_623_i3 : envelope_623_i3 = + insert (5, 9) (Finset.univ.biUnion childrenD_623_i3) := by + exact envelope_eq_combination childrenD_623_i3 (5, 9) envelope_623_i3 + pivot_mem_623_i3 child_envelope_sub_623_i3 envelope_origin_623_i3 +def checked_623_i3 : CheckedCard where + required := required_623_i3 + envelope := envelope_623_i3 + height := height_623_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_623_i3 +def height_623_i5 : ℕ := 10 +def childrenH_623_i5 : Fin 3 → ℕ := ![height_179, height_371, height_443] +theorem height_exact_623_i5 : height_623_i5 = 1 + Finset.univ.sup childrenH_623_i5 := by decide +kernel +theorem required_origin_623_i5 : ∀ x ∈ required_623_i5, + (∃ j, x ∈ childrenC_623_i5 j) ∨ ∀ j, x ∈ childrenD_623_i5 j := by decide +kernel +theorem required_exact_623_i5 : required_623_i5 = + ((Finset.univ.biUnion childrenC_623_i5) ∪ commonEnvelope childrenD_623_i5).erase (5, 5) := by + exact required_eq_combination childrenC_623_i5 childrenD_623_i5 (5, 5) required_623_i5 + (by decide +kernel) child_required_sub_623_i5 common_sub_623_i5 required_origin_623_i5 +theorem envelope_origin_623_i5 : ∀ x ∈ envelope_623_i5, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_623_i5 j := by decide +kernel +theorem envelope_exact_623_i5 : envelope_623_i5 = + insert (5, 5) (Finset.univ.biUnion childrenD_623_i5) := by + exact envelope_eq_combination childrenD_623_i5 (5, 5) envelope_623_i5 + pivot_mem_623_i5 child_envelope_sub_623_i5 envelope_origin_623_i5 +def checked_623_i5 : CheckedCard where + required := required_623_i5 + envelope := envelope_623_i5 + height := height_623_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_623_i5 +def height_623_i2 : ℕ := 11 +def childrenH_623_i2 : Fin 7 → ℕ := ![height_12, height_188, height_211, height_623_i3, height_619, height_623_i5, height_620] +theorem height_exact_623_i2 : height_623_i2 = 1 + Finset.univ.sup childrenH_623_i2 := by decide +kernel +theorem required_origin_623_i2 : ∀ x ∈ required_623_i2, + (∃ j, x ∈ childrenC_623_i2 j) ∨ ∀ j, x ∈ childrenD_623_i2 j := by decide +kernel +theorem required_exact_623_i2 : required_623_i2 = + ((Finset.univ.biUnion childrenC_623_i2) ∪ commonEnvelope childrenD_623_i2).erase (5, 8) := by + exact required_eq_combination childrenC_623_i2 childrenD_623_i2 (5, 8) required_623_i2 + (by decide +kernel) child_required_sub_623_i2 common_sub_623_i2 required_origin_623_i2 +theorem envelope_origin_623_i2 : ∀ x ∈ envelope_623_i2, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_623_i2 j := by decide +kernel +theorem envelope_exact_623_i2 : envelope_623_i2 = + insert (5, 8) (Finset.univ.biUnion childrenD_623_i2) := by + exact envelope_eq_combination childrenD_623_i2 (5, 8) envelope_623_i2 + pivot_mem_623_i2 child_envelope_sub_623_i2 envelope_origin_623_i2 +def checked_623_i2 : CheckedCard where + required := required_623_i2 + envelope := envelope_623_i2 + height := height_623_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_623_i2 +def height_623_i7 : ℕ := 7 +def childrenH_623_i7 : Fin 3 → ℕ := ![height_179, height_197, height_465] +theorem height_exact_623_i7 : height_623_i7 = 1 + Finset.univ.sup childrenH_623_i7 := by decide +kernel +theorem required_origin_623_i7 : ∀ x ∈ required_623_i7, + (∃ j, x ∈ childrenC_623_i7 j) ∨ ∀ j, x ∈ childrenD_623_i7 j := by decide +kernel +theorem required_exact_623_i7 : required_623_i7 = + ((Finset.univ.biUnion childrenC_623_i7) ∪ commonEnvelope childrenD_623_i7).erase (5, 5) := by + exact required_eq_combination childrenC_623_i7 childrenD_623_i7 (5, 5) required_623_i7 + (by decide +kernel) child_required_sub_623_i7 common_sub_623_i7 required_origin_623_i7 +theorem envelope_origin_623_i7 : ∀ x ∈ envelope_623_i7, + x = (5, 5) ∨ ∃ j, x ∈ childrenD_623_i7 j := by decide +kernel +theorem envelope_exact_623_i7 : envelope_623_i7 = + insert (5, 5) (Finset.univ.biUnion childrenD_623_i7) := by + exact envelope_eq_combination childrenD_623_i7 (5, 5) envelope_623_i7 + pivot_mem_623_i7 child_envelope_sub_623_i7 envelope_origin_623_i7 +def checked_623_i7 : CheckedCard where + required := required_623_i7 + envelope := envelope_623_i7 + height := height_623_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_623_i7 +def height_623_i6 : ℕ := 10 +def childrenH_623_i6 : Fin 6 → ℕ := ![height_12, height_322, height_369, height_435, height_623_i7, height_622] +theorem height_exact_623_i6 : height_623_i6 = 1 + Finset.univ.sup childrenH_623_i6 := by decide +kernel +theorem required_origin_623_i6 : ∀ x ∈ required_623_i6, + (∃ j, x ∈ childrenC_623_i6 j) ∨ ∀ j, x ∈ childrenD_623_i6 j := by decide +kernel +theorem required_exact_623_i6 : required_623_i6 = + ((Finset.univ.biUnion childrenC_623_i6) ∪ commonEnvelope childrenD_623_i6).erase (5, 8) := by + exact required_eq_combination childrenC_623_i6 childrenD_623_i6 (5, 8) required_623_i6 + (by decide +kernel) child_required_sub_623_i6 common_sub_623_i6 required_origin_623_i6 +theorem envelope_origin_623_i6 : ∀ x ∈ envelope_623_i6, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_623_i6 j := by decide +kernel +theorem envelope_exact_623_i6 : envelope_623_i6 = + insert (5, 8) (Finset.univ.biUnion childrenD_623_i6) := by + exact envelope_eq_combination childrenD_623_i6 (5, 8) envelope_623_i6 + pivot_mem_623_i6 child_envelope_sub_623_i6 envelope_origin_623_i6 +def checked_623_i6 : CheckedCard where + required := required_623_i6 + envelope := envelope_623_i6 + height := height_623_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_623_i6 +def height_623 : ℕ := 17 +def childrenH_623 : Fin 11 → ℕ := ![height_467, height_602, height_603, height_605, height_607, height_608, height_623_i0, height_618, height_623_i1, height_623_i2, height_623_i6] +theorem height_exact_623 : height_623 = 1 + Finset.univ.sup childrenH_623 := by decide +kernel +theorem required_origin_623 : ∀ x ∈ required_623, + (∃ j, x ∈ childrenC_623 j) ∨ ∀ j, x ∈ childrenD_623 j := by decide +kernel +theorem required_exact_623 : required_623 = + ((Finset.univ.biUnion childrenC_623) ∪ commonEnvelope childrenD_623).erase (5, 6) := by + exact required_eq_combination childrenC_623 childrenD_623 (5, 6) required_623 + (by decide +kernel) child_required_sub_623 common_sub_623 required_origin_623 +theorem envelope_origin_623 : ∀ x ∈ envelope_623, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_623 j := by decide +kernel +theorem envelope_exact_623 : envelope_623 = + insert (5, 6) (Finset.univ.biUnion childrenD_623) := by + exact envelope_eq_combination childrenD_623 (5, 6) envelope_623 + pivot_mem_623 child_envelope_sub_623 envelope_origin_623 +def checked_623 : CheckedCard where + required := required_623 + envelope := envelope_623 + height := height_623 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_623 +def height_630_i0 : ℕ := 10 +def childrenH_630_i0 : Fin 7 → ℕ := ![height_12, height_13, height_355, height_356, height_434, height_435, height_441] +theorem height_exact_630_i0 : height_630_i0 = 1 + Finset.univ.sup childrenH_630_i0 := by decide +kernel +theorem required_origin_630_i0 : ∀ x ∈ required_630_i0, + (∃ j, x ∈ childrenC_630_i0 j) ∨ ∀ j, x ∈ childrenD_630_i0 j := by decide +kernel +theorem required_exact_630_i0 : required_630_i0 = + ((Finset.univ.biUnion childrenC_630_i0) ∪ commonEnvelope childrenD_630_i0).erase (4, 8) := by + exact required_eq_combination childrenC_630_i0 childrenD_630_i0 (4, 8) required_630_i0 + (by decide +kernel) child_required_sub_630_i0 common_sub_630_i0 required_origin_630_i0 +theorem envelope_origin_630_i0 : ∀ x ∈ envelope_630_i0, + x = (4, 8) ∨ ∃ j, x ∈ childrenD_630_i0 j := by decide +kernel +theorem envelope_exact_630_i0 : envelope_630_i0 = + insert (4, 8) (Finset.univ.biUnion childrenD_630_i0) := by + exact envelope_eq_combination childrenD_630_i0 (4, 8) envelope_630_i0 + pivot_mem_630_i0 child_envelope_sub_630_i0 envelope_origin_630_i0 +def checked_630_i0 : CheckedCard where + required := required_630_i0 + envelope := envelope_630_i0 + height := height_630_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_630_i0 +def height_630_i1 : ℕ := 7 +def childrenH_630_i1 : Fin 4 → ℕ := ![height_13, height_112, height_363, height_364] +theorem height_exact_630_i1 : height_630_i1 = 1 + Finset.univ.sup childrenH_630_i1 := by decide +kernel +theorem required_origin_630_i1 : ∀ x ∈ required_630_i1, + (∃ j, x ∈ childrenC_630_i1 j) ∨ ∀ j, x ∈ childrenD_630_i1 j := by decide +kernel +theorem required_exact_630_i1 : required_630_i1 = + ((Finset.univ.biUnion childrenC_630_i1) ∪ commonEnvelope childrenD_630_i1).erase (4, 5) := by + exact required_eq_combination childrenC_630_i1 childrenD_630_i1 (4, 5) required_630_i1 + (by decide +kernel) child_required_sub_630_i1 common_sub_630_i1 required_origin_630_i1 +theorem envelope_origin_630_i1 : ∀ x ∈ envelope_630_i1, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_630_i1 j := by decide +kernel +theorem envelope_exact_630_i1 : envelope_630_i1 = + insert (4, 5) (Finset.univ.biUnion childrenD_630_i1) := by + exact envelope_eq_combination childrenD_630_i1 (4, 5) envelope_630_i1 + pivot_mem_630_i1 child_envelope_sub_630_i1 envelope_origin_630_i1 +def checked_630_i1 : CheckedCard where + required := required_630_i1 + envelope := envelope_630_i1 + height := height_630_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_630_i1 +def height_630_i2 : ℕ := 8 +def childrenH_630_i2 : Fin 5 → ℕ := ![height_112, height_181, height_181, height_295, height_466] +theorem height_exact_630_i2 : height_630_i2 = 1 + Finset.univ.sup childrenH_630_i2 := by decide +kernel +theorem required_origin_630_i2 : ∀ x ∈ required_630_i2, + (∃ j, x ∈ childrenC_630_i2 j) ∨ ∀ j, x ∈ childrenD_630_i2 j := by decide +kernel +theorem required_exact_630_i2 : required_630_i2 = + ((Finset.univ.biUnion childrenC_630_i2) ∪ commonEnvelope childrenD_630_i2).erase (4, 5) := by + exact required_eq_combination childrenC_630_i2 childrenD_630_i2 (4, 5) required_630_i2 + (by decide +kernel) child_required_sub_630_i2 common_sub_630_i2 required_origin_630_i2 +theorem envelope_origin_630_i2 : ∀ x ∈ envelope_630_i2, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_630_i2 j := by decide +kernel +theorem envelope_exact_630_i2 : envelope_630_i2 = + insert (4, 5) (Finset.univ.biUnion childrenD_630_i2) := by + exact envelope_eq_combination childrenD_630_i2 (4, 5) envelope_630_i2 + pivot_mem_630_i2 child_envelope_sub_630_i2 envelope_origin_630_i2 +def checked_630_i2 : CheckedCard where + required := required_630_i2 + envelope := envelope_630_i2 + height := height_630_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_630_i2 +def height_630_i4 : ℕ := 5 +def childrenH_630_i4 : Fin 2 → ℕ := ![height_10, height_34] +theorem height_exact_630_i4 : height_630_i4 = 1 + Finset.univ.sup childrenH_630_i4 := by decide +kernel +theorem required_origin_630_i4 : ∀ x ∈ required_630_i4, + (∃ j, x ∈ childrenC_630_i4 j) ∨ ∀ j, x ∈ childrenD_630_i4 j := by decide +kernel +theorem required_exact_630_i4 : required_630_i4 = + ((Finset.univ.biUnion childrenC_630_i4) ∪ commonEnvelope childrenD_630_i4).erase (5, 7) := by + exact required_eq_combination childrenC_630_i4 childrenD_630_i4 (5, 7) required_630_i4 + (by decide +kernel) child_required_sub_630_i4 common_sub_630_i4 required_origin_630_i4 +theorem envelope_origin_630_i4 : ∀ x ∈ envelope_630_i4, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_630_i4 j := by decide +kernel +theorem envelope_exact_630_i4 : envelope_630_i4 = + insert (5, 7) (Finset.univ.biUnion childrenD_630_i4) := by + exact envelope_eq_combination childrenD_630_i4 (5, 7) envelope_630_i4 + pivot_mem_630_i4 child_envelope_sub_630_i4 envelope_origin_630_i4 +def checked_630_i4 : CheckedCard where + required := required_630_i4 + envelope := envelope_630_i4 + height := height_630_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_630_i4 +def height_630_i3 : ℕ := 10 +def childrenH_630_i3 : Fin 5 → ℕ := ![height_112, height_257, height_398, height_630_i4, height_628] +theorem height_exact_630_i3 : height_630_i3 = 1 + Finset.univ.sup childrenH_630_i3 := by decide +kernel +theorem required_origin_630_i3 : ∀ x ∈ required_630_i3, + (∃ j, x ∈ childrenC_630_i3 j) ∨ ∀ j, x ∈ childrenD_630_i3 j := by decide +kernel +theorem required_exact_630_i3 : required_630_i3 = + ((Finset.univ.biUnion childrenC_630_i3) ∪ commonEnvelope childrenD_630_i3).erase (4, 5) := by + exact required_eq_combination childrenC_630_i3 childrenD_630_i3 (4, 5) required_630_i3 + (by decide +kernel) child_required_sub_630_i3 common_sub_630_i3 required_origin_630_i3 +theorem envelope_origin_630_i3 : ∀ x ∈ envelope_630_i3, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_630_i3 j := by decide +kernel +theorem envelope_exact_630_i3 : envelope_630_i3 = + insert (4, 5) (Finset.univ.biUnion childrenD_630_i3) := by + exact envelope_eq_combination childrenD_630_i3 (4, 5) envelope_630_i3 + pivot_mem_630_i3 child_envelope_sub_630_i3 envelope_origin_630_i3 +def checked_630_i3 : CheckedCard where + required := required_630_i3 + envelope := envelope_630_i3 + height := height_630_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_630_i3 +def height_630 : ℕ := 17 +def childrenH_630 : Fin 9 → ℕ := ![height_368, height_368, height_630_i0, height_467, height_627, height_630_i1, height_630_i2, height_629, height_630_i3] +theorem height_exact_630 : height_630 = 1 + Finset.univ.sup childrenH_630 := by decide +kernel +theorem required_origin_630 : ∀ x ∈ required_630, + (∃ j, x ∈ childrenC_630 j) ∨ ∀ j, x ∈ childrenD_630 j := by decide +kernel +theorem required_exact_630 : required_630 = + ((Finset.univ.biUnion childrenC_630) ∪ commonEnvelope childrenD_630).erase (4, 6) := by + exact required_eq_combination childrenC_630 childrenD_630 (4, 6) required_630 + (by decide +kernel) child_required_sub_630 common_sub_630 required_origin_630 +theorem envelope_origin_630 : ∀ x ∈ envelope_630, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_630 j := by decide +kernel +theorem envelope_exact_630 : envelope_630 = + insert (4, 6) (Finset.univ.biUnion childrenD_630) := by + exact envelope_eq_combination childrenD_630 (4, 6) envelope_630 + pivot_mem_630 child_envelope_sub_630 envelope_origin_630 +def checked_630 : CheckedCard where + required := required_630 + envelope := envelope_630 + height := height_630 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_630 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part02.lean new file mode 100644 index 0000000..a8def25 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part02.lean @@ -0,0 +1,477 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_707_i0 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_707_i0 : Finset Cell := ⟨(([(0, 6), (1, 6), (1, 7), (1, 8), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 6), (7, 7), (7, 8), (8, 6), (8, 7), (8, 8), (9, 6), (9, 7), (9, 8), (10, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_707_i0 : Fin 7 → Finset Cell := ![(placed21 3 (2, 8) required_116), (placed21 5 (7, 4) required_134), (placed21 5 (7, 4) required_180), (placed21 0 (4, 2) required_337), (placed21 5 (8, 4) required_435), (placed21 5 (7, 5) required_558), (placed21 1 (0, 3) required_662)] +def childrenD_707_i0 : Fin 7 → Finset Cell := ![(placed21 3 (2, 8) envelope_116), (placed21 5 (7, 4) envelope_134), (placed21 5 (7, 4) envelope_180), (placed21 0 (4, 2) envelope_337), (placed21 5 (8, 4) envelope_435), (placed21 5 (7, 5) envelope_558), (placed21 1 (0, 3) envelope_662)] +theorem common_sub_707_i0 : commonEnvelope childrenD_707_i0 ⊆ insert (5, 7) required_707_i0 := by decide +kernel +theorem child_required_sub_707_i0 : ∀ j, childrenC_707_i0 j ⊆ insert (5, 7) required_707_i0 := by decide +kernel +theorem child_envelope_sub_707_i0 : ∀ j, childrenD_707_i0 j ⊆ envelope_707_i0 := by decide +kernel +theorem pivot_mem_707_i0 : (5, 7) ∈ envelope_707_i0 := by decide +kernel +theorem children_work_707_i0 : ∀ j, Template HasSnaky 9 (childrenC_707_i0 j) (childrenD_707_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_116 3 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_134 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_180 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_337 0 (4, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (8, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_558 5 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_662 1 (0, 3)).mono (by decide +kernel) +theorem row_works_707_i0 : Template HasSnaky 10 required_707_i0 envelope_707_i0 := by + refine compose HasSnaky 9 childrenC_707_i0 childrenD_707_i0 children_work_707_i0 (5, 7) + required_707_i0 envelope_707_i0 pivot_mem_707_i0 child_required_sub_707_i0 child_envelope_sub_707_i0 ?_ + intro b hb + exact common_sub_707_i0 (mem_commonEnvelope childrenD_707_i0 b hb) +def required_707_i2 : Finset Cell := ⟨(([(4, 5), (5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_707_i2 : Finset Cell := ⟨(([(1, 6), (1, 8), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_707_i2 : Fin 3 → Finset Cell := ![(placed21 0 (5, 3) required_7), (placed21 2 (6, 3) required_9), (placed21 5 (6, 4) required_380)] +def childrenD_707_i2 : Fin 3 → Finset Cell := ![(placed21 0 (5, 3) envelope_7), (placed21 2 (6, 3) envelope_9), (placed21 5 (6, 4) envelope_380)] +theorem common_sub_707_i2 : commonEnvelope childrenD_707_i2 ⊆ insert (5, 7) required_707_i2 := by decide +kernel +theorem child_required_sub_707_i2 : ∀ j, childrenC_707_i2 j ⊆ insert (5, 7) required_707_i2 := by decide +kernel +theorem child_envelope_sub_707_i2 : ∀ j, childrenD_707_i2 j ⊆ envelope_707_i2 := by decide +kernel +theorem pivot_mem_707_i2 : (5, 7) ∈ envelope_707_i2 := by decide +kernel +theorem children_work_707_i2 : ∀ j, Template HasSnaky 9 (childrenC_707_i2 j) (childrenD_707_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_380 5 (6, 4)).mono (by decide +kernel) +theorem row_works_707_i2 : Template HasSnaky 10 required_707_i2 envelope_707_i2 := by + refine compose HasSnaky 9 childrenC_707_i2 childrenD_707_i2 children_work_707_i2 (5, 7) + required_707_i2 envelope_707_i2 pivot_mem_707_i2 child_required_sub_707_i2 child_envelope_sub_707_i2 ?_ + intro b hb + exact common_sub_707_i2 (mem_commonEnvelope childrenD_707_i2 b hb) +def required_707_i1 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_707_i1 : Finset Cell := ⟨(([(1, 2), (1, 4), (1, 6), (1, 8), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 2), (3, 3), (3, 4), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (8, 2), (8, 3), (8, 4), (9, 2), (9, 3), (9, 4), (10, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_707_i1 : Fin 4 → Finset Cell := ![(placed21 6 (6, 8) required_14), (placed21 4 (4, 8) required_33), (placed21 3 (1, 7) required_322), required_707_i2] +def childrenD_707_i1 : Fin 4 → Finset Cell := ![(placed21 6 (6, 8) envelope_14), (placed21 4 (4, 8) envelope_33), (placed21 3 (1, 7) envelope_322), envelope_707_i2] +theorem common_sub_707_i1 : commonEnvelope childrenD_707_i1 ⊆ insert (5, 4) required_707_i1 := by decide +kernel +theorem child_required_sub_707_i1 : ∀ j, childrenC_707_i1 j ⊆ insert (5, 4) required_707_i1 := by decide +kernel +theorem child_envelope_sub_707_i1 : ∀ j, childrenD_707_i1 j ⊆ envelope_707_i1 := by decide +kernel +theorem pivot_mem_707_i1 : (5, 4) ∈ envelope_707_i1 := by decide +kernel +theorem children_work_707_i1 : ∀ j, Template HasSnaky 10 (childrenC_707_i1 j) (childrenD_707_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_14 6 (6, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_33 4 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_322 3 (1, 7)).mono (by decide +kernel) + · exact row_works_707_i2.mono (by decide +kernel) +theorem row_works_707_i1 : Template HasSnaky 11 required_707_i1 envelope_707_i1 := by + refine compose HasSnaky 10 childrenC_707_i1 childrenD_707_i1 children_work_707_i1 (5, 4) + required_707_i1 envelope_707_i1 pivot_mem_707_i1 child_required_sub_707_i1 child_envelope_sub_707_i1 ?_ + intro b hb + exact common_sub_707_i1 (mem_commonEnvelope childrenD_707_i1 b hb) +def required_707_i4 : Finset Cell := ⟨(([(5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_707_i4 : Finset Cell := ⟨(([(4, 1), (4, 2), (4, 3), (4, 5), (4, 7), (4, 8), (4, 9), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (11, 2), (11, 3), (11, 4), (11, 5), (12, 2), (12, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_707_i4 : Fin 4 → Finset Cell := ![(placed21 0 (5, 3) required_7), (placed21 1 (4, 4) required_8), (placed21 2 (6, 3) required_9), (placed21 4 (4, 9) required_485)] +def childrenD_707_i4 : Fin 4 → Finset Cell := ![(placed21 0 (5, 3) envelope_7), (placed21 1 (4, 4) envelope_8), (placed21 2 (6, 3) envelope_9), (placed21 4 (4, 9) envelope_485)] +theorem common_sub_707_i4 : commonEnvelope childrenD_707_i4 ⊆ insert (5, 7) required_707_i4 := by decide +kernel +theorem child_required_sub_707_i4 : ∀ j, childrenC_707_i4 j ⊆ insert (5, 7) required_707_i4 := by decide +kernel +theorem child_envelope_sub_707_i4 : ∀ j, childrenD_707_i4 j ⊆ envelope_707_i4 := by decide +kernel +theorem pivot_mem_707_i4 : (5, 7) ∈ envelope_707_i4 := by decide +kernel +theorem children_work_707_i4 : ∀ j, Template HasSnaky 12 (childrenC_707_i4 j) (childrenD_707_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 0 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_9 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_485 4 (4, 9)).mono (by decide +kernel) +theorem row_works_707_i4 : Template HasSnaky 13 required_707_i4 envelope_707_i4 := by + refine compose HasSnaky 12 childrenC_707_i4 childrenD_707_i4 children_work_707_i4 (5, 7) + required_707_i4 envelope_707_i4 pivot_mem_707_i4 child_required_sub_707_i4 child_envelope_sub_707_i4 ?_ + intro b hb + exact common_sub_707_i4 (mem_commonEnvelope childrenD_707_i4 b hb) +def required_707_i3 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_707_i3 : Finset Cell := ⟨(([(0, 6), (1, 2), (1, 4), (1, 6), (1, 7), (1, 8), (2, 2), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (3, 2), (3, 3), (3, 4), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (11, 2), (11, 3), (11, 4), (11, 5), (12, 2), (12, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_707_i3 : Fin 5 → Finset Cell := ![(placed21 4 (3, 7) required_136), (placed21 0 (3, 2) required_267), (placed21 3 (1, 7) required_322), (placed21 5 (9, 3) required_322), required_707_i4] +def childrenD_707_i3 : Fin 5 → Finset Cell := ![(placed21 4 (3, 7) envelope_136), (placed21 0 (3, 2) envelope_267), (placed21 3 (1, 7) envelope_322), (placed21 5 (9, 3) envelope_322), envelope_707_i4] +theorem common_sub_707_i3 : commonEnvelope childrenD_707_i3 ⊆ insert (5, 4) required_707_i3 := by decide +kernel +theorem child_required_sub_707_i3 : ∀ j, childrenC_707_i3 j ⊆ insert (5, 4) required_707_i3 := by decide +kernel +theorem child_envelope_sub_707_i3 : ∀ j, childrenD_707_i3 j ⊆ envelope_707_i3 := by decide +kernel +theorem pivot_mem_707_i3 : (5, 4) ∈ envelope_707_i3 := by decide +kernel +theorem children_work_707_i3 : ∀ j, Template HasSnaky 13 (childrenC_707_i3 j) (childrenD_707_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_136 4 (3, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_267 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_322 3 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_322 5 (9, 3)).mono (by decide +kernel) + · exact row_works_707_i4.mono (by decide +kernel) +theorem row_works_707_i3 : Template HasSnaky 14 required_707_i3 envelope_707_i3 := by + refine compose HasSnaky 13 childrenC_707_i3 childrenD_707_i3 children_work_707_i3 (5, 4) + required_707_i3 envelope_707_i3 pivot_mem_707_i3 child_required_sub_707_i3 child_envelope_sub_707_i3 ?_ + intro b hb + exact common_sub_707_i3 (mem_commonEnvelope childrenD_707_i3 b hb) +def required_707_i6 : Finset Cell := ⟨(([(5, 4), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_707_i6 : Finset Cell := ⟨(([(2, 6), (3, 6), (3, 7), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 6), (7, 7), (7, 8), (8, 6), (8, 7), (8, 8), (9, 6), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_707_i6 : Fin 4 → Finset Cell := ![(placed21 2 (6, 3) required_9), (placed21 1 (2, 4) required_115), (placed21 5 (8, 3) required_302), (placed21 5 (8, 3) required_303)] +def childrenD_707_i6 : Fin 4 → Finset Cell := ![(placed21 2 (6, 3) envelope_9), (placed21 1 (2, 4) envelope_115), (placed21 5 (8, 3) envelope_302), (placed21 5 (8, 3) envelope_303)] +theorem common_sub_707_i6 : commonEnvelope childrenD_707_i6 ⊆ insert (5, 7) required_707_i6 := by decide +kernel +theorem child_required_sub_707_i6 : ∀ j, childrenC_707_i6 j ⊆ insert (5, 7) required_707_i6 := by decide +kernel +theorem child_envelope_sub_707_i6 : ∀ j, childrenD_707_i6 j ⊆ envelope_707_i6 := by decide +kernel +theorem pivot_mem_707_i6 : (5, 7) ∈ envelope_707_i6 := by decide +kernel +theorem children_work_707_i6 : ∀ j, Template HasSnaky 6 (childrenC_707_i6 j) (childrenD_707_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_9 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_115 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_302 5 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_303 5 (8, 3)).mono (by decide +kernel) +theorem row_works_707_i6 : Template HasSnaky 7 required_707_i6 envelope_707_i6 := by + refine compose HasSnaky 6 childrenC_707_i6 childrenD_707_i6 children_work_707_i6 (5, 7) + required_707_i6 envelope_707_i6 pivot_mem_707_i6 child_required_sub_707_i6 child_envelope_sub_707_i6 ?_ + intro b hb + exact common_sub_707_i6 (mem_commonEnvelope childrenD_707_i6 b hb) +def required_707_i5 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_707_i5 : Finset Cell := ⟨(([(1, 6), (1, 7), (2, 6), (2, 7), (3, 6), (3, 7), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (7, 5), (7, 6), (7, 7), (7, 8), (8, 5), (8, 6), (8, 7), (8, 8), (9, 6), (9, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_707_i5 : Fin 4 → Finset Cell := ![(placed21 4 (4, 8) required_13), (placed21 6 (6, 8) required_14), (placed21 7 (8, 7) required_332), required_707_i6] +def childrenD_707_i5 : Fin 4 → Finset Cell := ![(placed21 4 (4, 8) envelope_13), (placed21 6 (6, 8) envelope_14), (placed21 7 (8, 7) envelope_332), envelope_707_i6] +theorem common_sub_707_i5 : commonEnvelope childrenD_707_i5 ⊆ insert (5, 4) required_707_i5 := by decide +kernel +theorem child_required_sub_707_i5 : ∀ j, childrenC_707_i5 j ⊆ insert (5, 4) required_707_i5 := by decide +kernel +theorem child_envelope_sub_707_i5 : ∀ j, childrenD_707_i5 j ⊆ envelope_707_i5 := by decide +kernel +theorem pivot_mem_707_i5 : (5, 4) ∈ envelope_707_i5 := by decide +kernel +theorem children_work_707_i5 : ∀ j, Template HasSnaky 7 (childrenC_707_i5 j) (childrenD_707_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_13 4 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_14 6 (6, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_332 7 (8, 7)).mono (by decide +kernel) + · exact row_works_707_i6.mono (by decide +kernel) +theorem row_works_707_i5 : Template HasSnaky 8 required_707_i5 envelope_707_i5 := by + refine compose HasSnaky 7 childrenC_707_i5 childrenD_707_i5 children_work_707_i5 (5, 4) + required_707_i5 envelope_707_i5 pivot_mem_707_i5 child_required_sub_707_i5 child_envelope_sub_707_i5 ?_ + intro b hb + exact common_sub_707_i5 (mem_commonEnvelope childrenD_707_i5 b hb) +def required_707_i7 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_707_i7 : Finset Cell := ⟨(([(1, 6), (1, 7), (1, 8), (1, 9), (2, 6), (2, 7), (2, 8), (2, 9), (3, 6), (3, 7), (3, 8), (3, 9), (4, 1), (4, 2), (4, 3), (4, 5), (4, 7), (4, 8), (4, 9), (4, 10), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (10, 3), (10, 6), (10, 7), (10, 8), (11, 6), (11, 7), (11, 8), (12, 6), (12, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_707_i7 : Fin 7 → Finset Cell := ![(placed21 2 (6, 3) required_12), (placed21 2 (6, 3) required_13), (placed21 5 (8, 4) required_118), (placed21 6 (6, 10) required_369), (placed21 5 (8, 4) required_435), (placed21 0 (4, 1) required_528), (placed21 1 (1, 3) required_689)] +def childrenD_707_i7 : Fin 7 → Finset Cell := ![(placed21 2 (6, 3) envelope_12), (placed21 2 (6, 3) envelope_13), (placed21 5 (8, 4) envelope_118), (placed21 6 (6, 10) envelope_369), (placed21 5 (8, 4) envelope_435), (placed21 0 (4, 1) envelope_528), (placed21 1 (1, 3) envelope_689)] +theorem common_sub_707_i7 : commonEnvelope childrenD_707_i7 ⊆ insert (5, 7) required_707_i7 := by decide +kernel +theorem child_required_sub_707_i7 : ∀ j, childrenC_707_i7 j ⊆ insert (5, 7) required_707_i7 := by decide +kernel +theorem child_envelope_sub_707_i7 : ∀ j, childrenD_707_i7 j ⊆ envelope_707_i7 := by decide +kernel +theorem pivot_mem_707_i7 : (5, 7) ∈ envelope_707_i7 := by decide +kernel +theorem children_work_707_i7 : ∀ j, Template HasSnaky 11 (childrenC_707_i7 j) (childrenD_707_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_13 2 (6, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_118 5 (8, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_369 6 (6, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (8, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_528 0 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_689 1 (1, 3)).mono (by decide +kernel) +theorem row_works_707_i7 : Template HasSnaky 12 required_707_i7 envelope_707_i7 := by + refine compose HasSnaky 11 childrenC_707_i7 childrenD_707_i7 children_work_707_i7 (5, 7) + required_707_i7 envelope_707_i7 pivot_mem_707_i7 child_required_sub_707_i7 child_envelope_sub_707_i7 ?_ + intro b hb + exact common_sub_707_i7 (mem_commonEnvelope childrenD_707_i7 b hb) +def required_707_i8 : Finset Cell := ⟨(([(4, 5), (5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_707_i8 : Finset Cell := ⟨(([(0, 7), (0, 9), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 2), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 3), (9, 4), (9, 7), (9, 8), (9, 9), (10, 3), (10, 4)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_707_i8 : Fin 6 → Finset Cell := ![(placed21 5 (8, 4) required_537), (placed21 4 (3, 9) required_537), (placed21 5 (7, 4) required_702), (placed21 4 (3, 8) required_702), (placed21 1 (0, 4) required_704), (placed21 0 (3, 1) required_704)] +def childrenD_707_i8 : Fin 6 → Finset Cell := ![(placed21 5 (8, 4) envelope_537), (placed21 4 (3, 9) envelope_537), (placed21 5 (7, 4) envelope_702), (placed21 4 (3, 8) envelope_702), (placed21 1 (0, 4) envelope_704), (placed21 0 (3, 1) envelope_704)] +theorem common_sub_707_i8 : commonEnvelope childrenD_707_i8 ⊆ insert (4, 6) required_707_i8 := by decide +kernel +theorem child_required_sub_707_i8 : ∀ j, childrenC_707_i8 j ⊆ insert (4, 6) required_707_i8 := by decide +kernel +theorem child_envelope_sub_707_i8 : ∀ j, childrenD_707_i8 j ⊆ envelope_707_i8 := by decide +kernel +theorem pivot_mem_707_i8 : (4, 6) ∈ envelope_707_i8 := by decide +kernel +theorem children_work_707_i8 : ∀ j, Template HasSnaky 10 (childrenC_707_i8 j) (childrenD_707_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_537 5 (8, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_537 4 (3, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_702 5 (7, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_702 4 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_704 1 (0, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_704 0 (3, 1)).mono (by decide +kernel) +theorem row_works_707_i8 : Template HasSnaky 11 required_707_i8 envelope_707_i8 := by + refine compose HasSnaky 10 childrenC_707_i8 childrenD_707_i8 children_work_707_i8 (4, 6) + required_707_i8 envelope_707_i8 pivot_mem_707_i8 child_required_sub_707_i8 child_envelope_sub_707_i8 ?_ + intro b hb + exact common_sub_707_i8 (mem_commonEnvelope childrenD_707_i8 b hb) +def required_707 : Finset Cell := ⟨(([(4, 5), (5, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_707 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 7), (0, 9), (1, 2), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 2), (3, 3), (3, 4), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_707 : Fin 13 → Finset Cell := ![(placed21 0 (4, 1) required_459), (placed21 4 (3, 10) required_535), (placed21 0 (1, 1) required_617), (placed21 1 (0, 1) required_660), (placed21 1 (0, 3) required_663), required_707_i0, required_707_i1, required_707_i3, required_707_i5, required_707_i7, required_707_i8, (placed21 4 (2, 10) required_705), (placed21 4 (0, 10) required_706)] +def childrenD_707 : Fin 13 → Finset Cell := ![(placed21 0 (4, 1) envelope_459), (placed21 4 (3, 10) envelope_535), (placed21 0 (1, 1) envelope_617), (placed21 1 (0, 1) envelope_660), (placed21 1 (0, 3) envelope_663), envelope_707_i0, envelope_707_i1, envelope_707_i3, envelope_707_i5, envelope_707_i7, envelope_707_i8, (placed21 4 (2, 10) envelope_705), (placed21 4 (0, 10) envelope_706)] +theorem common_sub_707 : commonEnvelope childrenD_707 ⊆ insert (5, 6) required_707 := by decide +kernel +theorem child_required_sub_707 : ∀ j, childrenC_707 j ⊆ insert (5, 6) required_707 := by decide +kernel +theorem child_envelope_sub_707 : ∀ j, childrenD_707 j ⊆ envelope_707 := by decide +kernel +theorem pivot_mem_707 : (5, 6) ∈ envelope_707 := by decide +kernel +theorem children_work_707 : ∀ j, Template HasSnaky 16 (childrenC_707 j) (childrenD_707 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_459 0 (4, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_535 4 (3, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_617 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_660 1 (0, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_663 1 (0, 3)).mono (by decide +kernel) + · exact row_works_707_i0.mono (by decide +kernel) + · exact row_works_707_i1.mono (by decide +kernel) + · exact row_works_707_i3.mono (by decide +kernel) + · exact row_works_707_i5.mono (by decide +kernel) + · exact row_works_707_i7.mono (by decide +kernel) + · exact row_works_707_i8.mono (by decide +kernel) + · exact (placed21_template row_works_705 4 (2, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_706 4 (0, 10)).mono (by decide +kernel) +theorem row_works_707 : Template HasSnaky 17 required_707 envelope_707 := by + refine compose HasSnaky 16 childrenC_707 childrenD_707 children_work_707 (5, 6) + required_707 envelope_707 pivot_mem_707 child_required_sub_707 child_envelope_sub_707 ?_ + intro b hb + exact common_sub_707 (mem_commonEnvelope childrenD_707 b hb) +def height_707_i0 : ℕ := 10 +def childrenH_707_i0 : Fin 7 → ℕ := ![height_116, height_134, height_180, height_337, height_435, height_558, height_662] +theorem height_exact_707_i0 : height_707_i0 = 1 + Finset.univ.sup childrenH_707_i0 := by decide +kernel +theorem required_origin_707_i0 : ∀ x ∈ required_707_i0, + (∃ j, x ∈ childrenC_707_i0 j) ∨ ∀ j, x ∈ childrenD_707_i0 j := by decide +kernel +theorem required_exact_707_i0 : required_707_i0 = + ((Finset.univ.biUnion childrenC_707_i0) ∪ commonEnvelope childrenD_707_i0).erase (5, 7) := by + exact required_eq_combination childrenC_707_i0 childrenD_707_i0 (5, 7) required_707_i0 + (by decide +kernel) child_required_sub_707_i0 common_sub_707_i0 required_origin_707_i0 +theorem envelope_origin_707_i0 : ∀ x ∈ envelope_707_i0, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_707_i0 j := by decide +kernel +theorem envelope_exact_707_i0 : envelope_707_i0 = + insert (5, 7) (Finset.univ.biUnion childrenD_707_i0) := by + exact envelope_eq_combination childrenD_707_i0 (5, 7) envelope_707_i0 + pivot_mem_707_i0 child_envelope_sub_707_i0 envelope_origin_707_i0 +def checked_707_i0 : CheckedCard where + required := required_707_i0 + envelope := envelope_707_i0 + height := height_707_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_707_i0 +def height_707_i2 : ℕ := 10 +def childrenH_707_i2 : Fin 3 → ℕ := ![height_7, height_9, height_380] +theorem height_exact_707_i2 : height_707_i2 = 1 + Finset.univ.sup childrenH_707_i2 := by decide +kernel +theorem required_origin_707_i2 : ∀ x ∈ required_707_i2, + (∃ j, x ∈ childrenC_707_i2 j) ∨ ∀ j, x ∈ childrenD_707_i2 j := by decide +kernel +theorem required_exact_707_i2 : required_707_i2 = + ((Finset.univ.biUnion childrenC_707_i2) ∪ commonEnvelope childrenD_707_i2).erase (5, 7) := by + exact required_eq_combination childrenC_707_i2 childrenD_707_i2 (5, 7) required_707_i2 + (by decide +kernel) child_required_sub_707_i2 common_sub_707_i2 required_origin_707_i2 +theorem envelope_origin_707_i2 : ∀ x ∈ envelope_707_i2, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_707_i2 j := by decide +kernel +theorem envelope_exact_707_i2 : envelope_707_i2 = + insert (5, 7) (Finset.univ.biUnion childrenD_707_i2) := by + exact envelope_eq_combination childrenD_707_i2 (5, 7) envelope_707_i2 + pivot_mem_707_i2 child_envelope_sub_707_i2 envelope_origin_707_i2 +def checked_707_i2 : CheckedCard where + required := required_707_i2 + envelope := envelope_707_i2 + height := height_707_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_707_i2 +def height_707_i1 : ℕ := 11 +def childrenH_707_i1 : Fin 4 → ℕ := ![height_14, height_33, height_322, height_707_i2] +theorem height_exact_707_i1 : height_707_i1 = 1 + Finset.univ.sup childrenH_707_i1 := by decide +kernel +theorem required_origin_707_i1 : ∀ x ∈ required_707_i1, + (∃ j, x ∈ childrenC_707_i1 j) ∨ ∀ j, x ∈ childrenD_707_i1 j := by decide +kernel +theorem required_exact_707_i1 : required_707_i1 = + ((Finset.univ.biUnion childrenC_707_i1) ∪ commonEnvelope childrenD_707_i1).erase (5, 4) := by + exact required_eq_combination childrenC_707_i1 childrenD_707_i1 (5, 4) required_707_i1 + (by decide +kernel) child_required_sub_707_i1 common_sub_707_i1 required_origin_707_i1 +theorem envelope_origin_707_i1 : ∀ x ∈ envelope_707_i1, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_707_i1 j := by decide +kernel +theorem envelope_exact_707_i1 : envelope_707_i1 = + insert (5, 4) (Finset.univ.biUnion childrenD_707_i1) := by + exact envelope_eq_combination childrenD_707_i1 (5, 4) envelope_707_i1 + pivot_mem_707_i1 child_envelope_sub_707_i1 envelope_origin_707_i1 +def checked_707_i1 : CheckedCard where + required := required_707_i1 + envelope := envelope_707_i1 + height := height_707_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_707_i1 +def height_707_i4 : ℕ := 13 +def childrenH_707_i4 : Fin 4 → ℕ := ![height_7, height_8, height_9, height_485] +theorem height_exact_707_i4 : height_707_i4 = 1 + Finset.univ.sup childrenH_707_i4 := by decide +kernel +theorem required_origin_707_i4 : ∀ x ∈ required_707_i4, + (∃ j, x ∈ childrenC_707_i4 j) ∨ ∀ j, x ∈ childrenD_707_i4 j := by decide +kernel +theorem required_exact_707_i4 : required_707_i4 = + ((Finset.univ.biUnion childrenC_707_i4) ∪ commonEnvelope childrenD_707_i4).erase (5, 7) := by + exact required_eq_combination childrenC_707_i4 childrenD_707_i4 (5, 7) required_707_i4 + (by decide +kernel) child_required_sub_707_i4 common_sub_707_i4 required_origin_707_i4 +theorem envelope_origin_707_i4 : ∀ x ∈ envelope_707_i4, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_707_i4 j := by decide +kernel +theorem envelope_exact_707_i4 : envelope_707_i4 = + insert (5, 7) (Finset.univ.biUnion childrenD_707_i4) := by + exact envelope_eq_combination childrenD_707_i4 (5, 7) envelope_707_i4 + pivot_mem_707_i4 child_envelope_sub_707_i4 envelope_origin_707_i4 +def checked_707_i4 : CheckedCard where + required := required_707_i4 + envelope := envelope_707_i4 + height := height_707_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_707_i4 +def height_707_i3 : ℕ := 14 +def childrenH_707_i3 : Fin 5 → ℕ := ![height_136, height_267, height_322, height_322, height_707_i4] +theorem height_exact_707_i3 : height_707_i3 = 1 + Finset.univ.sup childrenH_707_i3 := by decide +kernel +theorem required_origin_707_i3 : ∀ x ∈ required_707_i3, + (∃ j, x ∈ childrenC_707_i3 j) ∨ ∀ j, x ∈ childrenD_707_i3 j := by decide +kernel +theorem required_exact_707_i3 : required_707_i3 = + ((Finset.univ.biUnion childrenC_707_i3) ∪ commonEnvelope childrenD_707_i3).erase (5, 4) := by + exact required_eq_combination childrenC_707_i3 childrenD_707_i3 (5, 4) required_707_i3 + (by decide +kernel) child_required_sub_707_i3 common_sub_707_i3 required_origin_707_i3 +theorem envelope_origin_707_i3 : ∀ x ∈ envelope_707_i3, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_707_i3 j := by decide +kernel +theorem envelope_exact_707_i3 : envelope_707_i3 = + insert (5, 4) (Finset.univ.biUnion childrenD_707_i3) := by + exact envelope_eq_combination childrenD_707_i3 (5, 4) envelope_707_i3 + pivot_mem_707_i3 child_envelope_sub_707_i3 envelope_origin_707_i3 +def checked_707_i3 : CheckedCard where + required := required_707_i3 + envelope := envelope_707_i3 + height := height_707_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_707_i3 +def height_707_i6 : ℕ := 7 +def childrenH_707_i6 : Fin 4 → ℕ := ![height_9, height_115, height_302, height_303] +theorem height_exact_707_i6 : height_707_i6 = 1 + Finset.univ.sup childrenH_707_i6 := by decide +kernel +theorem required_origin_707_i6 : ∀ x ∈ required_707_i6, + (∃ j, x ∈ childrenC_707_i6 j) ∨ ∀ j, x ∈ childrenD_707_i6 j := by decide +kernel +theorem required_exact_707_i6 : required_707_i6 = + ((Finset.univ.biUnion childrenC_707_i6) ∪ commonEnvelope childrenD_707_i6).erase (5, 7) := by + exact required_eq_combination childrenC_707_i6 childrenD_707_i6 (5, 7) required_707_i6 + (by decide +kernel) child_required_sub_707_i6 common_sub_707_i6 required_origin_707_i6 +theorem envelope_origin_707_i6 : ∀ x ∈ envelope_707_i6, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_707_i6 j := by decide +kernel +theorem envelope_exact_707_i6 : envelope_707_i6 = + insert (5, 7) (Finset.univ.biUnion childrenD_707_i6) := by + exact envelope_eq_combination childrenD_707_i6 (5, 7) envelope_707_i6 + pivot_mem_707_i6 child_envelope_sub_707_i6 envelope_origin_707_i6 +def checked_707_i6 : CheckedCard where + required := required_707_i6 + envelope := envelope_707_i6 + height := height_707_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_707_i6 +def height_707_i5 : ℕ := 8 +def childrenH_707_i5 : Fin 4 → ℕ := ![height_13, height_14, height_332, height_707_i6] +theorem height_exact_707_i5 : height_707_i5 = 1 + Finset.univ.sup childrenH_707_i5 := by decide +kernel +theorem required_origin_707_i5 : ∀ x ∈ required_707_i5, + (∃ j, x ∈ childrenC_707_i5 j) ∨ ∀ j, x ∈ childrenD_707_i5 j := by decide +kernel +theorem required_exact_707_i5 : required_707_i5 = + ((Finset.univ.biUnion childrenC_707_i5) ∪ commonEnvelope childrenD_707_i5).erase (5, 4) := by + exact required_eq_combination childrenC_707_i5 childrenD_707_i5 (5, 4) required_707_i5 + (by decide +kernel) child_required_sub_707_i5 common_sub_707_i5 required_origin_707_i5 +theorem envelope_origin_707_i5 : ∀ x ∈ envelope_707_i5, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_707_i5 j := by decide +kernel +theorem envelope_exact_707_i5 : envelope_707_i5 = + insert (5, 4) (Finset.univ.biUnion childrenD_707_i5) := by + exact envelope_eq_combination childrenD_707_i5 (5, 4) envelope_707_i5 + pivot_mem_707_i5 child_envelope_sub_707_i5 envelope_origin_707_i5 +def checked_707_i5 : CheckedCard where + required := required_707_i5 + envelope := envelope_707_i5 + height := height_707_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_707_i5 +def height_707_i7 : ℕ := 12 +def childrenH_707_i7 : Fin 7 → ℕ := ![height_12, height_13, height_118, height_369, height_435, height_528, height_689] +theorem height_exact_707_i7 : height_707_i7 = 1 + Finset.univ.sup childrenH_707_i7 := by decide +kernel +theorem required_origin_707_i7 : ∀ x ∈ required_707_i7, + (∃ j, x ∈ childrenC_707_i7 j) ∨ ∀ j, x ∈ childrenD_707_i7 j := by decide +kernel +theorem required_exact_707_i7 : required_707_i7 = + ((Finset.univ.biUnion childrenC_707_i7) ∪ commonEnvelope childrenD_707_i7).erase (5, 7) := by + exact required_eq_combination childrenC_707_i7 childrenD_707_i7 (5, 7) required_707_i7 + (by decide +kernel) child_required_sub_707_i7 common_sub_707_i7 required_origin_707_i7 +theorem envelope_origin_707_i7 : ∀ x ∈ envelope_707_i7, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_707_i7 j := by decide +kernel +theorem envelope_exact_707_i7 : envelope_707_i7 = + insert (5, 7) (Finset.univ.biUnion childrenD_707_i7) := by + exact envelope_eq_combination childrenD_707_i7 (5, 7) envelope_707_i7 + pivot_mem_707_i7 child_envelope_sub_707_i7 envelope_origin_707_i7 +def checked_707_i7 : CheckedCard where + required := required_707_i7 + envelope := envelope_707_i7 + height := height_707_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_707_i7 +def height_707_i8 : ℕ := 11 +def childrenH_707_i8 : Fin 6 → ℕ := ![height_537, height_537, height_702, height_702, height_704, height_704] +theorem height_exact_707_i8 : height_707_i8 = 1 + Finset.univ.sup childrenH_707_i8 := by decide +kernel +theorem required_origin_707_i8 : ∀ x ∈ required_707_i8, + (∃ j, x ∈ childrenC_707_i8 j) ∨ ∀ j, x ∈ childrenD_707_i8 j := by decide +kernel +theorem required_exact_707_i8 : required_707_i8 = + ((Finset.univ.biUnion childrenC_707_i8) ∪ commonEnvelope childrenD_707_i8).erase (4, 6) := by + exact required_eq_combination childrenC_707_i8 childrenD_707_i8 (4, 6) required_707_i8 + (by decide +kernel) child_required_sub_707_i8 common_sub_707_i8 required_origin_707_i8 +theorem envelope_origin_707_i8 : ∀ x ∈ envelope_707_i8, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_707_i8 j := by decide +kernel +theorem envelope_exact_707_i8 : envelope_707_i8 = + insert (4, 6) (Finset.univ.biUnion childrenD_707_i8) := by + exact envelope_eq_combination childrenD_707_i8 (4, 6) envelope_707_i8 + pivot_mem_707_i8 child_envelope_sub_707_i8 envelope_origin_707_i8 +def checked_707_i8 : CheckedCard where + required := required_707_i8 + envelope := envelope_707_i8 + height := height_707_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_707_i8 +def height_707 : ℕ := 17 +def childrenH_707 : Fin 13 → ℕ := ![height_459, height_535, height_617, height_660, height_663, height_707_i0, height_707_i1, height_707_i3, height_707_i5, height_707_i7, height_707_i8, height_705, height_706] +theorem height_exact_707 : height_707 = 1 + Finset.univ.sup childrenH_707 := by decide +kernel +theorem required_origin_707 : ∀ x ∈ required_707, + (∃ j, x ∈ childrenC_707 j) ∨ ∀ j, x ∈ childrenD_707 j := by decide +kernel +theorem required_exact_707 : required_707 = + ((Finset.univ.biUnion childrenC_707) ∪ commonEnvelope childrenD_707).erase (5, 6) := by + exact required_eq_combination childrenC_707 childrenD_707 (5, 6) required_707 + (by decide +kernel) child_required_sub_707 common_sub_707 required_origin_707 +theorem envelope_origin_707 : ∀ x ∈ envelope_707, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_707 j := by decide +kernel +theorem envelope_exact_707 : envelope_707 = + insert (5, 6) (Finset.univ.biUnion childrenD_707) := by + exact envelope_eq_combination childrenD_707 (5, 6) envelope_707 + pivot_mem_707 child_envelope_sub_707 envelope_origin_707 +def checked_707 : CheckedCard where + required := required_707 + envelope := envelope_707 + height := height_707 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_707 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part01.lean new file mode 100644 index 0000000..9465f26 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part01.lean @@ -0,0 +1,874 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height17Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_684_i1 : Finset Cell := ⟨(([(6, 7), (7, 7), (7, 10), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_684_i1 : Finset Cell := ⟨(([(4, 3), (4, 5), (5, 3), (5, 4), (5, 5), (5, 6), (5, 8), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 7), (7, 9), (7, 10), (7, 11), (7, 12), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (13, 3), (13, 5), (13, 6), (13, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_684_i1 : Fin 6 → Finset Cell := ![(placed21 4 (6, 8) required_8), (placed21 4 (6, 10) required_115), (placed21 1 (5, 6) required_469), (placed21 4 (5, 12) required_470), (placed21 3 (4, 8) required_485), (placed21 4 (4, 12) required_489)] +def childrenD_684_i1 : Fin 6 → Finset Cell := ![(placed21 4 (6, 8) envelope_8), (placed21 4 (6, 10) envelope_115), (placed21 1 (5, 6) envelope_469), (placed21 4 (5, 12) envelope_470), (placed21 3 (4, 8) envelope_485), (placed21 4 (4, 12) envelope_489)] +theorem common_sub_684_i1 : commonEnvelope childrenD_684_i1 ⊆ insert (9, 7) required_684_i1 := by decide +kernel +theorem child_required_sub_684_i1 : ∀ j, childrenC_684_i1 j ⊆ insert (9, 7) required_684_i1 := by decide +kernel +theorem child_envelope_sub_684_i1 : ∀ j, childrenD_684_i1 j ⊆ envelope_684_i1 := by decide +kernel +theorem pivot_mem_684_i1 : (9, 7) ∈ envelope_684_i1 := by decide +kernel +theorem children_work_684_i1 : ∀ j, Template HasSnaky 12 (childrenC_684_i1 j) (childrenD_684_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 4 (6, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_115 4 (6, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_469 1 (5, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_470 4 (5, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_485 3 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_489 4 (4, 12)).mono (by decide +kernel) +theorem row_works_684_i1 : Template HasSnaky 13 required_684_i1 envelope_684_i1 := by + refine compose HasSnaky 12 childrenC_684_i1 childrenD_684_i1 children_work_684_i1 (9, 7) + required_684_i1 envelope_684_i1 pivot_mem_684_i1 child_required_sub_684_i1 child_envelope_sub_684_i1 ?_ + intro b hb + exact common_sub_684_i1 (mem_commonEnvelope childrenD_684_i1 b hb) +def required_684_i0 : Finset Cell := ⟨(([(6, 7), (7, 7), (7, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_684_i0 : Finset Cell := ⟨(([(3, 8), (3, 10), (4, 3), (4, 5), (4, 6), (4, 8), (4, 9), (4, 10), (5, 3), (5, 4), (5, 5), (5, 6), (5, 8), (5, 9), (5, 10), (5, 11), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 2), (7, 3), (7, 4), (7, 5), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 10), (13, 3), (13, 5), (13, 6), (13, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_684_i0 : Fin 6 → Finset Cell := ![(placed21 4 (5, 10) required_118), (placed21 3 (5, 10) required_355), (placed21 3 (5, 11) required_434), (placed21 1 (3, 6) required_468), required_684_i1, (placed21 7 (9, 11) required_491)] +def childrenD_684_i0 : Fin 6 → Finset Cell := ![(placed21 4 (5, 10) envelope_118), (placed21 3 (5, 10) envelope_355), (placed21 3 (5, 11) envelope_434), (placed21 1 (3, 6) envelope_468), envelope_684_i1, (placed21 7 (9, 11) envelope_491)] +theorem common_sub_684_i0 : commonEnvelope childrenD_684_i0 ⊆ insert (8, 7) required_684_i0 := by decide +kernel +theorem child_required_sub_684_i0 : ∀ j, childrenC_684_i0 j ⊆ insert (8, 7) required_684_i0 := by decide +kernel +theorem child_envelope_sub_684_i0 : ∀ j, childrenD_684_i0 j ⊆ envelope_684_i0 := by decide +kernel +theorem pivot_mem_684_i0 : (8, 7) ∈ envelope_684_i0 := by decide +kernel +theorem children_work_684_i0 : ∀ j, Template HasSnaky 13 (childrenC_684_i0 j) (childrenD_684_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_118 4 (5, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_355 3 (5, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_434 3 (5, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_468 1 (3, 6)).mono (by decide +kernel) + · exact row_works_684_i1.mono (by decide +kernel) + · exact (placed21_template row_works_491 7 (9, 11)).mono (by decide +kernel) +theorem row_works_684_i0 : Template HasSnaky 14 required_684_i0 envelope_684_i0 := by + refine compose HasSnaky 13 childrenC_684_i0 childrenD_684_i0 children_work_684_i0 (8, 7) + required_684_i0 envelope_684_i0 pivot_mem_684_i0 child_required_sub_684_i0 child_envelope_sub_684_i0 ?_ + intro b hb + exact common_sub_684_i0 (mem_commonEnvelope childrenD_684_i0 b hb) +def required_684_i2 : Finset Cell := ⟨(([(6, 7), (7, 7), (7, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_684_i2 : Finset Cell := ⟨(([(2, 8), (2, 10), (3, 8), (3, 9), (3, 10), (3, 11), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 9), (8, 10), (8, 11), (8, 12), (9, 8), (9, 9), (9, 10), (10, 8), (10, 9), (10, 10), (11, 8), (11, 9), (11, 10), (12, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_684_i2 : Fin 6 → Finset Cell := ![(placed21 0 (6, 6) required_50), (placed21 0 (6, 6) required_97), (placed21 2 (7, 6) required_98), (placed21 6 (8, 11) required_454), (placed21 5 (8, 7) required_455), (placed21 1 (2, 6) required_624)] +def childrenD_684_i2 : Fin 6 → Finset Cell := ![(placed21 0 (6, 6) envelope_50), (placed21 0 (6, 6) envelope_97), (placed21 2 (7, 6) envelope_98), (placed21 6 (8, 11) envelope_454), (placed21 5 (8, 7) envelope_455), (placed21 1 (2, 6) envelope_624)] +theorem common_sub_684_i2 : commonEnvelope childrenD_684_i2 ⊆ insert (7, 9) required_684_i2 := by decide +kernel +theorem child_required_sub_684_i2 : ∀ j, childrenC_684_i2 j ⊆ insert (7, 9) required_684_i2 := by decide +kernel +theorem child_envelope_sub_684_i2 : ∀ j, childrenD_684_i2 j ⊆ envelope_684_i2 := by decide +kernel +theorem pivot_mem_684_i2 : (7, 9) ∈ envelope_684_i2 := by decide +kernel +theorem children_work_684_i2 : ∀ j, Template HasSnaky 11 (childrenC_684_i2 j) (childrenD_684_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_50 0 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_97 0 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_98 2 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_454 6 (8, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_455 5 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_624 1 (2, 6)).mono (by decide +kernel) +theorem row_works_684_i2 : Template HasSnaky 12 required_684_i2 envelope_684_i2 := by + refine compose HasSnaky 11 childrenC_684_i2 childrenD_684_i2 children_work_684_i2 (7, 9) + required_684_i2 envelope_684_i2 pivot_mem_684_i2 child_required_sub_684_i2 child_envelope_sub_684_i2 ?_ + intro b hb + exact common_sub_684_i2 (mem_commonEnvelope childrenD_684_i2 b hb) +def required_684_i3 : Finset Cell := ⟨(([(7, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_684_i3 : Finset Cell := ⟨(([(3, 10), (3, 11), (3, 12), (3, 13), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (13, 10), (13, 11), (13, 12), (13, 14), (14, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_684_i3 : Fin 13 → Finset Cell := ![(placed21 4 (4, 14) required_174), (placed21 0 (5, 7) required_475), (placed21 2 (9, 7) required_475), (placed21 0 (5, 7) required_483), (placed21 1 (4, 8) required_508), (placed21 5 (10, 8) required_508), (placed21 4 (4, 14) required_566), (placed21 0 (5, 7) required_587), (placed21 2 (9, 7) required_587), (placed21 4 (5, 15) required_635), (placed21 4 (3, 15) required_644), (placed21 4 (3, 15) required_645), (placed21 4 (3, 15) required_647)] +def childrenD_684_i3 : Fin 13 → Finset Cell := ![(placed21 4 (4, 14) envelope_174), (placed21 0 (5, 7) envelope_475), (placed21 2 (9, 7) envelope_475), (placed21 0 (5, 7) envelope_483), (placed21 1 (4, 8) envelope_508), (placed21 5 (10, 8) envelope_508), (placed21 4 (4, 14) envelope_566), (placed21 0 (5, 7) envelope_587), (placed21 2 (9, 7) envelope_587), (placed21 4 (5, 15) envelope_635), (placed21 4 (3, 15) envelope_644), (placed21 4 (3, 15) envelope_645), (placed21 4 (3, 15) envelope_647)] +theorem common_sub_684_i3 : commonEnvelope childrenD_684_i3 ⊆ insert (7, 11) required_684_i3 := by decide +kernel +theorem child_required_sub_684_i3 : ∀ j, childrenC_684_i3 j ⊆ insert (7, 11) required_684_i3 := by decide +kernel +theorem child_envelope_sub_684_i3 : ∀ j, childrenD_684_i3 j ⊆ envelope_684_i3 := by decide +kernel +theorem pivot_mem_684_i3 : (7, 11) ∈ envelope_684_i3 := by decide +kernel +theorem children_work_684_i3 : ∀ j, Template HasSnaky 14 (childrenC_684_i3 j) (childrenD_684_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_174 4 (4, 14)).mono (by decide +kernel) + · exact (placed21_template row_works_475 0 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_475 2 (9, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_483 0 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_508 1 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_508 5 (10, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_566 4 (4, 14)).mono (by decide +kernel) + · exact (placed21_template row_works_587 0 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_587 2 (9, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_635 4 (5, 15)).mono (by decide +kernel) + · exact (placed21_template row_works_644 4 (3, 15)).mono (by decide +kernel) + · exact (placed21_template row_works_645 4 (3, 15)).mono (by decide +kernel) + · exact (placed21_template row_works_647 4 (3, 15)).mono (by decide +kernel) +theorem row_works_684_i3 : Template HasSnaky 15 required_684_i3 envelope_684_i3 := by + refine compose HasSnaky 14 childrenC_684_i3 childrenD_684_i3 children_work_684_i3 (7, 11) + required_684_i3 envelope_684_i3 pivot_mem_684_i3 child_required_sub_684_i3 child_envelope_sub_684_i3 ?_ + intro b hb + exact common_sub_684_i3 (mem_commonEnvelope childrenD_684_i3 b hb) +def required_684_i5 : Finset Cell := ⟨(([(6, 7), (7, 7), (7, 10), (8, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_684_i5 : Finset Cell := ⟨(([(5, 6), (5, 8), (5, 9), (5, 10), (5, 11), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 7), (7, 9), (7, 10), (7, 11), (8, 7), (9, 6), (9, 7), (9, 8), (10, 6), (10, 7), (10, 8), (11, 6), (11, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_684_i5 : Fin 2 → Finset Cell := ![(placed21 0 (6, 6) required_8), (placed21 2 (9, 6) required_313)] +def childrenD_684_i5 : Fin 2 → Finset Cell := ![(placed21 0 (6, 6) envelope_8), (placed21 2 (9, 6) envelope_313)] +theorem common_sub_684_i5 : commonEnvelope childrenD_684_i5 ⊆ insert (9, 7) required_684_i5 := by decide +kernel +theorem child_required_sub_684_i5 : ∀ j, childrenC_684_i5 j ⊆ insert (9, 7) required_684_i5 := by decide +kernel +theorem child_envelope_sub_684_i5 : ∀ j, childrenD_684_i5 j ⊆ envelope_684_i5 := by decide +kernel +theorem pivot_mem_684_i5 : (9, 7) ∈ envelope_684_i5 := by decide +kernel +theorem children_work_684_i5 : ∀ j, Template HasSnaky 6 (childrenC_684_i5 j) (childrenD_684_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 0 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_313 2 (9, 6)).mono (by decide +kernel) +theorem row_works_684_i5 : Template HasSnaky 7 required_684_i5 envelope_684_i5 := by + refine compose HasSnaky 6 childrenC_684_i5 childrenD_684_i5 children_work_684_i5 (9, 7) + required_684_i5 envelope_684_i5 pivot_mem_684_i5 child_required_sub_684_i5 child_envelope_sub_684_i5 ?_ + intro b hb + exact common_sub_684_i5 (mem_commonEnvelope childrenD_684_i5 b hb) +def required_684_i4 : Finset Cell := ⟨(([(6, 7), (7, 7), (7, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_684_i4 : Finset Cell := ⟨(([(2, 10), (3, 8), (3, 9), (3, 10), (3, 11), (4, 6), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (5, 3), (5, 4), (5, 5), (5, 6), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (7, 3), (7, 4), (7, 5), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (11, 6), (11, 7), (11, 8), (11, 10), (12, 6), (12, 7), (12, 8), (13, 6), (13, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_684_i4 : Fin 5 → Finset Cell := ![(placed21 0 (5, 4) required_257), required_684_i5, (placed21 3 (5, 11) required_434), (placed21 5 (11, 6) required_468), (placed21 7 (9, 11) required_491)] +def childrenD_684_i4 : Fin 5 → Finset Cell := ![(placed21 0 (5, 4) envelope_257), envelope_684_i5, (placed21 3 (5, 11) envelope_434), (placed21 5 (11, 6) envelope_468), (placed21 7 (9, 11) envelope_491)] +theorem common_sub_684_i4 : commonEnvelope childrenD_684_i4 ⊆ insert (8, 7) required_684_i4 := by decide +kernel +theorem child_required_sub_684_i4 : ∀ j, childrenC_684_i4 j ⊆ insert (8, 7) required_684_i4 := by decide +kernel +theorem child_envelope_sub_684_i4 : ∀ j, childrenD_684_i4 j ⊆ envelope_684_i4 := by decide +kernel +theorem pivot_mem_684_i4 : (8, 7) ∈ envelope_684_i4 := by decide +kernel +theorem children_work_684_i4 : ∀ j, Template HasSnaky 11 (childrenC_684_i4 j) (childrenD_684_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_257 0 (5, 4)).mono (by decide +kernel) + · exact row_works_684_i5.mono (by decide +kernel) + · exact (placed21_template row_works_434 3 (5, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_468 5 (11, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_491 7 (9, 11)).mono (by decide +kernel) +theorem row_works_684_i4 : Template HasSnaky 12 required_684_i4 envelope_684_i4 := by + refine compose HasSnaky 11 childrenC_684_i4 childrenD_684_i4 children_work_684_i4 (8, 7) + required_684_i4 envelope_684_i4 pivot_mem_684_i4 child_required_sub_684_i4 child_envelope_sub_684_i4 ?_ + intro b hb + exact common_sub_684_i4 (mem_commonEnvelope childrenD_684_i4 b hb) +def required_684 : Finset Cell := ⟨(([(6, 7), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_684 : Finset Cell := ⟨(([(0, 9), (0, 11), (0, 13), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 3), (5, 4), (5, 5), (5, 6), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (7, 2), (7, 3), (7, 4), (7, 5), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 14), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (15, 5), (15, 7), (15, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_684 : Fin 15 → Finset Cell := ![required_684_i0, (placed21 3 (0, 15) required_623), required_684_i2, (placed21 5 (9, 6) required_625), (placed21 3 (0, 14) required_630), (placed21 5 (10, 6) required_632), (placed21 5 (11, 6) required_636), (placed21 1 (3, 6) required_639), required_684_i3, (placed21 1 (1, 5) required_656), (placed21 1 (4, 5) required_657), (placed21 1 (2, 4) required_670), (placed21 5 (12, 3) required_675), (placed21 1 (2, 6) required_683), required_684_i4] +def childrenD_684 : Fin 15 → Finset Cell := ![envelope_684_i0, (placed21 3 (0, 15) envelope_623), envelope_684_i2, (placed21 5 (9, 6) envelope_625), (placed21 3 (0, 14) envelope_630), (placed21 5 (10, 6) envelope_632), (placed21 5 (11, 6) envelope_636), (placed21 1 (3, 6) envelope_639), envelope_684_i3, (placed21 1 (1, 5) envelope_656), (placed21 1 (4, 5) envelope_657), (placed21 1 (2, 4) envelope_670), (placed21 5 (12, 3) envelope_675), (placed21 1 (2, 6) envelope_683), envelope_684_i4] +theorem common_sub_684 : commonEnvelope childrenD_684 ⊆ insert (7, 10) required_684 := by decide +kernel +theorem child_required_sub_684 : ∀ j, childrenC_684 j ⊆ insert (7, 10) required_684 := by decide +kernel +theorem child_envelope_sub_684 : ∀ j, childrenD_684 j ⊆ envelope_684 := by decide +kernel +theorem pivot_mem_684 : (7, 10) ∈ envelope_684 := by decide +kernel +theorem children_work_684 : ∀ j, Template HasSnaky 17 (childrenC_684 j) (childrenD_684 j) := by + intro j + fin_cases j + · exact row_works_684_i0.mono (by decide +kernel) + · exact (placed21_template row_works_623 3 (0, 15)).mono (by decide +kernel) + · exact row_works_684_i2.mono (by decide +kernel) + · exact (placed21_template row_works_625 5 (9, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_630 3 (0, 14)).mono (by decide +kernel) + · exact (placed21_template row_works_632 5 (10, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_636 5 (11, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_639 1 (3, 6)).mono (by decide +kernel) + · exact row_works_684_i3.mono (by decide +kernel) + · exact (placed21_template row_works_656 1 (1, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_657 1 (4, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_670 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_675 5 (12, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_683 1 (2, 6)).mono (by decide +kernel) + · exact row_works_684_i4.mono (by decide +kernel) +theorem row_works_684 : Template HasSnaky 18 required_684 envelope_684 := by + refine compose HasSnaky 17 childrenC_684 childrenD_684 children_work_684 (7, 10) + required_684 envelope_684 pivot_mem_684 child_required_sub_684 child_envelope_sub_684 ?_ + intro b hb + exact common_sub_684 (mem_commonEnvelope childrenD_684 b hb) +def required_691_i0 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i0 : Finset Cell := ⟨(([(1, 4), (1, 6), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (5, 5), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i0 : Fin 3 → Finset Cell := ![(placed21 4 (3, 6) required_27), (placed21 3 (1, 7) required_277), (placed21 1 (1, 3) required_278)] +def childrenD_691_i0 : Fin 3 → Finset Cell := ![(placed21 4 (3, 6) envelope_27), (placed21 3 (1, 7) envelope_277), (placed21 1 (1, 3) envelope_278)] +theorem common_sub_691_i0 : commonEnvelope childrenD_691_i0 ⊆ insert (4, 5) required_691_i0 := by decide +kernel +theorem child_required_sub_691_i0 : ∀ j, childrenC_691_i0 j ⊆ insert (4, 5) required_691_i0 := by decide +kernel +theorem child_envelope_sub_691_i0 : ∀ j, childrenD_691_i0 j ⊆ envelope_691_i0 := by decide +kernel +theorem pivot_mem_691_i0 : (4, 5) ∈ envelope_691_i0 := by decide +kernel +theorem children_work_691_i0 : ∀ j, Template HasSnaky 5 (childrenC_691_i0 j) (childrenD_691_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_27 4 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_277 3 (1, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_278 1 (1, 3)).mono (by decide +kernel) +theorem row_works_691_i0 : Template HasSnaky 6 required_691_i0 envelope_691_i0 := by + refine compose HasSnaky 5 childrenC_691_i0 childrenD_691_i0 children_work_691_i0 (4, 5) + required_691_i0 envelope_691_i0 pivot_mem_691_i0 child_required_sub_691_i0 child_envelope_sub_691_i0 ?_ + intro b hb + exact common_sub_691_i0 (mem_commonEnvelope childrenD_691_i0 b hb) +def required_691_i5 : Finset Cell := ⟨(([(3, 5), (4, 5), (4, 6), (6, 5), (6, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i5 : Finset Cell := ⟨(([(3, 5), (3, 6), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 7), (9, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i5 : Fin 2 → Finset Cell := ![(placed21 6 (7, 6) required_0), (placed21 0 (3, 2) required_317)] +def childrenD_691_i5 : Fin 2 → Finset Cell := ![(placed21 6 (7, 6) envelope_0), (placed21 0 (3, 2) envelope_317)] +theorem common_sub_691_i5 : commonEnvelope childrenD_691_i5 ⊆ insert (5, 6) required_691_i5 := by decide +kernel +theorem child_required_sub_691_i5 : ∀ j, childrenC_691_i5 j ⊆ insert (5, 6) required_691_i5 := by decide +kernel +theorem child_envelope_sub_691_i5 : ∀ j, childrenD_691_i5 j ⊆ envelope_691_i5 := by decide +kernel +theorem pivot_mem_691_i5 : (5, 6) ∈ envelope_691_i5 := by decide +kernel +theorem children_work_691_i5 : ∀ j, Template HasSnaky 7 (childrenC_691_i5 j) (childrenD_691_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 6 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_317 0 (3, 2)).mono (by decide +kernel) +theorem row_works_691_i5 : Template HasSnaky 8 required_691_i5 envelope_691_i5 := by + refine compose HasSnaky 7 childrenC_691_i5 childrenD_691_i5 children_work_691_i5 (5, 6) + required_691_i5 envelope_691_i5 pivot_mem_691_i5 child_required_sub_691_i5 child_envelope_sub_691_i5 ?_ + intro b hb + exact common_sub_691_i5 (mem_commonEnvelope childrenD_691_i5 b hb) +def required_691_i4 : Finset Cell := ⟨(([(3, 5), (3, 6), (4, 5), (4, 6), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i4 : Finset Cell := ⟨(([(3, 5), (3, 6), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 3), (10, 4), (10, 5), (10, 7), (10, 9), (11, 3), (11, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i4 : Fin 4 → Finset Cell := ![(placed21 3 (3, 6) required_30), (placed21 4 (3, 9) required_59), (placed21 0 (5, 2) required_462), required_691_i5] +def childrenD_691_i4 : Fin 4 → Finset Cell := ![(placed21 3 (3, 6) envelope_30), (placed21 4 (3, 9) envelope_59), (placed21 0 (5, 2) envelope_462), envelope_691_i5] +theorem common_sub_691_i4 : commonEnvelope childrenD_691_i4 ⊆ insert (6, 6) required_691_i4 := by decide +kernel +theorem child_required_sub_691_i4 : ∀ j, childrenC_691_i4 j ⊆ insert (6, 6) required_691_i4 := by decide +kernel +theorem child_envelope_sub_691_i4 : ∀ j, childrenD_691_i4 j ⊆ envelope_691_i4 := by decide +kernel +theorem pivot_mem_691_i4 : (6, 6) ∈ envelope_691_i4 := by decide +kernel +theorem children_work_691_i4 : ∀ j, Template HasSnaky 13 (childrenC_691_i4 j) (childrenD_691_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_30 3 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_59 4 (3, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_462 0 (5, 2)).mono (by decide +kernel) + · exact row_works_691_i5.mono (by decide +kernel) +theorem row_works_691_i4 : Template HasSnaky 14 required_691_i4 envelope_691_i4 := by + refine compose HasSnaky 13 childrenC_691_i4 childrenD_691_i4 children_work_691_i4 (6, 6) + required_691_i4 envelope_691_i4 pivot_mem_691_i4 child_required_sub_691_i4 child_envelope_sub_691_i4 ?_ + intro b hb + exact common_sub_691_i4 (mem_commonEnvelope childrenD_691_i4 b hb) +def required_691_i3 : Finset Cell := ⟨(([(3, 4), (3, 5), (3, 6), (4, 5), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i3 : Finset Cell := ⟨(([(2, 4), (3, 4), (3, 5), (3, 6), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 3), (10, 4), (10, 5), (10, 7), (10, 9), (11, 3), (11, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i3 : Fin 3 → Finset Cell := ![(placed21 3 (2, 6) required_102), (placed21 0 (2, 3) required_400), required_691_i4] +def childrenD_691_i3 : Fin 3 → Finset Cell := ![(placed21 3 (2, 6) envelope_102), (placed21 0 (2, 3) envelope_400), envelope_691_i4] +theorem common_sub_691_i3 : commonEnvelope childrenD_691_i3 ⊆ insert (6, 5) required_691_i3 := by decide +kernel +theorem child_required_sub_691_i3 : ∀ j, childrenC_691_i3 j ⊆ insert (6, 5) required_691_i3 := by decide +kernel +theorem child_envelope_sub_691_i3 : ∀ j, childrenD_691_i3 j ⊆ envelope_691_i3 := by decide +kernel +theorem pivot_mem_691_i3 : (6, 5) ∈ envelope_691_i3 := by decide +kernel +theorem children_work_691_i3 : ∀ j, Template HasSnaky 14 (childrenC_691_i3 j) (childrenD_691_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_102 3 (2, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_400 0 (2, 3)).mono (by decide +kernel) + · exact row_works_691_i4.mono (by decide +kernel) +theorem row_works_691_i3 : Template HasSnaky 15 required_691_i3 envelope_691_i3 := by + refine compose HasSnaky 14 childrenC_691_i3 childrenD_691_i3 children_work_691_i3 (6, 5) + required_691_i3 envelope_691_i3 pivot_mem_691_i3 child_required_sub_691_i3 child_envelope_sub_691_i3 ?_ + intro b hb + exact common_sub_691_i3 (mem_commonEnvelope childrenD_691_i3 b hb) +def required_691_i2 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6), (4, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i2 : Finset Cell := ⟨(([(2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 5), (4, 6), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 3), (10, 4), (10, 5), (10, 7), (10, 9), (11, 3), (11, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i2 : Fin 2 → Finset Cell := ![(placed21 1 (3, 2) required_0), required_691_i3] +def childrenD_691_i2 : Fin 2 → Finset Cell := ![(placed21 1 (3, 2) envelope_0), envelope_691_i3] +theorem common_sub_691_i2 : commonEnvelope childrenD_691_i2 ⊆ insert (4, 5) required_691_i2 := by decide +kernel +theorem child_required_sub_691_i2 : ∀ j, childrenC_691_i2 j ⊆ insert (4, 5) required_691_i2 := by decide +kernel +theorem child_envelope_sub_691_i2 : ∀ j, childrenD_691_i2 j ⊆ envelope_691_i2 := by decide +kernel +theorem pivot_mem_691_i2 : (4, 5) ∈ envelope_691_i2 := by decide +kernel +theorem children_work_691_i2 : ∀ j, Template HasSnaky 15 (childrenC_691_i2 j) (childrenD_691_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_0 1 (3, 2)).mono (by decide +kernel) + · exact row_works_691_i3.mono (by decide +kernel) +theorem row_works_691_i2 : Template HasSnaky 16 required_691_i2 envelope_691_i2 := by + refine compose HasSnaky 15 childrenC_691_i2 childrenD_691_i2 children_work_691_i2 (4, 5) + required_691_i2 envelope_691_i2 pivot_mem_691_i2 child_required_sub_691_i2 child_envelope_sub_691_i2 ?_ + intro b hb + exact common_sub_691_i2 (mem_commonEnvelope childrenD_691_i2 b hb) +def required_691_i1 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i1 : Finset Cell := ⟨(([(2, 4), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (4, 5), (4, 6), (4, 7), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 3), (10, 4), (10, 5), (10, 7), (10, 9), (11, 3), (11, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i1 : Fin 2 → Finset Cell := ![(placed21 1 (3, 3) required_5), required_691_i2] +def childrenD_691_i1 : Fin 2 → Finset Cell := ![(placed21 1 (3, 3) envelope_5), envelope_691_i2] +theorem common_sub_691_i1 : commonEnvelope childrenD_691_i1 ⊆ insert (4, 6) required_691_i1 := by decide +kernel +theorem child_required_sub_691_i1 : ∀ j, childrenC_691_i1 j ⊆ insert (4, 6) required_691_i1 := by decide +kernel +theorem child_envelope_sub_691_i1 : ∀ j, childrenD_691_i1 j ⊆ envelope_691_i1 := by decide +kernel +theorem pivot_mem_691_i1 : (4, 6) ∈ envelope_691_i1 := by decide +kernel +theorem children_work_691_i1 : ∀ j, Template HasSnaky 16 (childrenC_691_i1 j) (childrenD_691_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 1 (3, 3)).mono (by decide +kernel) + · exact row_works_691_i2.mono (by decide +kernel) +theorem row_works_691_i1 : Template HasSnaky 17 required_691_i1 envelope_691_i1 := by + refine compose HasSnaky 16 childrenC_691_i1 childrenD_691_i1 children_work_691_i1 (4, 6) + required_691_i1 envelope_691_i1 pivot_mem_691_i1 child_required_sub_691_i1 child_envelope_sub_691_i1 ?_ + intro b hb + exact common_sub_691_i1 (mem_commonEnvelope childrenD_691_i1 b hb) +def required_691_i10 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i10 : Finset Cell := ⟨(([(2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 7), (4, 8), (5, 7), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i10 : Fin 2 → Finset Cell := ![(placed21 5 (3, 3) required_5), (placed21 1 (2, 4) required_35)] +def childrenD_691_i10 : Fin 2 → Finset Cell := ![(placed21 5 (3, 3) envelope_5), (placed21 1 (2, 4) envelope_35)] +theorem common_sub_691_i10 : commonEnvelope childrenD_691_i10 ⊆ insert (2, 6) required_691_i10 := by decide +kernel +theorem child_required_sub_691_i10 : ∀ j, childrenC_691_i10 j ⊆ insert (2, 6) required_691_i10 := by decide +kernel +theorem child_envelope_sub_691_i10 : ∀ j, childrenD_691_i10 j ⊆ envelope_691_i10 := by decide +kernel +theorem pivot_mem_691_i10 : (2, 6) ∈ envelope_691_i10 := by decide +kernel +theorem children_work_691_i10 : ∀ j, Template HasSnaky 2 (childrenC_691_i10 j) (childrenD_691_i10 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 5 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_35 1 (2, 4)).mono (by decide +kernel) +theorem row_works_691_i10 : Template HasSnaky 3 required_691_i10 envelope_691_i10 := by + refine compose HasSnaky 2 childrenC_691_i10 childrenD_691_i10 children_work_691_i10 (2, 6) + required_691_i10 envelope_691_i10 pivot_mem_691_i10 child_required_sub_691_i10 child_envelope_sub_691_i10 ?_ + intro b hb + exact common_sub_691_i10 (mem_commonEnvelope childrenD_691_i10 b hb) +def required_691_i9 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (6, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i9 : Finset Cell := ⟨(([(2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 6), (9, 7), (9, 8), (9, 9), (10, 6), (10, 7), (10, 8), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i9 : Fin 3 → Finset Cell := ![required_691_i10, (placed21 4 (5, 10) required_460), (placed21 0 (2, 2) required_488)] +def childrenD_691_i9 : Fin 3 → Finset Cell := ![envelope_691_i10, (placed21 4 (5, 10) envelope_460), (placed21 0 (2, 2) envelope_488)] +theorem common_sub_691_i9 : commonEnvelope childrenD_691_i9 ⊆ insert (6, 7) required_691_i9 := by decide +kernel +theorem child_required_sub_691_i9 : ∀ j, childrenC_691_i9 j ⊆ insert (6, 7) required_691_i9 := by decide +kernel +theorem child_envelope_sub_691_i9 : ∀ j, childrenD_691_i9 j ⊆ envelope_691_i9 := by decide +kernel +theorem pivot_mem_691_i9 : (6, 7) ∈ envelope_691_i9 := by decide +kernel +theorem children_work_691_i9 : ∀ j, Template HasSnaky 10 (childrenC_691_i9 j) (childrenD_691_i9 j) := by + intro j + fin_cases j + · exact row_works_691_i10.mono (by decide +kernel) + · exact (placed21_template row_works_460 4 (5, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_488 0 (2, 2)).mono (by decide +kernel) +theorem row_works_691_i9 : Template HasSnaky 11 required_691_i9 envelope_691_i9 := by + refine compose HasSnaky 10 childrenC_691_i9 childrenD_691_i9 children_work_691_i9 (6, 7) + required_691_i9 envelope_691_i9 pivot_mem_691_i9 child_required_sub_691_i9 child_envelope_sub_691_i9 ?_ + intro b hb + exact common_sub_691_i9 (mem_commonEnvelope childrenD_691_i9 b hb) +def required_691_i8 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i8 : Finset Cell := ⟨(([(2, 4), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 5), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 6), (9, 7), (9, 8), (9, 9), (10, 6), (10, 7), (10, 8), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i8 : Fin 3 → Finset Cell := ![(placed21 1 (2, 4) required_39), (placed21 1 (2, 4) required_80), required_691_i9] +def childrenD_691_i8 : Fin 3 → Finset Cell := ![(placed21 1 (2, 4) envelope_39), (placed21 1 (2, 4) envelope_80), envelope_691_i9] +theorem common_sub_691_i8 : commonEnvelope childrenD_691_i8 ⊆ insert (6, 5) required_691_i8 := by decide +kernel +theorem child_required_sub_691_i8 : ∀ j, childrenC_691_i8 j ⊆ insert (6, 5) required_691_i8 := by decide +kernel +theorem child_envelope_sub_691_i8 : ∀ j, childrenD_691_i8 j ⊆ envelope_691_i8 := by decide +kernel +theorem pivot_mem_691_i8 : (6, 5) ∈ envelope_691_i8 := by decide +kernel +theorem children_work_691_i8 : ∀ j, Template HasSnaky 11 (childrenC_691_i8 j) (childrenD_691_i8 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_39 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_80 1 (2, 4)).mono (by decide +kernel) + · exact row_works_691_i9.mono (by decide +kernel) +theorem row_works_691_i8 : Template HasSnaky 12 required_691_i8 envelope_691_i8 := by + refine compose HasSnaky 11 childrenC_691_i8 childrenD_691_i8 children_work_691_i8 (6, 5) + required_691_i8 envelope_691_i8 pivot_mem_691_i8 child_required_sub_691_i8 child_envelope_sub_691_i8 ?_ + intro b hb + exact common_sub_691_i8 (mem_commonEnvelope childrenD_691_i8 b hb) +def required_691_i7 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6), (3, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i7 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 3), (2, 4), (2, 6), (2, 7), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 6), (9, 7), (9, 8), (9, 9), (10, 6), (10, 7), (10, 8), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i7 : Fin 3 → Finset Cell := ![(placed21 0 (3, 4) required_21), (placed21 7 (6, 7) required_56), required_691_i8] +def childrenD_691_i7 : Fin 3 → Finset Cell := ![(placed21 0 (3, 4) envelope_21), (placed21 7 (6, 7) envelope_56), envelope_691_i8] +theorem common_sub_691_i7 : commonEnvelope childrenD_691_i7 ⊆ insert (4, 5) required_691_i7 := by decide +kernel +theorem child_required_sub_691_i7 : ∀ j, childrenC_691_i7 j ⊆ insert (4, 5) required_691_i7 := by decide +kernel +theorem child_envelope_sub_691_i7 : ∀ j, childrenD_691_i7 j ⊆ envelope_691_i7 := by decide +kernel +theorem pivot_mem_691_i7 : (4, 5) ∈ envelope_691_i7 := by decide +kernel +theorem children_work_691_i7 : ∀ j, Template HasSnaky 12 (childrenC_691_i7 j) (childrenD_691_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_21 0 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_56 7 (6, 7)).mono (by decide +kernel) + · exact row_works_691_i8.mono (by decide +kernel) +theorem row_works_691_i7 : Template HasSnaky 13 required_691_i7 envelope_691_i7 := by + refine compose HasSnaky 12 childrenC_691_i7 childrenD_691_i7 children_work_691_i7 (4, 5) + required_691_i7 envelope_691_i7 pivot_mem_691_i7 child_required_sub_691_i7 child_envelope_sub_691_i7 ?_ + intro b hb + exact common_sub_691_i7 (mem_commonEnvelope childrenD_691_i7 b hb) +def required_691_i6 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5), (3, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691_i6 : Finset Cell := ⟨(([(0, 4), (1, 4), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 4), (4, 5), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 6), (9, 7), (9, 8), (9, 9), (10, 6), (10, 7), (10, 8), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691_i6 : Fin 4 → Finset Cell := ![(placed21 2 (3, 3) required_6), (placed21 1 (2, 4) required_8), (placed21 1 (0, 2) required_690), required_691_i7] +def childrenD_691_i6 : Fin 4 → Finset Cell := ![(placed21 2 (3, 3) envelope_6), (placed21 1 (2, 4) envelope_8), (placed21 1 (0, 2) envelope_690), envelope_691_i7] +theorem common_sub_691_i6 : commonEnvelope childrenD_691_i6 ⊆ insert (3, 7) required_691_i6 := by decide +kernel +theorem child_required_sub_691_i6 : ∀ j, childrenC_691_i6 j ⊆ insert (3, 7) required_691_i6 := by decide +kernel +theorem child_envelope_sub_691_i6 : ∀ j, childrenD_691_i6 j ⊆ envelope_691_i6 := by decide +kernel +theorem pivot_mem_691_i6 : (3, 7) ∈ envelope_691_i6 := by decide +kernel +theorem children_work_691_i6 : ∀ j, Template HasSnaky 13 (childrenC_691_i6 j) (childrenD_691_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_6 2 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_8 1 (2, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_690 1 (0, 2)).mono (by decide +kernel) + · exact row_works_691_i7.mono (by decide +kernel) +theorem row_works_691_i6 : Template HasSnaky 14 required_691_i6 envelope_691_i6 := by + refine compose HasSnaky 13 childrenC_691_i6 childrenD_691_i6 children_work_691_i6 (3, 7) + required_691_i6 envelope_691_i6 pivot_mem_691_i6 child_required_sub_691_i6 child_envelope_sub_691_i6 ?_ + intro b hb + exact common_sub_691_i6 (mem_commonEnvelope childrenD_691_i6 b hb) +def required_691 : Finset Cell := ⟨(([(3, 3), (3, 4), (3, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_691 : Finset Cell := ⟨(([(0, 4), (1, 4), (1, 6), (2, 3), (2, 4), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 0), (4, 1), (4, 2), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (11, 3), (11, 5)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_691 : Fin 4 → Finset Cell := ![(placed21 1 (2, 3) required_8), required_691_i0, required_691_i1, required_691_i6] +def childrenD_691 : Fin 4 → Finset Cell := ![(placed21 1 (2, 3) envelope_8), envelope_691_i0, envelope_691_i1, envelope_691_i6] +theorem common_sub_691 : commonEnvelope childrenD_691 ⊆ insert (3, 6) required_691 := by decide +kernel +theorem child_required_sub_691 : ∀ j, childrenC_691 j ⊆ insert (3, 6) required_691 := by decide +kernel +theorem child_envelope_sub_691 : ∀ j, childrenD_691 j ⊆ envelope_691 := by decide +kernel +theorem pivot_mem_691 : (3, 6) ∈ envelope_691 := by decide +kernel +theorem children_work_691 : ∀ j, Template HasSnaky 17 (childrenC_691 j) (childrenD_691 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 1 (2, 3)).mono (by decide +kernel) + · exact row_works_691_i0.mono (by decide +kernel) + · exact row_works_691_i1.mono (by decide +kernel) + · exact row_works_691_i6.mono (by decide +kernel) +theorem row_works_691 : Template HasSnaky 18 required_691 envelope_691 := by + refine compose HasSnaky 17 childrenC_691 childrenD_691 children_work_691 (3, 6) + required_691 envelope_691 pivot_mem_691 child_required_sub_691 child_envelope_sub_691 ?_ + intro b hb + exact common_sub_691 (mem_commonEnvelope childrenD_691 b hb) +def height_684_i1 : ℕ := 13 +def childrenH_684_i1 : Fin 6 → ℕ := ![height_8, height_115, height_469, height_470, height_485, height_489] +theorem height_exact_684_i1 : height_684_i1 = 1 + Finset.univ.sup childrenH_684_i1 := by decide +kernel +theorem required_origin_684_i1 : ∀ x ∈ required_684_i1, + (∃ j, x ∈ childrenC_684_i1 j) ∨ ∀ j, x ∈ childrenD_684_i1 j := by decide +kernel +theorem required_exact_684_i1 : required_684_i1 = + ((Finset.univ.biUnion childrenC_684_i1) ∪ commonEnvelope childrenD_684_i1).erase (9, 7) := by + exact required_eq_combination childrenC_684_i1 childrenD_684_i1 (9, 7) required_684_i1 + (by decide +kernel) child_required_sub_684_i1 common_sub_684_i1 required_origin_684_i1 +theorem envelope_origin_684_i1 : ∀ x ∈ envelope_684_i1, + x = (9, 7) ∨ ∃ j, x ∈ childrenD_684_i1 j := by decide +kernel +theorem envelope_exact_684_i1 : envelope_684_i1 = + insert (9, 7) (Finset.univ.biUnion childrenD_684_i1) := by + exact envelope_eq_combination childrenD_684_i1 (9, 7) envelope_684_i1 + pivot_mem_684_i1 child_envelope_sub_684_i1 envelope_origin_684_i1 +def checked_684_i1 : CheckedCard where + required := required_684_i1 + envelope := envelope_684_i1 + height := height_684_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_684_i1 +def height_684_i0 : ℕ := 14 +def childrenH_684_i0 : Fin 6 → ℕ := ![height_118, height_355, height_434, height_468, height_684_i1, height_491] +theorem height_exact_684_i0 : height_684_i0 = 1 + Finset.univ.sup childrenH_684_i0 := by decide +kernel +theorem required_origin_684_i0 : ∀ x ∈ required_684_i0, + (∃ j, x ∈ childrenC_684_i0 j) ∨ ∀ j, x ∈ childrenD_684_i0 j := by decide +kernel +theorem required_exact_684_i0 : required_684_i0 = + ((Finset.univ.biUnion childrenC_684_i0) ∪ commonEnvelope childrenD_684_i0).erase (8, 7) := by + exact required_eq_combination childrenC_684_i0 childrenD_684_i0 (8, 7) required_684_i0 + (by decide +kernel) child_required_sub_684_i0 common_sub_684_i0 required_origin_684_i0 +theorem envelope_origin_684_i0 : ∀ x ∈ envelope_684_i0, + x = (8, 7) ∨ ∃ j, x ∈ childrenD_684_i0 j := by decide +kernel +theorem envelope_exact_684_i0 : envelope_684_i0 = + insert (8, 7) (Finset.univ.biUnion childrenD_684_i0) := by + exact envelope_eq_combination childrenD_684_i0 (8, 7) envelope_684_i0 + pivot_mem_684_i0 child_envelope_sub_684_i0 envelope_origin_684_i0 +def checked_684_i0 : CheckedCard where + required := required_684_i0 + envelope := envelope_684_i0 + height := height_684_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_684_i0 +def height_684_i2 : ℕ := 12 +def childrenH_684_i2 : Fin 6 → ℕ := ![height_50, height_97, height_98, height_454, height_455, height_624] +theorem height_exact_684_i2 : height_684_i2 = 1 + Finset.univ.sup childrenH_684_i2 := by decide +kernel +theorem required_origin_684_i2 : ∀ x ∈ required_684_i2, + (∃ j, x ∈ childrenC_684_i2 j) ∨ ∀ j, x ∈ childrenD_684_i2 j := by decide +kernel +theorem required_exact_684_i2 : required_684_i2 = + ((Finset.univ.biUnion childrenC_684_i2) ∪ commonEnvelope childrenD_684_i2).erase (7, 9) := by + exact required_eq_combination childrenC_684_i2 childrenD_684_i2 (7, 9) required_684_i2 + (by decide +kernel) child_required_sub_684_i2 common_sub_684_i2 required_origin_684_i2 +theorem envelope_origin_684_i2 : ∀ x ∈ envelope_684_i2, + x = (7, 9) ∨ ∃ j, x ∈ childrenD_684_i2 j := by decide +kernel +theorem envelope_exact_684_i2 : envelope_684_i2 = + insert (7, 9) (Finset.univ.biUnion childrenD_684_i2) := by + exact envelope_eq_combination childrenD_684_i2 (7, 9) envelope_684_i2 + pivot_mem_684_i2 child_envelope_sub_684_i2 envelope_origin_684_i2 +def checked_684_i2 : CheckedCard where + required := required_684_i2 + envelope := envelope_684_i2 + height := height_684_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_684_i2 +def height_684_i3 : ℕ := 15 +def childrenH_684_i3 : Fin 13 → ℕ := ![height_174, height_475, height_475, height_483, height_508, height_508, height_566, height_587, height_587, height_635, height_644, height_645, height_647] +theorem height_exact_684_i3 : height_684_i3 = 1 + Finset.univ.sup childrenH_684_i3 := by decide +kernel +theorem required_origin_684_i3 : ∀ x ∈ required_684_i3, + (∃ j, x ∈ childrenC_684_i3 j) ∨ ∀ j, x ∈ childrenD_684_i3 j := by decide +kernel +theorem required_exact_684_i3 : required_684_i3 = + ((Finset.univ.biUnion childrenC_684_i3) ∪ commonEnvelope childrenD_684_i3).erase (7, 11) := by + exact required_eq_combination childrenC_684_i3 childrenD_684_i3 (7, 11) required_684_i3 + (by decide +kernel) child_required_sub_684_i3 common_sub_684_i3 required_origin_684_i3 +theorem envelope_origin_684_i3 : ∀ x ∈ envelope_684_i3, + x = (7, 11) ∨ ∃ j, x ∈ childrenD_684_i3 j := by decide +kernel +theorem envelope_exact_684_i3 : envelope_684_i3 = + insert (7, 11) (Finset.univ.biUnion childrenD_684_i3) := by + exact envelope_eq_combination childrenD_684_i3 (7, 11) envelope_684_i3 + pivot_mem_684_i3 child_envelope_sub_684_i3 envelope_origin_684_i3 +def checked_684_i3 : CheckedCard where + required := required_684_i3 + envelope := envelope_684_i3 + height := height_684_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_684_i3 +def height_684_i5 : ℕ := 7 +def childrenH_684_i5 : Fin 2 → ℕ := ![height_8, height_313] +theorem height_exact_684_i5 : height_684_i5 = 1 + Finset.univ.sup childrenH_684_i5 := by decide +kernel +theorem required_origin_684_i5 : ∀ x ∈ required_684_i5, + (∃ j, x ∈ childrenC_684_i5 j) ∨ ∀ j, x ∈ childrenD_684_i5 j := by decide +kernel +theorem required_exact_684_i5 : required_684_i5 = + ((Finset.univ.biUnion childrenC_684_i5) ∪ commonEnvelope childrenD_684_i5).erase (9, 7) := by + exact required_eq_combination childrenC_684_i5 childrenD_684_i5 (9, 7) required_684_i5 + (by decide +kernel) child_required_sub_684_i5 common_sub_684_i5 required_origin_684_i5 +theorem envelope_origin_684_i5 : ∀ x ∈ envelope_684_i5, + x = (9, 7) ∨ ∃ j, x ∈ childrenD_684_i5 j := by decide +kernel +theorem envelope_exact_684_i5 : envelope_684_i5 = + insert (9, 7) (Finset.univ.biUnion childrenD_684_i5) := by + exact envelope_eq_combination childrenD_684_i5 (9, 7) envelope_684_i5 + pivot_mem_684_i5 child_envelope_sub_684_i5 envelope_origin_684_i5 +def checked_684_i5 : CheckedCard where + required := required_684_i5 + envelope := envelope_684_i5 + height := height_684_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_684_i5 +def height_684_i4 : ℕ := 12 +def childrenH_684_i4 : Fin 5 → ℕ := ![height_257, height_684_i5, height_434, height_468, height_491] +theorem height_exact_684_i4 : height_684_i4 = 1 + Finset.univ.sup childrenH_684_i4 := by decide +kernel +theorem required_origin_684_i4 : ∀ x ∈ required_684_i4, + (∃ j, x ∈ childrenC_684_i4 j) ∨ ∀ j, x ∈ childrenD_684_i4 j := by decide +kernel +theorem required_exact_684_i4 : required_684_i4 = + ((Finset.univ.biUnion childrenC_684_i4) ∪ commonEnvelope childrenD_684_i4).erase (8, 7) := by + exact required_eq_combination childrenC_684_i4 childrenD_684_i4 (8, 7) required_684_i4 + (by decide +kernel) child_required_sub_684_i4 common_sub_684_i4 required_origin_684_i4 +theorem envelope_origin_684_i4 : ∀ x ∈ envelope_684_i4, + x = (8, 7) ∨ ∃ j, x ∈ childrenD_684_i4 j := by decide +kernel +theorem envelope_exact_684_i4 : envelope_684_i4 = + insert (8, 7) (Finset.univ.biUnion childrenD_684_i4) := by + exact envelope_eq_combination childrenD_684_i4 (8, 7) envelope_684_i4 + pivot_mem_684_i4 child_envelope_sub_684_i4 envelope_origin_684_i4 +def checked_684_i4 : CheckedCard where + required := required_684_i4 + envelope := envelope_684_i4 + height := height_684_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_684_i4 +def height_684 : ℕ := 18 +def childrenH_684 : Fin 15 → ℕ := ![height_684_i0, height_623, height_684_i2, height_625, height_630, height_632, height_636, height_639, height_684_i3, height_656, height_657, height_670, height_675, height_683, height_684_i4] +theorem height_exact_684 : height_684 = 1 + Finset.univ.sup childrenH_684 := by decide +kernel +theorem required_origin_684 : ∀ x ∈ required_684, + (∃ j, x ∈ childrenC_684 j) ∨ ∀ j, x ∈ childrenD_684 j := by decide +kernel +theorem required_exact_684 : required_684 = + ((Finset.univ.biUnion childrenC_684) ∪ commonEnvelope childrenD_684).erase (7, 10) := by + exact required_eq_combination childrenC_684 childrenD_684 (7, 10) required_684 + (by decide +kernel) child_required_sub_684 common_sub_684 required_origin_684 +theorem envelope_origin_684 : ∀ x ∈ envelope_684, + x = (7, 10) ∨ ∃ j, x ∈ childrenD_684 j := by decide +kernel +theorem envelope_exact_684 : envelope_684 = + insert (7, 10) (Finset.univ.biUnion childrenD_684) := by + exact envelope_eq_combination childrenD_684 (7, 10) envelope_684 + pivot_mem_684 child_envelope_sub_684 envelope_origin_684 +def checked_684 : CheckedCard where + required := required_684 + envelope := envelope_684 + height := height_684 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_684 +def height_691_i0 : ℕ := 6 +def childrenH_691_i0 : Fin 3 → ℕ := ![height_27, height_277, height_278] +theorem height_exact_691_i0 : height_691_i0 = 1 + Finset.univ.sup childrenH_691_i0 := by decide +kernel +theorem required_origin_691_i0 : ∀ x ∈ required_691_i0, + (∃ j, x ∈ childrenC_691_i0 j) ∨ ∀ j, x ∈ childrenD_691_i0 j := by decide +kernel +theorem required_exact_691_i0 : required_691_i0 = + ((Finset.univ.biUnion childrenC_691_i0) ∪ commonEnvelope childrenD_691_i0).erase (4, 5) := by + exact required_eq_combination childrenC_691_i0 childrenD_691_i0 (4, 5) required_691_i0 + (by decide +kernel) child_required_sub_691_i0 common_sub_691_i0 required_origin_691_i0 +theorem envelope_origin_691_i0 : ∀ x ∈ envelope_691_i0, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_691_i0 j := by decide +kernel +theorem envelope_exact_691_i0 : envelope_691_i0 = + insert (4, 5) (Finset.univ.biUnion childrenD_691_i0) := by + exact envelope_eq_combination childrenD_691_i0 (4, 5) envelope_691_i0 + pivot_mem_691_i0 child_envelope_sub_691_i0 envelope_origin_691_i0 +def checked_691_i0 : CheckedCard where + required := required_691_i0 + envelope := envelope_691_i0 + height := height_691_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i0 +def height_691_i5 : ℕ := 8 +def childrenH_691_i5 : Fin 2 → ℕ := ![height_0, height_317] +theorem height_exact_691_i5 : height_691_i5 = 1 + Finset.univ.sup childrenH_691_i5 := by decide +kernel +theorem required_origin_691_i5 : ∀ x ∈ required_691_i5, + (∃ j, x ∈ childrenC_691_i5 j) ∨ ∀ j, x ∈ childrenD_691_i5 j := by decide +kernel +theorem required_exact_691_i5 : required_691_i5 = + ((Finset.univ.biUnion childrenC_691_i5) ∪ commonEnvelope childrenD_691_i5).erase (5, 6) := by + exact required_eq_combination childrenC_691_i5 childrenD_691_i5 (5, 6) required_691_i5 + (by decide +kernel) child_required_sub_691_i5 common_sub_691_i5 required_origin_691_i5 +theorem envelope_origin_691_i5 : ∀ x ∈ envelope_691_i5, + x = (5, 6) ∨ ∃ j, x ∈ childrenD_691_i5 j := by decide +kernel +theorem envelope_exact_691_i5 : envelope_691_i5 = + insert (5, 6) (Finset.univ.biUnion childrenD_691_i5) := by + exact envelope_eq_combination childrenD_691_i5 (5, 6) envelope_691_i5 + pivot_mem_691_i5 child_envelope_sub_691_i5 envelope_origin_691_i5 +def checked_691_i5 : CheckedCard where + required := required_691_i5 + envelope := envelope_691_i5 + height := height_691_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i5 +def height_691_i4 : ℕ := 14 +def childrenH_691_i4 : Fin 4 → ℕ := ![height_30, height_59, height_462, height_691_i5] +theorem height_exact_691_i4 : height_691_i4 = 1 + Finset.univ.sup childrenH_691_i4 := by decide +kernel +theorem required_origin_691_i4 : ∀ x ∈ required_691_i4, + (∃ j, x ∈ childrenC_691_i4 j) ∨ ∀ j, x ∈ childrenD_691_i4 j := by decide +kernel +theorem required_exact_691_i4 : required_691_i4 = + ((Finset.univ.biUnion childrenC_691_i4) ∪ commonEnvelope childrenD_691_i4).erase (6, 6) := by + exact required_eq_combination childrenC_691_i4 childrenD_691_i4 (6, 6) required_691_i4 + (by decide +kernel) child_required_sub_691_i4 common_sub_691_i4 required_origin_691_i4 +theorem envelope_origin_691_i4 : ∀ x ∈ envelope_691_i4, + x = (6, 6) ∨ ∃ j, x ∈ childrenD_691_i4 j := by decide +kernel +theorem envelope_exact_691_i4 : envelope_691_i4 = + insert (6, 6) (Finset.univ.biUnion childrenD_691_i4) := by + exact envelope_eq_combination childrenD_691_i4 (6, 6) envelope_691_i4 + pivot_mem_691_i4 child_envelope_sub_691_i4 envelope_origin_691_i4 +def checked_691_i4 : CheckedCard where + required := required_691_i4 + envelope := envelope_691_i4 + height := height_691_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i4 +def height_691_i3 : ℕ := 15 +def childrenH_691_i3 : Fin 3 → ℕ := ![height_102, height_400, height_691_i4] +theorem height_exact_691_i3 : height_691_i3 = 1 + Finset.univ.sup childrenH_691_i3 := by decide +kernel +theorem required_origin_691_i3 : ∀ x ∈ required_691_i3, + (∃ j, x ∈ childrenC_691_i3 j) ∨ ∀ j, x ∈ childrenD_691_i3 j := by decide +kernel +theorem required_exact_691_i3 : required_691_i3 = + ((Finset.univ.biUnion childrenC_691_i3) ∪ commonEnvelope childrenD_691_i3).erase (6, 5) := by + exact required_eq_combination childrenC_691_i3 childrenD_691_i3 (6, 5) required_691_i3 + (by decide +kernel) child_required_sub_691_i3 common_sub_691_i3 required_origin_691_i3 +theorem envelope_origin_691_i3 : ∀ x ∈ envelope_691_i3, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_691_i3 j := by decide +kernel +theorem envelope_exact_691_i3 : envelope_691_i3 = + insert (6, 5) (Finset.univ.biUnion childrenD_691_i3) := by + exact envelope_eq_combination childrenD_691_i3 (6, 5) envelope_691_i3 + pivot_mem_691_i3 child_envelope_sub_691_i3 envelope_origin_691_i3 +def checked_691_i3 : CheckedCard where + required := required_691_i3 + envelope := envelope_691_i3 + height := height_691_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i3 +def height_691_i2 : ℕ := 16 +def childrenH_691_i2 : Fin 2 → ℕ := ![height_0, height_691_i3] +theorem height_exact_691_i2 : height_691_i2 = 1 + Finset.univ.sup childrenH_691_i2 := by decide +kernel +theorem required_origin_691_i2 : ∀ x ∈ required_691_i2, + (∃ j, x ∈ childrenC_691_i2 j) ∨ ∀ j, x ∈ childrenD_691_i2 j := by decide +kernel +theorem required_exact_691_i2 : required_691_i2 = + ((Finset.univ.biUnion childrenC_691_i2) ∪ commonEnvelope childrenD_691_i2).erase (4, 5) := by + exact required_eq_combination childrenC_691_i2 childrenD_691_i2 (4, 5) required_691_i2 + (by decide +kernel) child_required_sub_691_i2 common_sub_691_i2 required_origin_691_i2 +theorem envelope_origin_691_i2 : ∀ x ∈ envelope_691_i2, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_691_i2 j := by decide +kernel +theorem envelope_exact_691_i2 : envelope_691_i2 = + insert (4, 5) (Finset.univ.biUnion childrenD_691_i2) := by + exact envelope_eq_combination childrenD_691_i2 (4, 5) envelope_691_i2 + pivot_mem_691_i2 child_envelope_sub_691_i2 envelope_origin_691_i2 +def checked_691_i2 : CheckedCard where + required := required_691_i2 + envelope := envelope_691_i2 + height := height_691_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i2 +def height_691_i1 : ℕ := 17 +def childrenH_691_i1 : Fin 2 → ℕ := ![height_5, height_691_i2] +theorem height_exact_691_i1 : height_691_i1 = 1 + Finset.univ.sup childrenH_691_i1 := by decide +kernel +theorem required_origin_691_i1 : ∀ x ∈ required_691_i1, + (∃ j, x ∈ childrenC_691_i1 j) ∨ ∀ j, x ∈ childrenD_691_i1 j := by decide +kernel +theorem required_exact_691_i1 : required_691_i1 = + ((Finset.univ.biUnion childrenC_691_i1) ∪ commonEnvelope childrenD_691_i1).erase (4, 6) := by + exact required_eq_combination childrenC_691_i1 childrenD_691_i1 (4, 6) required_691_i1 + (by decide +kernel) child_required_sub_691_i1 common_sub_691_i1 required_origin_691_i1 +theorem envelope_origin_691_i1 : ∀ x ∈ envelope_691_i1, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_691_i1 j := by decide +kernel +theorem envelope_exact_691_i1 : envelope_691_i1 = + insert (4, 6) (Finset.univ.biUnion childrenD_691_i1) := by + exact envelope_eq_combination childrenD_691_i1 (4, 6) envelope_691_i1 + pivot_mem_691_i1 child_envelope_sub_691_i1 envelope_origin_691_i1 +def checked_691_i1 : CheckedCard where + required := required_691_i1 + envelope := envelope_691_i1 + height := height_691_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i1 +def height_691_i10 : ℕ := 3 +def childrenH_691_i10 : Fin 2 → ℕ := ![height_5, height_35] +theorem height_exact_691_i10 : height_691_i10 = 1 + Finset.univ.sup childrenH_691_i10 := by decide +kernel +theorem required_origin_691_i10 : ∀ x ∈ required_691_i10, + (∃ j, x ∈ childrenC_691_i10 j) ∨ ∀ j, x ∈ childrenD_691_i10 j := by decide +kernel +theorem required_exact_691_i10 : required_691_i10 = + ((Finset.univ.biUnion childrenC_691_i10) ∪ commonEnvelope childrenD_691_i10).erase (2, 6) := by + exact required_eq_combination childrenC_691_i10 childrenD_691_i10 (2, 6) required_691_i10 + (by decide +kernel) child_required_sub_691_i10 common_sub_691_i10 required_origin_691_i10 +theorem envelope_origin_691_i10 : ∀ x ∈ envelope_691_i10, + x = (2, 6) ∨ ∃ j, x ∈ childrenD_691_i10 j := by decide +kernel +theorem envelope_exact_691_i10 : envelope_691_i10 = + insert (2, 6) (Finset.univ.biUnion childrenD_691_i10) := by + exact envelope_eq_combination childrenD_691_i10 (2, 6) envelope_691_i10 + pivot_mem_691_i10 child_envelope_sub_691_i10 envelope_origin_691_i10 +def checked_691_i10 : CheckedCard where + required := required_691_i10 + envelope := envelope_691_i10 + height := height_691_i10 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i10 +def height_691_i9 : ℕ := 11 +def childrenH_691_i9 : Fin 3 → ℕ := ![height_691_i10, height_460, height_488] +theorem height_exact_691_i9 : height_691_i9 = 1 + Finset.univ.sup childrenH_691_i9 := by decide +kernel +theorem required_origin_691_i9 : ∀ x ∈ required_691_i9, + (∃ j, x ∈ childrenC_691_i9 j) ∨ ∀ j, x ∈ childrenD_691_i9 j := by decide +kernel +theorem required_exact_691_i9 : required_691_i9 = + ((Finset.univ.biUnion childrenC_691_i9) ∪ commonEnvelope childrenD_691_i9).erase (6, 7) := by + exact required_eq_combination childrenC_691_i9 childrenD_691_i9 (6, 7) required_691_i9 + (by decide +kernel) child_required_sub_691_i9 common_sub_691_i9 required_origin_691_i9 +theorem envelope_origin_691_i9 : ∀ x ∈ envelope_691_i9, + x = (6, 7) ∨ ∃ j, x ∈ childrenD_691_i9 j := by decide +kernel +theorem envelope_exact_691_i9 : envelope_691_i9 = + insert (6, 7) (Finset.univ.biUnion childrenD_691_i9) := by + exact envelope_eq_combination childrenD_691_i9 (6, 7) envelope_691_i9 + pivot_mem_691_i9 child_envelope_sub_691_i9 envelope_origin_691_i9 +def checked_691_i9 : CheckedCard where + required := required_691_i9 + envelope := envelope_691_i9 + height := height_691_i9 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i9 +def height_691_i8 : ℕ := 12 +def childrenH_691_i8 : Fin 3 → ℕ := ![height_39, height_80, height_691_i9] +theorem height_exact_691_i8 : height_691_i8 = 1 + Finset.univ.sup childrenH_691_i8 := by decide +kernel +theorem required_origin_691_i8 : ∀ x ∈ required_691_i8, + (∃ j, x ∈ childrenC_691_i8 j) ∨ ∀ j, x ∈ childrenD_691_i8 j := by decide +kernel +theorem required_exact_691_i8 : required_691_i8 = + ((Finset.univ.biUnion childrenC_691_i8) ∪ commonEnvelope childrenD_691_i8).erase (6, 5) := by + exact required_eq_combination childrenC_691_i8 childrenD_691_i8 (6, 5) required_691_i8 + (by decide +kernel) child_required_sub_691_i8 common_sub_691_i8 required_origin_691_i8 +theorem envelope_origin_691_i8 : ∀ x ∈ envelope_691_i8, + x = (6, 5) ∨ ∃ j, x ∈ childrenD_691_i8 j := by decide +kernel +theorem envelope_exact_691_i8 : envelope_691_i8 = + insert (6, 5) (Finset.univ.biUnion childrenD_691_i8) := by + exact envelope_eq_combination childrenD_691_i8 (6, 5) envelope_691_i8 + pivot_mem_691_i8 child_envelope_sub_691_i8 envelope_origin_691_i8 +def checked_691_i8 : CheckedCard where + required := required_691_i8 + envelope := envelope_691_i8 + height := height_691_i8 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i8 +def height_691_i7 : ℕ := 13 +def childrenH_691_i7 : Fin 3 → ℕ := ![height_21, height_56, height_691_i8] +theorem height_exact_691_i7 : height_691_i7 = 1 + Finset.univ.sup childrenH_691_i7 := by decide +kernel +theorem required_origin_691_i7 : ∀ x ∈ required_691_i7, + (∃ j, x ∈ childrenC_691_i7 j) ∨ ∀ j, x ∈ childrenD_691_i7 j := by decide +kernel +theorem required_exact_691_i7 : required_691_i7 = + ((Finset.univ.biUnion childrenC_691_i7) ∪ commonEnvelope childrenD_691_i7).erase (4, 5) := by + exact required_eq_combination childrenC_691_i7 childrenD_691_i7 (4, 5) required_691_i7 + (by decide +kernel) child_required_sub_691_i7 common_sub_691_i7 required_origin_691_i7 +theorem envelope_origin_691_i7 : ∀ x ∈ envelope_691_i7, + x = (4, 5) ∨ ∃ j, x ∈ childrenD_691_i7 j := by decide +kernel +theorem envelope_exact_691_i7 : envelope_691_i7 = + insert (4, 5) (Finset.univ.biUnion childrenD_691_i7) := by + exact envelope_eq_combination childrenD_691_i7 (4, 5) envelope_691_i7 + pivot_mem_691_i7 child_envelope_sub_691_i7 envelope_origin_691_i7 +def checked_691_i7 : CheckedCard where + required := required_691_i7 + envelope := envelope_691_i7 + height := height_691_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i7 +def height_691_i6 : ℕ := 14 +def childrenH_691_i6 : Fin 4 → ℕ := ![height_6, height_8, height_690, height_691_i7] +theorem height_exact_691_i6 : height_691_i6 = 1 + Finset.univ.sup childrenH_691_i6 := by decide +kernel +theorem required_origin_691_i6 : ∀ x ∈ required_691_i6, + (∃ j, x ∈ childrenC_691_i6 j) ∨ ∀ j, x ∈ childrenD_691_i6 j := by decide +kernel +theorem required_exact_691_i6 : required_691_i6 = + ((Finset.univ.biUnion childrenC_691_i6) ∪ commonEnvelope childrenD_691_i6).erase (3, 7) := by + exact required_eq_combination childrenC_691_i6 childrenD_691_i6 (3, 7) required_691_i6 + (by decide +kernel) child_required_sub_691_i6 common_sub_691_i6 required_origin_691_i6 +theorem envelope_origin_691_i6 : ∀ x ∈ envelope_691_i6, + x = (3, 7) ∨ ∃ j, x ∈ childrenD_691_i6 j := by decide +kernel +theorem envelope_exact_691_i6 : envelope_691_i6 = + insert (3, 7) (Finset.univ.biUnion childrenD_691_i6) := by + exact envelope_eq_combination childrenD_691_i6 (3, 7) envelope_691_i6 + pivot_mem_691_i6 child_envelope_sub_691_i6 envelope_origin_691_i6 +def checked_691_i6 : CheckedCard where + required := required_691_i6 + envelope := envelope_691_i6 + height := height_691_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691_i6 +def height_691 : ℕ := 18 +def childrenH_691 : Fin 4 → ℕ := ![height_8, height_691_i0, height_691_i1, height_691_i6] +theorem height_exact_691 : height_691 = 1 + Finset.univ.sup childrenH_691 := by decide +kernel +theorem required_origin_691 : ∀ x ∈ required_691, + (∃ j, x ∈ childrenC_691 j) ∨ ∀ j, x ∈ childrenD_691 j := by decide +kernel +theorem required_exact_691 : required_691 = + ((Finset.univ.biUnion childrenC_691) ∪ commonEnvelope childrenD_691).erase (3, 6) := by + exact required_eq_combination childrenC_691 childrenD_691 (3, 6) required_691 + (by decide +kernel) child_required_sub_691 common_sub_691 required_origin_691 +theorem envelope_origin_691 : ∀ x ∈ envelope_691, + x = (3, 6) ∨ ∃ j, x ∈ childrenD_691 j := by decide +kernel +theorem envelope_exact_691 : envelope_691 = + insert (3, 6) (Finset.univ.biUnion childrenD_691) := by + exact envelope_eq_combination childrenD_691 (3, 6) envelope_691 + pivot_mem_691 child_envelope_sub_691 envelope_origin_691 +def checked_691 : CheckedCard where + required := required_691 + envelope := envelope_691 + height := height_691 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_691 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part02.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part02.lean new file mode 100644 index 0000000..279df04 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part02.lean @@ -0,0 +1,401 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part02 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_701_i1 : Finset Cell := ⟨(([(5, 7), (5, 10), (6, 7), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_701_i1 : Finset Cell := ⟨(([(4, 8), (4, 10), (4, 11), (4, 12), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 6), (6, 7), (6, 10), (6, 11), (6, 12), (7, 7), (8, 6), (8, 7), (8, 8), (9, 6), (9, 7), (9, 8), (10, 6), (10, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_701_i1 : Fin 2 → Finset Cell := ![(placed21 3 (4, 8) required_10), (placed21 2 (6, 6) required_39)] +def childrenD_701_i1 : Fin 2 → Finset Cell := ![(placed21 3 (4, 8) envelope_10), (placed21 2 (6, 6) envelope_39)] +theorem common_sub_701_i1 : commonEnvelope childrenD_701_i1 ⊆ insert (5, 8) required_701_i1 := by decide +kernel +theorem child_required_sub_701_i1 : ∀ j, childrenC_701_i1 j ⊆ insert (5, 8) required_701_i1 := by decide +kernel +theorem child_envelope_sub_701_i1 : ∀ j, childrenD_701_i1 j ⊆ envelope_701_i1 := by decide +kernel +theorem pivot_mem_701_i1 : (5, 8) ∈ envelope_701_i1 := by decide +kernel +theorem children_work_701_i1 : ∀ j, Template HasSnaky 4 (childrenC_701_i1 j) (childrenD_701_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 3 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_39 2 (6, 6)).mono (by decide +kernel) +theorem row_works_701_i1 : Template HasSnaky 5 required_701_i1 envelope_701_i1 := by + refine compose HasSnaky 4 childrenC_701_i1 childrenD_701_i1 children_work_701_i1 (5, 8) + required_701_i1 envelope_701_i1 pivot_mem_701_i1 child_required_sub_701_i1 child_envelope_sub_701_i1 ?_ + intro b hb + exact common_sub_701_i1 (mem_commonEnvelope childrenD_701_i1 b hb) +def required_701_i2 : Finset Cell := ⟨(([(5, 7), (5, 10), (6, 7), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_701_i2 : Finset Cell := ⟨(([(1, 9), (1, 11), (2, 8), (2, 9), (2, 10), (2, 11), (3, 8), (3, 9), (3, 10), (3, 11), (4, 7), (4, 8), (4, 10), (4, 11), (5, 7), (5, 8), (5, 9), (5, 10), (6, 6), (6, 7), (6, 9), (6, 10), (6, 11), (7, 7), (7, 9), (7, 10), (7, 11), (8, 7), (8, 9), (8, 10), (8, 11), (9, 9), (9, 10), (9, 11), (10, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_701_i2 : Fin 2 → Finset Cell := ![(placed21 5 (8, 7) required_52), (placed21 1 (1, 6) required_325)] +def childrenD_701_i2 : Fin 2 → Finset Cell := ![(placed21 5 (8, 7) envelope_52), (placed21 1 (1, 6) envelope_325)] +theorem common_sub_701_i2 : commonEnvelope childrenD_701_i2 ⊆ insert (5, 8) required_701_i2 := by decide +kernel +theorem child_required_sub_701_i2 : ∀ j, childrenC_701_i2 j ⊆ insert (5, 8) required_701_i2 := by decide +kernel +theorem child_envelope_sub_701_i2 : ∀ j, childrenD_701_i2 j ⊆ envelope_701_i2 := by decide +kernel +theorem pivot_mem_701_i2 : (5, 8) ∈ envelope_701_i2 := by decide +kernel +theorem children_work_701_i2 : ∀ j, Template HasSnaky 9 (childrenC_701_i2 j) (childrenD_701_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_52 5 (8, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_325 1 (1, 6)).mono (by decide +kernel) +theorem row_works_701_i2 : Template HasSnaky 10 required_701_i2 envelope_701_i2 := by + refine compose HasSnaky 9 childrenC_701_i2 childrenD_701_i2 children_work_701_i2 (5, 8) + required_701_i2 envelope_701_i2 pivot_mem_701_i2 child_required_sub_701_i2 child_envelope_sub_701_i2 ?_ + intro b hb + exact common_sub_701_i2 (mem_commonEnvelope childrenD_701_i2 b hb) +def required_701_i3 : Finset Cell := ⟨(([(5, 7), (5, 10), (6, 7), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_701_i3 : Finset Cell := ⟨(([(2, 6), (2, 8), (2, 9), (2, 11), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 7), (5, 10), (5, 11), (5, 12), (6, 6), (6, 7), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (10, 6), (10, 9), (10, 10), (10, 11), (11, 9), (11, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_701_i3 : Fin 2 → Finset Cell := ![(placed21 2 (7, 6) required_8), (placed21 1 (2, 6) required_463)] +def childrenD_701_i3 : Fin 2 → Finset Cell := ![(placed21 2 (7, 6) envelope_8), (placed21 1 (2, 6) envelope_463)] +theorem common_sub_701_i3 : commonEnvelope childrenD_701_i3 ⊆ insert (4, 7) required_701_i3 := by decide +kernel +theorem child_required_sub_701_i3 : ∀ j, childrenC_701_i3 j ⊆ insert (4, 7) required_701_i3 := by decide +kernel +theorem child_envelope_sub_701_i3 : ∀ j, childrenD_701_i3 j ⊆ envelope_701_i3 := by decide +kernel +theorem pivot_mem_701_i3 : (4, 7) ∈ envelope_701_i3 := by decide +kernel +theorem children_work_701_i3 : ∀ j, Template HasSnaky 11 (childrenC_701_i3 j) (childrenD_701_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_8 2 (7, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_463 1 (2, 6)).mono (by decide +kernel) +theorem row_works_701_i3 : Template HasSnaky 12 required_701_i3 envelope_701_i3 := by + refine compose HasSnaky 11 childrenC_701_i3 childrenD_701_i3 children_work_701_i3 (4, 7) + required_701_i3 envelope_701_i3 pivot_mem_701_i3 child_required_sub_701_i3 child_envelope_sub_701_i3 ?_ + intro b hb + exact common_sub_701_i3 (mem_commonEnvelope childrenD_701_i3 b hb) +def required_701_i4 : Finset Cell := ⟨(([(5, 7), (5, 10), (6, 7), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_701_i4 : Finset Cell := ⟨(([(3, 6), (3, 8), (3, 9), (3, 10), (3, 11), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 7), (7, 7), (8, 6), (8, 7), (8, 8), (9, 6), (9, 7), (9, 8), (10, 6), (10, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_701_i4 : Fin 2 → Finset Cell := ![(placed21 3 (4, 8) required_18), (placed21 2 (7, 6) required_348)] +def childrenD_701_i4 : Fin 2 → Finset Cell := ![(placed21 3 (4, 8) envelope_18), (placed21 2 (7, 6) envelope_348)] +theorem common_sub_701_i4 : commonEnvelope childrenD_701_i4 ⊆ insert (4, 8) required_701_i4 := by decide +kernel +theorem child_required_sub_701_i4 : ∀ j, childrenC_701_i4 j ⊆ insert (4, 8) required_701_i4 := by decide +kernel +theorem child_envelope_sub_701_i4 : ∀ j, childrenD_701_i4 j ⊆ envelope_701_i4 := by decide +kernel +theorem pivot_mem_701_i4 : (4, 8) ∈ envelope_701_i4 := by decide +kernel +theorem children_work_701_i4 : ∀ j, Template HasSnaky 6 (childrenC_701_i4 j) (childrenD_701_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_18 3 (4, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_348 2 (7, 6)).mono (by decide +kernel) +theorem row_works_701_i4 : Template HasSnaky 7 required_701_i4 envelope_701_i4 := by + refine compose HasSnaky 6 childrenC_701_i4 childrenD_701_i4 children_work_701_i4 (4, 8) + required_701_i4 envelope_701_i4 pivot_mem_701_i4 child_required_sub_701_i4 child_envelope_sub_701_i4 ?_ + intro b hb + exact common_sub_701_i4 (mem_commonEnvelope childrenD_701_i4 b hb) +def required_701_i6 : Finset Cell := ⟨(([(5, 7), (5, 8), (5, 10), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_701_i6 : Finset Cell := ⟨(([(4, 6), (4, 7), (4, 8), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 6), (6, 7), (6, 10), (6, 11), (6, 12)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_701_i6 : Fin 2 → Finset Cell := ![(placed21 3 (5, 10) required_5), (placed21 0 (4, 6) required_9)] +def childrenD_701_i6 : Fin 2 → Finset Cell := ![(placed21 3 (5, 10) envelope_5), (placed21 0 (4, 6) envelope_9)] +theorem common_sub_701_i6 : commonEnvelope childrenD_701_i6 ⊆ insert (5, 9) required_701_i6 := by decide +kernel +theorem child_required_sub_701_i6 : ∀ j, childrenC_701_i6 j ⊆ insert (5, 9) required_701_i6 := by decide +kernel +theorem child_envelope_sub_701_i6 : ∀ j, childrenD_701_i6 j ⊆ envelope_701_i6 := by decide +kernel +theorem pivot_mem_701_i6 : (5, 9) ∈ envelope_701_i6 := by decide +kernel +theorem children_work_701_i6 : ∀ j, Template HasSnaky 3 (childrenC_701_i6 j) (childrenD_701_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (5, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_9 0 (4, 6)).mono (by decide +kernel) +theorem row_works_701_i6 : Template HasSnaky 4 required_701_i6 envelope_701_i6 := by + refine compose HasSnaky 3 childrenC_701_i6 childrenD_701_i6 children_work_701_i6 (5, 9) + required_701_i6 envelope_701_i6 pivot_mem_701_i6 child_required_sub_701_i6 child_envelope_sub_701_i6 ?_ + intro b hb + exact common_sub_701_i6 (mem_commonEnvelope childrenD_701_i6 b hb) +def required_701_i7 : Finset Cell := ⟨(([(5, 7), (5, 8), (5, 10), (6, 7), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_701_i7 : Finset Cell := ⟨(([(4, 6), (4, 7), (4, 9), (5, 7), (5, 8), (5, 9), (5, 10), (6, 6), (6, 7), (6, 9), (6, 10), (6, 11), (7, 7), (7, 8), (7, 10), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 6), (9, 7), (9, 8), (9, 10), (9, 11), (10, 6), (10, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_701_i7 : Fin 2 → Finset Cell := ![(placed21 3 (5, 10) required_5), (placed21 0 (4, 6) required_372)] +def childrenD_701_i7 : Fin 2 → Finset Cell := ![(placed21 3 (5, 10) envelope_5), (placed21 0 (4, 6) envelope_372)] +theorem common_sub_701_i7 : commonEnvelope childrenD_701_i7 ⊆ insert (5, 9) required_701_i7 := by decide +kernel +theorem child_required_sub_701_i7 : ∀ j, childrenC_701_i7 j ⊆ insert (5, 9) required_701_i7 := by decide +kernel +theorem child_envelope_sub_701_i7 : ∀ j, childrenD_701_i7 j ⊆ envelope_701_i7 := by decide +kernel +theorem pivot_mem_701_i7 : (5, 9) ∈ envelope_701_i7 := by decide +kernel +theorem children_work_701_i7 : ∀ j, Template HasSnaky 7 (childrenC_701_i7 j) (childrenD_701_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_5 3 (5, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_372 0 (4, 6)).mono (by decide +kernel) +theorem row_works_701_i7 : Template HasSnaky 8 required_701_i7 envelope_701_i7 := by + refine compose HasSnaky 7 childrenC_701_i7 childrenD_701_i7 children_work_701_i7 (5, 9) + required_701_i7 envelope_701_i7 pivot_mem_701_i7 child_required_sub_701_i7 child_envelope_sub_701_i7 ?_ + intro b hb + exact common_sub_701_i7 (mem_commonEnvelope childrenD_701_i7 b hb) +def required_701_i5 : Finset Cell := ⟨(([(5, 7), (5, 10), (6, 7), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_701_i5 : Finset Cell := ⟨(([(4, 6), (4, 7), (4, 8), (4, 9), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 6), (6, 7), (6, 9), (6, 10), (6, 11), (6, 12), (7, 7), (7, 8), (7, 10), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (9, 6), (9, 7), (9, 8), (9, 10), (9, 11), (10, 6), (10, 8), (10, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_701_i5 : Fin 3 → Finset Cell := ![(placed21 3 (4, 8) required_10), required_701_i6, required_701_i7] +def childrenD_701_i5 : Fin 3 → Finset Cell := ![(placed21 3 (4, 8) envelope_10), envelope_701_i6, envelope_701_i7] +theorem common_sub_701_i5 : commonEnvelope childrenD_701_i5 ⊆ insert (5, 8) required_701_i5 := by decide +kernel +theorem child_required_sub_701_i5 : ∀ j, childrenC_701_i5 j ⊆ insert (5, 8) required_701_i5 := by decide +kernel +theorem child_envelope_sub_701_i5 : ∀ j, childrenD_701_i5 j ⊆ envelope_701_i5 := by decide +kernel +theorem pivot_mem_701_i5 : (5, 8) ∈ envelope_701_i5 := by decide +kernel +theorem children_work_701_i5 : ∀ j, Template HasSnaky 8 (childrenC_701_i5 j) (childrenD_701_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_10 3 (4, 8)).mono (by decide +kernel) + · exact row_works_701_i6.mono (by decide +kernel) + · exact row_works_701_i7.mono (by decide +kernel) +theorem row_works_701_i5 : Template HasSnaky 9 required_701_i5 envelope_701_i5 := by + refine compose HasSnaky 8 childrenC_701_i5 childrenD_701_i5 children_work_701_i5 (5, 8) + required_701_i5 envelope_701_i5 pivot_mem_701_i5 child_required_sub_701_i5 child_envelope_sub_701_i5 ?_ + intro b hb + exact common_sub_701_i5 (mem_commonEnvelope childrenD_701_i5 b hb) +def required_701_i0 : Finset Cell := ⟨(([(5, 7), (6, 7), (7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_701_i0 : Finset Cell := ⟨(([(0, 8), (0, 9), (0, 11), (0, 13), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (6, 6), (6, 7), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (10, 6), (10, 8), (10, 9), (10, 10), (10, 11), (10, 13), (11, 9), (11, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_701_i0 : Fin 7 → Finset Cell := ![required_701_i1, (placed21 5 (10, 6) required_683), required_701_i2, required_701_i3, required_701_i4, (placed21 1 (2, 6) required_700), required_701_i5] +def childrenD_701_i0 : Fin 7 → Finset Cell := ![envelope_701_i1, (placed21 5 (10, 6) envelope_683), envelope_701_i2, envelope_701_i3, envelope_701_i4, (placed21 1 (2, 6) envelope_700), envelope_701_i5] +theorem common_sub_701_i0 : commonEnvelope childrenD_701_i0 ⊆ insert (5, 10) required_701_i0 := by decide +kernel +theorem child_required_sub_701_i0 : ∀ j, childrenC_701_i0 j ⊆ insert (5, 10) required_701_i0 := by decide +kernel +theorem child_envelope_sub_701_i0 : ∀ j, childrenD_701_i0 j ⊆ envelope_701_i0 := by decide +kernel +theorem pivot_mem_701_i0 : (5, 10) ∈ envelope_701_i0 := by decide +kernel +theorem children_work_701_i0 : ∀ j, Template HasSnaky 16 (childrenC_701_i0 j) (childrenD_701_i0 j) := by + intro j + fin_cases j + · exact row_works_701_i1.mono (by decide +kernel) + · exact (placed21_template row_works_683 5 (10, 6)).mono (by decide +kernel) + · exact row_works_701_i2.mono (by decide +kernel) + · exact row_works_701_i3.mono (by decide +kernel) + · exact row_works_701_i4.mono (by decide +kernel) + · exact (placed21_template row_works_700 1 (2, 6)).mono (by decide +kernel) + · exact row_works_701_i5.mono (by decide +kernel) +theorem row_works_701_i0 : Template HasSnaky 17 required_701_i0 envelope_701_i0 := by + refine compose HasSnaky 16 childrenC_701_i0 childrenD_701_i0 children_work_701_i0 (5, 10) + required_701_i0 envelope_701_i0 pivot_mem_701_i0 child_required_sub_701_i0 child_envelope_sub_701_i0 ?_ + intro b hb + exact common_sub_701_i0 (mem_commonEnvelope childrenD_701_i0 b hb) +def required_701 : Finset Cell := ⟨(([(5, 7), (6, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_701 : Finset Cell := ⟨(([(0, 3), (0, 5), (0, 8), (0, 9), (0, 11), (0, 13), (1, 3), (1, 4), (1, 5), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 11), (12, 4), (12, 6), (12, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_701 : Fin 6 → Finset Cell := ![(placed21 3 (3, 8) required_12), (placed21 2 (8, 3) required_322), (placed21 0 (4, 4) required_435), (placed21 6 (9, 10) required_697), (placed21 0 (1, 2) required_699), required_701_i0] +def childrenD_701 : Fin 6 → Finset Cell := ![(placed21 3 (3, 8) envelope_12), (placed21 2 (8, 3) envelope_322), (placed21 0 (4, 4) envelope_435), (placed21 6 (9, 10) envelope_697), (placed21 0 (1, 2) envelope_699), envelope_701_i0] +theorem common_sub_701 : commonEnvelope childrenD_701 ⊆ insert (7, 7) required_701 := by decide +kernel +theorem child_required_sub_701 : ∀ j, childrenC_701 j ⊆ insert (7, 7) required_701 := by decide +kernel +theorem child_envelope_sub_701 : ∀ j, childrenD_701 j ⊆ envelope_701 := by decide +kernel +theorem pivot_mem_701 : (7, 7) ∈ envelope_701 := by decide +kernel +theorem children_work_701 : ∀ j, Template HasSnaky 17 (childrenC_701 j) (childrenD_701 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 3 (3, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_322 2 (8, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_435 0 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_697 6 (9, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_699 0 (1, 2)).mono (by decide +kernel) + · exact row_works_701_i0.mono (by decide +kernel) +theorem row_works_701 : Template HasSnaky 18 required_701 envelope_701 := by + refine compose HasSnaky 17 childrenC_701 childrenD_701 children_work_701 (7, 7) + required_701 envelope_701 pivot_mem_701 child_required_sub_701 child_envelope_sub_701 ?_ + intro b hb + exact common_sub_701 (mem_commonEnvelope childrenD_701 b hb) +def height_701_i1 : ℕ := 5 +def childrenH_701_i1 : Fin 2 → ℕ := ![height_10, height_39] +theorem height_exact_701_i1 : height_701_i1 = 1 + Finset.univ.sup childrenH_701_i1 := by decide +kernel +theorem required_origin_701_i1 : ∀ x ∈ required_701_i1, + (∃ j, x ∈ childrenC_701_i1 j) ∨ ∀ j, x ∈ childrenD_701_i1 j := by decide +kernel +theorem required_exact_701_i1 : required_701_i1 = + ((Finset.univ.biUnion childrenC_701_i1) ∪ commonEnvelope childrenD_701_i1).erase (5, 8) := by + exact required_eq_combination childrenC_701_i1 childrenD_701_i1 (5, 8) required_701_i1 + (by decide +kernel) child_required_sub_701_i1 common_sub_701_i1 required_origin_701_i1 +theorem envelope_origin_701_i1 : ∀ x ∈ envelope_701_i1, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_701_i1 j := by decide +kernel +theorem envelope_exact_701_i1 : envelope_701_i1 = + insert (5, 8) (Finset.univ.biUnion childrenD_701_i1) := by + exact envelope_eq_combination childrenD_701_i1 (5, 8) envelope_701_i1 + pivot_mem_701_i1 child_envelope_sub_701_i1 envelope_origin_701_i1 +def checked_701_i1 : CheckedCard where + required := required_701_i1 + envelope := envelope_701_i1 + height := height_701_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_701_i1 +def height_701_i2 : ℕ := 10 +def childrenH_701_i2 : Fin 2 → ℕ := ![height_52, height_325] +theorem height_exact_701_i2 : height_701_i2 = 1 + Finset.univ.sup childrenH_701_i2 := by decide +kernel +theorem required_origin_701_i2 : ∀ x ∈ required_701_i2, + (∃ j, x ∈ childrenC_701_i2 j) ∨ ∀ j, x ∈ childrenD_701_i2 j := by decide +kernel +theorem required_exact_701_i2 : required_701_i2 = + ((Finset.univ.biUnion childrenC_701_i2) ∪ commonEnvelope childrenD_701_i2).erase (5, 8) := by + exact required_eq_combination childrenC_701_i2 childrenD_701_i2 (5, 8) required_701_i2 + (by decide +kernel) child_required_sub_701_i2 common_sub_701_i2 required_origin_701_i2 +theorem envelope_origin_701_i2 : ∀ x ∈ envelope_701_i2, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_701_i2 j := by decide +kernel +theorem envelope_exact_701_i2 : envelope_701_i2 = + insert (5, 8) (Finset.univ.biUnion childrenD_701_i2) := by + exact envelope_eq_combination childrenD_701_i2 (5, 8) envelope_701_i2 + pivot_mem_701_i2 child_envelope_sub_701_i2 envelope_origin_701_i2 +def checked_701_i2 : CheckedCard where + required := required_701_i2 + envelope := envelope_701_i2 + height := height_701_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_701_i2 +def height_701_i3 : ℕ := 12 +def childrenH_701_i3 : Fin 2 → ℕ := ![height_8, height_463] +theorem height_exact_701_i3 : height_701_i3 = 1 + Finset.univ.sup childrenH_701_i3 := by decide +kernel +theorem required_origin_701_i3 : ∀ x ∈ required_701_i3, + (∃ j, x ∈ childrenC_701_i3 j) ∨ ∀ j, x ∈ childrenD_701_i3 j := by decide +kernel +theorem required_exact_701_i3 : required_701_i3 = + ((Finset.univ.biUnion childrenC_701_i3) ∪ commonEnvelope childrenD_701_i3).erase (4, 7) := by + exact required_eq_combination childrenC_701_i3 childrenD_701_i3 (4, 7) required_701_i3 + (by decide +kernel) child_required_sub_701_i3 common_sub_701_i3 required_origin_701_i3 +theorem envelope_origin_701_i3 : ∀ x ∈ envelope_701_i3, + x = (4, 7) ∨ ∃ j, x ∈ childrenD_701_i3 j := by decide +kernel +theorem envelope_exact_701_i3 : envelope_701_i3 = + insert (4, 7) (Finset.univ.biUnion childrenD_701_i3) := by + exact envelope_eq_combination childrenD_701_i3 (4, 7) envelope_701_i3 + pivot_mem_701_i3 child_envelope_sub_701_i3 envelope_origin_701_i3 +def checked_701_i3 : CheckedCard where + required := required_701_i3 + envelope := envelope_701_i3 + height := height_701_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_701_i3 +def height_701_i4 : ℕ := 7 +def childrenH_701_i4 : Fin 2 → ℕ := ![height_18, height_348] +theorem height_exact_701_i4 : height_701_i4 = 1 + Finset.univ.sup childrenH_701_i4 := by decide +kernel +theorem required_origin_701_i4 : ∀ x ∈ required_701_i4, + (∃ j, x ∈ childrenC_701_i4 j) ∨ ∀ j, x ∈ childrenD_701_i4 j := by decide +kernel +theorem required_exact_701_i4 : required_701_i4 = + ((Finset.univ.biUnion childrenC_701_i4) ∪ commonEnvelope childrenD_701_i4).erase (4, 8) := by + exact required_eq_combination childrenC_701_i4 childrenD_701_i4 (4, 8) required_701_i4 + (by decide +kernel) child_required_sub_701_i4 common_sub_701_i4 required_origin_701_i4 +theorem envelope_origin_701_i4 : ∀ x ∈ envelope_701_i4, + x = (4, 8) ∨ ∃ j, x ∈ childrenD_701_i4 j := by decide +kernel +theorem envelope_exact_701_i4 : envelope_701_i4 = + insert (4, 8) (Finset.univ.biUnion childrenD_701_i4) := by + exact envelope_eq_combination childrenD_701_i4 (4, 8) envelope_701_i4 + pivot_mem_701_i4 child_envelope_sub_701_i4 envelope_origin_701_i4 +def checked_701_i4 : CheckedCard where + required := required_701_i4 + envelope := envelope_701_i4 + height := height_701_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_701_i4 +def height_701_i6 : ℕ := 4 +def childrenH_701_i6 : Fin 2 → ℕ := ![height_5, height_9] +theorem height_exact_701_i6 : height_701_i6 = 1 + Finset.univ.sup childrenH_701_i6 := by decide +kernel +theorem required_origin_701_i6 : ∀ x ∈ required_701_i6, + (∃ j, x ∈ childrenC_701_i6 j) ∨ ∀ j, x ∈ childrenD_701_i6 j := by decide +kernel +theorem required_exact_701_i6 : required_701_i6 = + ((Finset.univ.biUnion childrenC_701_i6) ∪ commonEnvelope childrenD_701_i6).erase (5, 9) := by + exact required_eq_combination childrenC_701_i6 childrenD_701_i6 (5, 9) required_701_i6 + (by decide +kernel) child_required_sub_701_i6 common_sub_701_i6 required_origin_701_i6 +theorem envelope_origin_701_i6 : ∀ x ∈ envelope_701_i6, + x = (5, 9) ∨ ∃ j, x ∈ childrenD_701_i6 j := by decide +kernel +theorem envelope_exact_701_i6 : envelope_701_i6 = + insert (5, 9) (Finset.univ.biUnion childrenD_701_i6) := by + exact envelope_eq_combination childrenD_701_i6 (5, 9) envelope_701_i6 + pivot_mem_701_i6 child_envelope_sub_701_i6 envelope_origin_701_i6 +def checked_701_i6 : CheckedCard where + required := required_701_i6 + envelope := envelope_701_i6 + height := height_701_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_701_i6 +def height_701_i7 : ℕ := 8 +def childrenH_701_i7 : Fin 2 → ℕ := ![height_5, height_372] +theorem height_exact_701_i7 : height_701_i7 = 1 + Finset.univ.sup childrenH_701_i7 := by decide +kernel +theorem required_origin_701_i7 : ∀ x ∈ required_701_i7, + (∃ j, x ∈ childrenC_701_i7 j) ∨ ∀ j, x ∈ childrenD_701_i7 j := by decide +kernel +theorem required_exact_701_i7 : required_701_i7 = + ((Finset.univ.biUnion childrenC_701_i7) ∪ commonEnvelope childrenD_701_i7).erase (5, 9) := by + exact required_eq_combination childrenC_701_i7 childrenD_701_i7 (5, 9) required_701_i7 + (by decide +kernel) child_required_sub_701_i7 common_sub_701_i7 required_origin_701_i7 +theorem envelope_origin_701_i7 : ∀ x ∈ envelope_701_i7, + x = (5, 9) ∨ ∃ j, x ∈ childrenD_701_i7 j := by decide +kernel +theorem envelope_exact_701_i7 : envelope_701_i7 = + insert (5, 9) (Finset.univ.biUnion childrenD_701_i7) := by + exact envelope_eq_combination childrenD_701_i7 (5, 9) envelope_701_i7 + pivot_mem_701_i7 child_envelope_sub_701_i7 envelope_origin_701_i7 +def checked_701_i7 : CheckedCard where + required := required_701_i7 + envelope := envelope_701_i7 + height := height_701_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_701_i7 +def height_701_i5 : ℕ := 9 +def childrenH_701_i5 : Fin 3 → ℕ := ![height_10, height_701_i6, height_701_i7] +theorem height_exact_701_i5 : height_701_i5 = 1 + Finset.univ.sup childrenH_701_i5 := by decide +kernel +theorem required_origin_701_i5 : ∀ x ∈ required_701_i5, + (∃ j, x ∈ childrenC_701_i5 j) ∨ ∀ j, x ∈ childrenD_701_i5 j := by decide +kernel +theorem required_exact_701_i5 : required_701_i5 = + ((Finset.univ.biUnion childrenC_701_i5) ∪ commonEnvelope childrenD_701_i5).erase (5, 8) := by + exact required_eq_combination childrenC_701_i5 childrenD_701_i5 (5, 8) required_701_i5 + (by decide +kernel) child_required_sub_701_i5 common_sub_701_i5 required_origin_701_i5 +theorem envelope_origin_701_i5 : ∀ x ∈ envelope_701_i5, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_701_i5 j := by decide +kernel +theorem envelope_exact_701_i5 : envelope_701_i5 = + insert (5, 8) (Finset.univ.biUnion childrenD_701_i5) := by + exact envelope_eq_combination childrenD_701_i5 (5, 8) envelope_701_i5 + pivot_mem_701_i5 child_envelope_sub_701_i5 envelope_origin_701_i5 +def checked_701_i5 : CheckedCard where + required := required_701_i5 + envelope := envelope_701_i5 + height := height_701_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_701_i5 +def height_701_i0 : ℕ := 17 +def childrenH_701_i0 : Fin 7 → ℕ := ![height_701_i1, height_683, height_701_i2, height_701_i3, height_701_i4, height_700, height_701_i5] +theorem height_exact_701_i0 : height_701_i0 = 1 + Finset.univ.sup childrenH_701_i0 := by decide +kernel +theorem required_origin_701_i0 : ∀ x ∈ required_701_i0, + (∃ j, x ∈ childrenC_701_i0 j) ∨ ∀ j, x ∈ childrenD_701_i0 j := by decide +kernel +theorem required_exact_701_i0 : required_701_i0 = + ((Finset.univ.biUnion childrenC_701_i0) ∪ commonEnvelope childrenD_701_i0).erase (5, 10) := by + exact required_eq_combination childrenC_701_i0 childrenD_701_i0 (5, 10) required_701_i0 + (by decide +kernel) child_required_sub_701_i0 common_sub_701_i0 required_origin_701_i0 +theorem envelope_origin_701_i0 : ∀ x ∈ envelope_701_i0, + x = (5, 10) ∨ ∃ j, x ∈ childrenD_701_i0 j := by decide +kernel +theorem envelope_exact_701_i0 : envelope_701_i0 = + insert (5, 10) (Finset.univ.biUnion childrenD_701_i0) := by + exact envelope_eq_combination childrenD_701_i0 (5, 10) envelope_701_i0 + pivot_mem_701_i0 child_envelope_sub_701_i0 envelope_origin_701_i0 +def checked_701_i0 : CheckedCard where + required := required_701_i0 + envelope := envelope_701_i0 + height := height_701_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_701_i0 +def height_701 : ℕ := 18 +def childrenH_701 : Fin 6 → ℕ := ![height_12, height_322, height_435, height_697, height_699, height_701_i0] +theorem height_exact_701 : height_701 = 1 + Finset.univ.sup childrenH_701 := by decide +kernel +theorem required_origin_701 : ∀ x ∈ required_701, + (∃ j, x ∈ childrenC_701 j) ∨ ∀ j, x ∈ childrenD_701 j := by decide +kernel +theorem required_exact_701 : required_701 = + ((Finset.univ.biUnion childrenC_701) ∪ commonEnvelope childrenD_701).erase (7, 7) := by + exact required_eq_combination childrenC_701 childrenD_701 (7, 7) required_701 + (by decide +kernel) child_required_sub_701 common_sub_701 required_origin_701 +theorem envelope_origin_701 : ∀ x ∈ envelope_701, + x = (7, 7) ∨ ∃ j, x ∈ childrenD_701 j := by decide +kernel +theorem envelope_exact_701 : envelope_701 = + insert (7, 7) (Finset.univ.biUnion childrenD_701) := by + exact envelope_eq_combination childrenD_701 (7, 7) envelope_701 + pivot_mem_701 child_envelope_sub_701 envelope_origin_701 +def checked_701 : CheckedCard where + required := required_701 + envelope := envelope_701 + height := height_701 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_701 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height19Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height19Part01.lean new file mode 100644 index 0000000..36b8840 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height19Part01.lean @@ -0,0 +1,156 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height18Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_694_i0 : Finset Cell := ⟨(([(5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_694_i0 : Finset Cell := ⟨(([(0, 5), (0, 7), (1, 5), (1, 6), (1, 7), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (7, 5), (7, 6), (7, 7), (8, 5), (8, 6), (8, 7), (9, 5), (9, 6), (9, 7), (10, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_694_i0 : Fin 5 → Finset Cell := ![(placed21 4 (4, 11) required_390), (placed21 2 (7, 3) required_544), (placed21 1 (0, 5) required_545), (placed21 5 (9, 5) required_546), (placed21 1 (0, 5) required_549)] +def childrenD_694_i0 : Fin 5 → Finset Cell := ![(placed21 4 (4, 11) envelope_390), (placed21 2 (7, 3) envelope_544), (placed21 1 (0, 5) envelope_545), (placed21 5 (9, 5) envelope_546), (placed21 1 (0, 5) envelope_549)] +theorem common_sub_694_i0 : commonEnvelope childrenD_694_i0 ⊆ insert (4, 6) required_694_i0 := by decide +kernel +theorem child_required_sub_694_i0 : ∀ j, childrenC_694_i0 j ⊆ insert (4, 6) required_694_i0 := by decide +kernel +theorem child_envelope_sub_694_i0 : ∀ j, childrenD_694_i0 j ⊆ envelope_694_i0 := by decide +kernel +theorem pivot_mem_694_i0 : (4, 6) ∈ envelope_694_i0 := by decide +kernel +theorem children_work_694_i0 : ∀ j, Template HasSnaky 10 (childrenC_694_i0 j) (childrenD_694_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_390 4 (4, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_544 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_545 1 (0, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_546 5 (9, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_549 1 (0, 5)).mono (by decide +kernel) +theorem row_works_694_i0 : Template HasSnaky 11 required_694_i0 envelope_694_i0 := by + refine compose HasSnaky 10 childrenC_694_i0 childrenD_694_i0 children_work_694_i0 (4, 6) + required_694_i0 envelope_694_i0 pivot_mem_694_i0 child_required_sub_694_i0 child_envelope_sub_694_i0 ?_ + intro b hb + exact common_sub_694_i0 (mem_commonEnvelope childrenD_694_i0 b hb) +def required_694_i1 : Finset Cell := ⟨(([(5, 5), (5, 6), (5, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_694_i1 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 7), (1, 5), (1, 6), (1, 7), (1, 8), (2, 5), (2, 6), (2, 7), (2, 8), (3, 5), (3, 6), (3, 7), (3, 8), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 9), (4, 10), (4, 11), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (12, 1), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (13, 4), (13, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_694_i1 : Fin 4 → Finset Cell := ![(placed21 4 (5, 8) required_7), (placed21 3 (4, 7) required_26), (placed21 7 (8, 8) required_142), (placed21 3 (0, 11) required_693)] +def childrenD_694_i1 : Fin 4 → Finset Cell := ![(placed21 4 (5, 8) envelope_7), (placed21 3 (4, 7) envelope_26), (placed21 7 (8, 8) envelope_142), (placed21 3 (0, 11) envelope_693)] +theorem common_sub_694_i1 : commonEnvelope childrenD_694_i1 ⊆ insert (5, 4) required_694_i1 := by decide +kernel +theorem child_required_sub_694_i1 : ∀ j, childrenC_694_i1 j ⊆ insert (5, 4) required_694_i1 := by decide +kernel +theorem child_envelope_sub_694_i1 : ∀ j, childrenD_694_i1 j ⊆ envelope_694_i1 := by decide +kernel +theorem pivot_mem_694_i1 : (5, 4) ∈ envelope_694_i1 := by decide +kernel +theorem children_work_694_i1 : ∀ j, Template HasSnaky 14 (childrenC_694_i1 j) (childrenD_694_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 4 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_26 3 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_142 7 (8, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_693 3 (0, 11)).mono (by decide +kernel) +theorem row_works_694_i1 : Template HasSnaky 15 required_694_i1 envelope_694_i1 := by + refine compose HasSnaky 14 childrenC_694_i1 childrenD_694_i1 children_work_694_i1 (5, 4) + required_694_i1 envelope_694_i1 pivot_mem_694_i1 child_required_sub_694_i1 child_envelope_sub_694_i1 ?_ + intro b hb + exact common_sub_694_i1 (mem_commonEnvelope childrenD_694_i1 b hb) +def required_694 : Finset Cell := ⟨(([(5, 5), (5, 6)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_694 : Finset Cell := ⟨(([(0, 5), (0, 6), (0, 7), (1, 5), (1, 6), (1, 7), (1, 8), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (4, 1), (4, 2), (4, 3), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 2), (6, 3), (6, 4), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (12, 1), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (13, 4), (13, 5), (13, 6), (13, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_694 : Fin 7 → Finset Cell := ![(placed21 3 (2, 8) required_116), (placed21 2 (7, 3) required_188), (placed21 1 (2, 5) required_397), (placed21 5 (8, 4) required_435), (placed21 0 (2, 2) required_691), required_694_i0, required_694_i1] +def childrenD_694 : Fin 7 → Finset Cell := ![(placed21 3 (2, 8) envelope_116), (placed21 2 (7, 3) envelope_188), (placed21 1 (2, 5) envelope_397), (placed21 5 (8, 4) envelope_435), (placed21 0 (2, 2) envelope_691), envelope_694_i0, envelope_694_i1] +theorem common_sub_694 : commonEnvelope childrenD_694 ⊆ insert (5, 7) required_694 := by decide +kernel +theorem child_required_sub_694 : ∀ j, childrenC_694 j ⊆ insert (5, 7) required_694 := by decide +kernel +theorem child_envelope_sub_694 : ∀ j, childrenD_694 j ⊆ envelope_694 := by decide +kernel +theorem pivot_mem_694 : (5, 7) ∈ envelope_694 := by decide +kernel +theorem children_work_694 : ∀ j, Template HasSnaky 18 (childrenC_694 j) (childrenD_694 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_116 3 (2, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_188 2 (7, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_397 1 (2, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_435 5 (8, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_691 0 (2, 2)).mono (by decide +kernel) + · exact row_works_694_i0.mono (by decide +kernel) + · exact row_works_694_i1.mono (by decide +kernel) +theorem row_works_694 : Template HasSnaky 19 required_694 envelope_694 := by + refine compose HasSnaky 18 childrenC_694 childrenD_694 children_work_694 (5, 7) + required_694 envelope_694 pivot_mem_694 child_required_sub_694 child_envelope_sub_694 ?_ + intro b hb + exact common_sub_694 (mem_commonEnvelope childrenD_694 b hb) +def height_694_i0 : ℕ := 11 +def childrenH_694_i0 : Fin 5 → ℕ := ![height_390, height_544, height_545, height_546, height_549] +theorem height_exact_694_i0 : height_694_i0 = 1 + Finset.univ.sup childrenH_694_i0 := by decide +kernel +theorem required_origin_694_i0 : ∀ x ∈ required_694_i0, + (∃ j, x ∈ childrenC_694_i0 j) ∨ ∀ j, x ∈ childrenD_694_i0 j := by decide +kernel +theorem required_exact_694_i0 : required_694_i0 = + ((Finset.univ.biUnion childrenC_694_i0) ∪ commonEnvelope childrenD_694_i0).erase (4, 6) := by + exact required_eq_combination childrenC_694_i0 childrenD_694_i0 (4, 6) required_694_i0 + (by decide +kernel) child_required_sub_694_i0 common_sub_694_i0 required_origin_694_i0 +theorem envelope_origin_694_i0 : ∀ x ∈ envelope_694_i0, + x = (4, 6) ∨ ∃ j, x ∈ childrenD_694_i0 j := by decide +kernel +theorem envelope_exact_694_i0 : envelope_694_i0 = + insert (4, 6) (Finset.univ.biUnion childrenD_694_i0) := by + exact envelope_eq_combination childrenD_694_i0 (4, 6) envelope_694_i0 + pivot_mem_694_i0 child_envelope_sub_694_i0 envelope_origin_694_i0 +def checked_694_i0 : CheckedCard where + required := required_694_i0 + envelope := envelope_694_i0 + height := height_694_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_694_i0 +def height_694_i1 : ℕ := 15 +def childrenH_694_i1 : Fin 4 → ℕ := ![height_7, height_26, height_142, height_693] +theorem height_exact_694_i1 : height_694_i1 = 1 + Finset.univ.sup childrenH_694_i1 := by decide +kernel +theorem required_origin_694_i1 : ∀ x ∈ required_694_i1, + (∃ j, x ∈ childrenC_694_i1 j) ∨ ∀ j, x ∈ childrenD_694_i1 j := by decide +kernel +theorem required_exact_694_i1 : required_694_i1 = + ((Finset.univ.biUnion childrenC_694_i1) ∪ commonEnvelope childrenD_694_i1).erase (5, 4) := by + exact required_eq_combination childrenC_694_i1 childrenD_694_i1 (5, 4) required_694_i1 + (by decide +kernel) child_required_sub_694_i1 common_sub_694_i1 required_origin_694_i1 +theorem envelope_origin_694_i1 : ∀ x ∈ envelope_694_i1, + x = (5, 4) ∨ ∃ j, x ∈ childrenD_694_i1 j := by decide +kernel +theorem envelope_exact_694_i1 : envelope_694_i1 = + insert (5, 4) (Finset.univ.biUnion childrenD_694_i1) := by + exact envelope_eq_combination childrenD_694_i1 (5, 4) envelope_694_i1 + pivot_mem_694_i1 child_envelope_sub_694_i1 envelope_origin_694_i1 +def checked_694_i1 : CheckedCard where + required := required_694_i1 + envelope := envelope_694_i1 + height := height_694_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_694_i1 +def height_694 : ℕ := 19 +def childrenH_694 : Fin 7 → ℕ := ![height_116, height_188, height_397, height_435, height_691, height_694_i0, height_694_i1] +theorem height_exact_694 : height_694 = 1 + Finset.univ.sup childrenH_694 := by decide +kernel +theorem required_origin_694 : ∀ x ∈ required_694, + (∃ j, x ∈ childrenC_694 j) ∨ ∀ j, x ∈ childrenD_694 j := by decide +kernel +theorem required_exact_694 : required_694 = + ((Finset.univ.biUnion childrenC_694) ∪ commonEnvelope childrenD_694).erase (5, 7) := by + exact required_eq_combination childrenC_694 childrenD_694 (5, 7) required_694 + (by decide +kernel) child_required_sub_694 common_sub_694 required_origin_694 +theorem envelope_origin_694 : ∀ x ∈ envelope_694, + x = (5, 7) ∨ ∃ j, x ∈ childrenD_694 j := by decide +kernel +theorem envelope_exact_694 : envelope_694 = + insert (5, 7) (Finset.univ.biUnion childrenD_694) := by + exact envelope_eq_combination childrenD_694 (5, 7) envelope_694 + pivot_mem_694 child_envelope_sub_694 envelope_origin_694 +def checked_694 : CheckedCard where + required := required_694 + envelope := envelope_694 + height := height_694 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_694 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height20Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height20Part01.lean new file mode 100644 index 0000000..c019963 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height20Part01.lean @@ -0,0 +1,556 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height17Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height18Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height18Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height19Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_708_i2 : Finset Cell := ⟨(([(6, 8), (7, 7), (7, 8), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_708_i2 : Finset Cell := ⟨(([(2, 7), (3, 7), (3, 8), (3, 9), (4, 7), (4, 8), (4, 9), (5, 8), (5, 9), (6, 7), (6, 8), (6, 9), (7, 7), (7, 8), (7, 9), (8, 8), (8, 9), (9, 7), (9, 8), (9, 9), (10, 7), (10, 8), (11, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_708_i2 : Fin 3 → Finset Cell := ![(placed21 5 (9, 8) required_7), (placed21 1 (4, 7) required_234), (placed21 5 (9, 7) required_241)] +def childrenD_708_i2 : Fin 3 → Finset Cell := ![(placed21 5 (9, 8) envelope_7), (placed21 1 (4, 7) envelope_234), (placed21 5 (9, 7) envelope_241)] +theorem common_sub_708_i2 : commonEnvelope childrenD_708_i2 ⊆ insert (5, 8) required_708_i2 := by decide +kernel +theorem child_required_sub_708_i2 : ∀ j, childrenC_708_i2 j ⊆ insert (5, 8) required_708_i2 := by decide +kernel +theorem child_envelope_sub_708_i2 : ∀ j, childrenD_708_i2 j ⊆ envelope_708_i2 := by decide +kernel +theorem pivot_mem_708_i2 : (5, 8) ∈ envelope_708_i2 := by decide +kernel +theorem children_work_708_i2 : ∀ j, Template HasSnaky 5 (childrenC_708_i2 j) (childrenD_708_i2 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 5 (9, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_234 1 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_241 5 (9, 7)).mono (by decide +kernel) +theorem row_works_708_i2 : Template HasSnaky 6 required_708_i2 envelope_708_i2 := by + refine compose HasSnaky 5 childrenC_708_i2 childrenD_708_i2 children_work_708_i2 (5, 8) + required_708_i2 envelope_708_i2 pivot_mem_708_i2 child_required_sub_708_i2 child_envelope_sub_708_i2 ?_ + intro b hb + exact common_sub_708_i2 (mem_commonEnvelope childrenD_708_i2 b hb) +def required_708_i4 : Finset Cell := ⟨(([(6, 8), (7, 6), (7, 7), (7, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_708_i4 : Finset Cell := ⟨(([(4, 8), (5, 8), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 9), (8, 10), (8, 11), (9, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_708_i4 : Fin 3 → Finset Cell := ![(placed21 2 (7, 5) required_7), (placed21 0 (6, 5) required_9), (placed21 5 (9, 6) required_92)] +def childrenD_708_i4 : Fin 3 → Finset Cell := ![(placed21 2 (7, 5) envelope_7), (placed21 0 (6, 5) envelope_9), (placed21 5 (9, 6) envelope_92)] +theorem common_sub_708_i4 : commonEnvelope childrenD_708_i4 ⊆ insert (7, 9) required_708_i4 := by decide +kernel +theorem child_required_sub_708_i4 : ∀ j, childrenC_708_i4 j ⊆ insert (7, 9) required_708_i4 := by decide +kernel +theorem child_envelope_sub_708_i4 : ∀ j, childrenD_708_i4 j ⊆ envelope_708_i4 := by decide +kernel +theorem pivot_mem_708_i4 : (7, 9) ∈ envelope_708_i4 := by decide +kernel +theorem children_work_708_i4 : ∀ j, Template HasSnaky 4 (childrenC_708_i4 j) (childrenD_708_i4 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 2 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_9 0 (6, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_92 5 (9, 6)).mono (by decide +kernel) +theorem row_works_708_i4 : Template HasSnaky 5 required_708_i4 envelope_708_i4 := by + refine compose HasSnaky 4 childrenC_708_i4 childrenD_708_i4 children_work_708_i4 (7, 9) + required_708_i4 envelope_708_i4 pivot_mem_708_i4 child_required_sub_708_i4 child_envelope_sub_708_i4 ?_ + intro b hb + exact common_sub_708_i4 (mem_commonEnvelope childrenD_708_i4 b hb) +def required_708_i3 : Finset Cell := ⟨(([(6, 8), (7, 7), (7, 8), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_708_i3 : Finset Cell := ⟨(([(4, 8), (5, 8), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 8), (8, 9), (8, 10), (8, 11), (9, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_708_i3 : Fin 3 → Finset Cell := ![(placed21 2 (7, 5) required_44), (placed21 0 (7, 5) required_52), required_708_i4] +def childrenD_708_i3 : Fin 3 → Finset Cell := ![(placed21 2 (7, 5) envelope_44), (placed21 0 (7, 5) envelope_52), envelope_708_i4] +theorem common_sub_708_i3 : commonEnvelope childrenD_708_i3 ⊆ insert (7, 6) required_708_i3 := by decide +kernel +theorem child_required_sub_708_i3 : ∀ j, childrenC_708_i3 j ⊆ insert (7, 6) required_708_i3 := by decide +kernel +theorem child_envelope_sub_708_i3 : ∀ j, childrenD_708_i3 j ⊆ envelope_708_i3 := by decide +kernel +theorem pivot_mem_708_i3 : (7, 6) ∈ envelope_708_i3 := by decide +kernel +theorem children_work_708_i3 : ∀ j, Template HasSnaky 5 (childrenC_708_i3 j) (childrenD_708_i3 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_44 2 (7, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_52 0 (7, 5)).mono (by decide +kernel) + · exact row_works_708_i4.mono (by decide +kernel) +theorem row_works_708_i3 : Template HasSnaky 6 required_708_i3 envelope_708_i3 := by + refine compose HasSnaky 5 childrenC_708_i3 childrenD_708_i3 children_work_708_i3 (7, 6) + required_708_i3 envelope_708_i3 pivot_mem_708_i3 child_required_sub_708_i3 child_envelope_sub_708_i3 ?_ + intro b hb + exact common_sub_708_i3 (mem_commonEnvelope childrenD_708_i3 b hb) +def required_708_i1 : Finset Cell := ⟨(([(6, 8), (7, 8), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_708_i1 : Finset Cell := ⟨(([(2, 7), (3, 7), (3, 8), (3, 9), (4, 7), (4, 8), (4, 9), (5, 8), (5, 9), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (8, 8), (8, 9), (8, 10), (8, 11), (9, 7), (9, 8), (9, 9), (10, 7), (10, 8), (11, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_708_i1 : Fin 6 → Finset Cell := ![(placed21 2 (9, 5) required_57), (placed21 2 (9, 5) required_88), (placed21 2 (9, 5) required_111), (placed21 0 (5, 5) required_213), required_708_i2, required_708_i3] +def childrenD_708_i1 : Fin 6 → Finset Cell := ![(placed21 2 (9, 5) envelope_57), (placed21 2 (9, 5) envelope_88), (placed21 2 (9, 5) envelope_111), (placed21 0 (5, 5) envelope_213), envelope_708_i2, envelope_708_i3] +theorem common_sub_708_i1 : commonEnvelope childrenD_708_i1 ⊆ insert (7, 7) required_708_i1 := by decide +kernel +theorem child_required_sub_708_i1 : ∀ j, childrenC_708_i1 j ⊆ insert (7, 7) required_708_i1 := by decide +kernel +theorem child_envelope_sub_708_i1 : ∀ j, childrenD_708_i1 j ⊆ envelope_708_i1 := by decide +kernel +theorem pivot_mem_708_i1 : (7, 7) ∈ envelope_708_i1 := by decide +kernel +theorem children_work_708_i1 : ∀ j, Template HasSnaky 6 (childrenC_708_i1 j) (childrenD_708_i1 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_57 2 (9, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_88 2 (9, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_111 2 (9, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_213 0 (5, 5)).mono (by decide +kernel) + · exact row_works_708_i2.mono (by decide +kernel) + · exact row_works_708_i3.mono (by decide +kernel) +theorem row_works_708_i1 : Template HasSnaky 7 required_708_i1 envelope_708_i1 := by + refine compose HasSnaky 6 childrenC_708_i1 childrenD_708_i1 children_work_708_i1 (7, 7) + required_708_i1 envelope_708_i1 pivot_mem_708_i1 child_required_sub_708_i1 child_envelope_sub_708_i1 ?_ + intro b hb + exact common_sub_708_i1 (mem_commonEnvelope childrenD_708_i1 b hb) +def required_708_i5 : Finset Cell := ⟨(([(6, 8), (7, 8), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_708_i5 : Finset Cell := ⟨(([(2, 7), (2, 9), (3, 7), (3, 8), (3, 9), (4, 7), (4, 8), (4, 9), (5, 7), (5, 8), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (8, 8), (8, 9), (9, 7), (9, 8), (9, 9), (10, 7), (10, 8), (11, 7), (11, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_708_i5 : Fin 3 → Finset Cell := ![(placed21 3 (5, 8) required_7), (placed21 5 (11, 7) required_186), (placed21 6 (9, 11) required_292)] +def childrenD_708_i5 : Fin 3 → Finset Cell := ![(placed21 3 (5, 8) envelope_7), (placed21 5 (11, 7) envelope_186), (placed21 6 (9, 11) envelope_292)] +theorem common_sub_708_i5 : commonEnvelope childrenD_708_i5 ⊆ insert (9, 8) required_708_i5 := by decide +kernel +theorem child_required_sub_708_i5 : ∀ j, childrenC_708_i5 j ⊆ insert (9, 8) required_708_i5 := by decide +kernel +theorem child_envelope_sub_708_i5 : ∀ j, childrenD_708_i5 j ⊆ envelope_708_i5 := by decide +kernel +theorem pivot_mem_708_i5 : (9, 8) ∈ envelope_708_i5 := by decide +kernel +theorem children_work_708_i5 : ∀ j, Template HasSnaky 6 (childrenC_708_i5 j) (childrenD_708_i5 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_7 3 (5, 8)).mono (by decide +kernel) + · exact (placed21_template row_works_186 5 (11, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_292 6 (9, 11)).mono (by decide +kernel) +theorem row_works_708_i5 : Template HasSnaky 7 required_708_i5 envelope_708_i5 := by + refine compose HasSnaky 6 childrenC_708_i5 childrenD_708_i5 children_work_708_i5 (9, 8) + required_708_i5 envelope_708_i5 pivot_mem_708_i5 child_required_sub_708_i5 child_envelope_sub_708_i5 ?_ + intro b hb + exact common_sub_708_i5 (mem_commonEnvelope childrenD_708_i5 b hb) +def required_708_i0 : Finset Cell := ⟨(([(7, 8), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_708_i0 : Finset Cell := ⟨(([(2, 7), (2, 9), (3, 7), (3, 8), (3, 9), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 8), (8, 9), (8, 10), (8, 11), (9, 7), (9, 8), (9, 9), (10, 7), (10, 8), (11, 7), (11, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_708_i0 : Fin 7 → Finset Cell := ![(placed21 0 (5, 5) required_117), (placed21 2 (9, 6) required_137), (placed21 2 (9, 6) required_181), (placed21 2 (9, 5) required_257), (placed21 2 (9, 5) required_435), required_708_i1, required_708_i5] +def childrenD_708_i0 : Fin 7 → Finset Cell := ![(placed21 0 (5, 5) envelope_117), (placed21 2 (9, 6) envelope_137), (placed21 2 (9, 6) envelope_181), (placed21 2 (9, 5) envelope_257), (placed21 2 (9, 5) envelope_435), envelope_708_i1, envelope_708_i5] +theorem common_sub_708_i0 : commonEnvelope childrenD_708_i0 ⊆ insert (6, 8) required_708_i0 := by decide +kernel +theorem child_required_sub_708_i0 : ∀ j, childrenC_708_i0 j ⊆ insert (6, 8) required_708_i0 := by decide +kernel +theorem child_envelope_sub_708_i0 : ∀ j, childrenD_708_i0 j ⊆ envelope_708_i0 := by decide +kernel +theorem pivot_mem_708_i0 : (6, 8) ∈ envelope_708_i0 := by decide +kernel +theorem children_work_708_i0 : ∀ j, Template HasSnaky 8 (childrenC_708_i0 j) (childrenD_708_i0 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_117 0 (5, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_137 2 (9, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_181 2 (9, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_257 2 (9, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_435 2 (9, 5)).mono (by decide +kernel) + · exact row_works_708_i1.mono (by decide +kernel) + · exact row_works_708_i5.mono (by decide +kernel) +theorem row_works_708_i0 : Template HasSnaky 9 required_708_i0 envelope_708_i0 := by + refine compose HasSnaky 8 childrenC_708_i0 childrenD_708_i0 children_work_708_i0 (6, 8) + required_708_i0 envelope_708_i0 pivot_mem_708_i0 child_required_sub_708_i0 child_envelope_sub_708_i0 ?_ + intro b hb + exact common_sub_708_i0 (mem_commonEnvelope childrenD_708_i0 b hb) +def required_708_i6 : Finset Cell := ⟨(([(7, 8), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_708_i6 : Finset Cell := ⟨(([(3, 9), (3, 10), (3, 11), (4, 9), (4, 10), (4, 11), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (8, 4), (8, 5), (8, 6), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (12, 7), (12, 9), (12, 10), (12, 11), (12, 12)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_708_i6 : Fin 7 → Finset Cell := ![(placed21 3 (5, 9) required_12), (placed21 5 (11, 6) required_135), (placed21 0 (6, 6) required_181), (placed21 4 (6, 11) required_435), (placed21 4 (5, 11) required_565), (placed21 2 (12, 4) required_687), (placed21 0 (5, 4) required_689)] +def childrenD_708_i6 : Fin 7 → Finset Cell := ![(placed21 3 (5, 9) envelope_12), (placed21 5 (11, 6) envelope_135), (placed21 0 (6, 6) envelope_181), (placed21 4 (6, 11) envelope_435), (placed21 4 (5, 11) envelope_565), (placed21 2 (12, 4) envelope_687), (placed21 0 (5, 4) envelope_689)] +theorem common_sub_708_i6 : commonEnvelope childrenD_708_i6 ⊆ insert (9, 8) required_708_i6 := by decide +kernel +theorem child_required_sub_708_i6 : ∀ j, childrenC_708_i6 j ⊆ insert (9, 8) required_708_i6 := by decide +kernel +theorem child_envelope_sub_708_i6 : ∀ j, childrenD_708_i6 j ⊆ envelope_708_i6 := by decide +kernel +theorem pivot_mem_708_i6 : (9, 8) ∈ envelope_708_i6 := by decide +kernel +theorem children_work_708_i6 : ∀ j, Template HasSnaky 12 (childrenC_708_i6 j) (childrenD_708_i6 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 3 (5, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_135 5 (11, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_181 0 (6, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_435 4 (6, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_565 4 (5, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_687 2 (12, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_689 0 (5, 4)).mono (by decide +kernel) +theorem row_works_708_i6 : Template HasSnaky 13 required_708_i6 envelope_708_i6 := by + refine compose HasSnaky 12 childrenC_708_i6 childrenD_708_i6 children_work_708_i6 (9, 8) + required_708_i6 envelope_708_i6 pivot_mem_708_i6 child_required_sub_708_i6 child_envelope_sub_708_i6 ?_ + intro b hb + exact common_sub_708_i6 (mem_commonEnvelope childrenD_708_i6 b hb) +def required_708_i7 : Finset Cell := ⟨(([(7, 8), (8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_708_i7 : Finset Cell := ⟨(([(2, 4), (2, 6), (2, 7), (2, 9), (2, 10), (2, 12), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (8, 3), (8, 4), (8, 5), (8, 6), (8, 8), (8, 10), (8, 11), (8, 12), (8, 13), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (14, 4), (14, 6), (14, 7), (14, 9), (14, 10), (14, 12)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_708_i7 : Fin 6 → Finset Cell := ![(placed21 1 (5, 7) required_12), (placed21 3 (5, 9) required_12), (placed21 5 (11, 7) required_12), (placed21 7 (11, 9) required_12), (placed21 0 (5, 1) required_490), (placed21 2 (11, 1) required_490)] +def childrenD_708_i7 : Fin 6 → Finset Cell := ![(placed21 1 (5, 7) envelope_12), (placed21 3 (5, 9) envelope_12), (placed21 5 (11, 7) envelope_12), (placed21 7 (11, 9) envelope_12), (placed21 0 (5, 1) envelope_490), (placed21 2 (11, 1) envelope_490)] +theorem common_sub_708_i7 : commonEnvelope childrenD_708_i7 ⊆ insert (9, 8) required_708_i7 := by decide +kernel +theorem child_required_sub_708_i7 : ∀ j, childrenC_708_i7 j ⊆ insert (9, 8) required_708_i7 := by decide +kernel +theorem child_envelope_sub_708_i7 : ∀ j, childrenD_708_i7 j ⊆ envelope_708_i7 := by decide +kernel +theorem pivot_mem_708_i7 : (9, 8) ∈ envelope_708_i7 := by decide +kernel +theorem children_work_708_i7 : ∀ j, Template HasSnaky 13 (childrenC_708_i7 j) (childrenD_708_i7 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_12 1 (5, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_12 3 (5, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_12 5 (11, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_12 7 (11, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_490 0 (5, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_490 2 (11, 1)).mono (by decide +kernel) +theorem row_works_708_i7 : Template HasSnaky 14 required_708_i7 envelope_708_i7 := by + refine compose HasSnaky 13 childrenC_708_i7 childrenD_708_i7 children_work_708_i7 (9, 8) + required_708_i7 envelope_708_i7 pivot_mem_708_i7 child_required_sub_708_i7 child_envelope_sub_708_i7 ?_ + intro b hb + exact common_sub_708_i7 (mem_commonEnvelope childrenD_708_i7 b hb) +def required_708 : Finset Cell := ⟨(([(8, 8)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_708 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 11), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 14), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (9, 16), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (10, 16), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (11, 15), (11, 16), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (13, 15), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 11), (14, 12), (14, 13), (14, 15), (15, 5), (15, 6), (15, 7), (15, 8), (15, 9), (15, 10), (15, 11), (16, 6), (16, 8), (16, 10)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_708 : Fin 16 → Finset Cell := ![(placed21 5 (12, 7) required_459), (placed21 5 (11, 6) required_475), (placed21 3 (4, 10) required_587), (placed21 1 (4, 7) required_603), (placed21 0 (5, 5) required_605), (placed21 6 (11, 13) required_650), (placed21 0 (1, 1) required_684), required_708_i0, required_708_i6, (placed21 7 (13, 13) required_694), (placed21 0 (5, 3) required_695), (placed21 5 (13, 3) required_696), (placed21 1 (3, 4) required_698), (placed21 2 (13, 1) required_701), required_708_i7, (placed21 2 (12, 3) required_707)] +def childrenD_708 : Fin 16 → Finset Cell := ![(placed21 5 (12, 7) envelope_459), (placed21 5 (11, 6) envelope_475), (placed21 3 (4, 10) envelope_587), (placed21 1 (4, 7) envelope_603), (placed21 0 (5, 5) envelope_605), (placed21 6 (11, 13) envelope_650), (placed21 0 (1, 1) envelope_684), envelope_708_i0, envelope_708_i6, (placed21 7 (13, 13) envelope_694), (placed21 0 (5, 3) envelope_695), (placed21 5 (13, 3) envelope_696), (placed21 1 (3, 4) envelope_698), (placed21 2 (13, 1) envelope_701), envelope_708_i7, (placed21 2 (12, 3) envelope_707)] +theorem common_sub_708 : commonEnvelope childrenD_708 ⊆ insert (7, 8) required_708 := by decide +kernel +theorem child_required_sub_708 : ∀ j, childrenC_708 j ⊆ insert (7, 8) required_708 := by decide +kernel +theorem child_envelope_sub_708 : ∀ j, childrenD_708 j ⊆ envelope_708 := by decide +kernel +theorem pivot_mem_708 : (7, 8) ∈ envelope_708 := by decide +kernel +theorem children_work_708 : ∀ j, Template HasSnaky 19 (childrenC_708 j) (childrenD_708 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_459 5 (12, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_475 5 (11, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_587 3 (4, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_603 1 (4, 7)).mono (by decide +kernel) + · exact (placed21_template row_works_605 0 (5, 5)).mono (by decide +kernel) + · exact (placed21_template row_works_650 6 (11, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_684 0 (1, 1)).mono (by decide +kernel) + · exact row_works_708_i0.mono (by decide +kernel) + · exact row_works_708_i6.mono (by decide +kernel) + · exact (placed21_template row_works_694 7 (13, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_695 0 (5, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_696 5 (13, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_698 1 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_701 2 (13, 1)).mono (by decide +kernel) + · exact row_works_708_i7.mono (by decide +kernel) + · exact (placed21_template row_works_707 2 (12, 3)).mono (by decide +kernel) +theorem row_works_708 : Template HasSnaky 20 required_708 envelope_708 := by + refine compose HasSnaky 19 childrenC_708 childrenD_708 children_work_708 (7, 8) + required_708 envelope_708 pivot_mem_708 child_required_sub_708 child_envelope_sub_708 ?_ + intro b hb + exact common_sub_708 (mem_commonEnvelope childrenD_708 b hb) +def required_725 : Finset Cell := ⟨(([(7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_725 : Finset Cell := ⟨(([(0, 3), (0, 4), (0, 5), (0, 6), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 11), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 10), (6, 11), (6, 12), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (14, 2), (14, 3), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 12), (15, 6), (15, 7), (15, 8), (15, 9)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_725 : Fin 16 → Finset Cell := ![(placed21 4 (6, 12) required_459), (placed21 7 (11, 9) required_579), (placed21 6 (11, 12) required_581), (placed21 4 (4, 11) required_654), (placed21 0 (3, 3) required_661), (placed21 6 (10, 12) required_677), (placed21 7 (12, 11) required_682), (placed21 4 (2, 13) required_694), (placed21 0 (2, 2) required_696), (placed21 6 (11, 12) required_698), (placed21 0 (2, 2) required_709), (placed21 0 (4, 3) required_710), (placed21 3 (2, 12) required_715), (placed21 7 (13, 12) required_717), (placed21 0 (2, 2) required_718), (placed21 6 (12, 15) required_724)] +def childrenD_725 : Fin 16 → Finset Cell := ![(placed21 4 (6, 12) envelope_459), (placed21 7 (11, 9) envelope_579), (placed21 6 (11, 12) envelope_581), (placed21 4 (4, 11) envelope_654), (placed21 0 (3, 3) envelope_661), (placed21 6 (10, 12) envelope_677), (placed21 7 (12, 11) envelope_682), (placed21 4 (2, 13) envelope_694), (placed21 0 (2, 2) envelope_696), (placed21 6 (11, 12) envelope_698), (placed21 0 (2, 2) envelope_709), (placed21 0 (4, 3) envelope_710), (placed21 3 (2, 12) envelope_715), (placed21 7 (13, 12) envelope_717), (placed21 0 (2, 2) envelope_718), (placed21 6 (12, 15) envelope_724)] +theorem common_sub_725 : commonEnvelope childrenD_725 ⊆ insert (7, 8) required_725 := by decide +kernel +theorem child_required_sub_725 : ∀ j, childrenC_725 j ⊆ insert (7, 8) required_725 := by decide +kernel +theorem child_envelope_sub_725 : ∀ j, childrenD_725 j ⊆ envelope_725 := by decide +kernel +theorem pivot_mem_725 : (7, 8) ∈ envelope_725 := by decide +kernel +theorem children_work_725 : ∀ j, Template HasSnaky 19 (childrenC_725 j) (childrenD_725 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_459 4 (6, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_579 7 (11, 9)).mono (by decide +kernel) + · exact (placed21_template row_works_581 6 (11, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_654 4 (4, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_661 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_677 6 (10, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_682 7 (12, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_694 4 (2, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_696 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_698 6 (11, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_709 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_710 0 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_715 3 (2, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_717 7 (13, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_718 0 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_724 6 (12, 15)).mono (by decide +kernel) +theorem row_works_725 : Template HasSnaky 20 required_725 envelope_725 := by + refine compose HasSnaky 19 childrenC_725 childrenD_725 children_work_725 (7, 8) + required_725 envelope_725 pivot_mem_725 child_required_sub_725 child_envelope_sub_725 ?_ + intro b hb + exact common_sub_725 (mem_commonEnvelope childrenD_725 b hb) +def required_726 : Finset Cell := ⟨(([(7, 7)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def envelope_726 : Finset Cell := ⟨(([(0, 8), (1, 8), (1, 9), (1, 10), (2, 8), (2, 9), (2, 10), (2, 11), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (6, 3), (6, 4), (6, 5), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (10, 0), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (12, 0), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (14, 3), (14, 4), (14, 5), (14, 6), (14, 8), (14, 9), (14, 10), (14, 11), (15, 6), (15, 9), (15, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_726 : Fin 16 → Finset Cell := ![(placed21 1 (3, 6) required_459), (placed21 4 (6, 11) required_579), (placed21 1 (3, 3) required_581), (placed21 1 (4, 4) required_654), (placed21 5 (12, 3) required_661), (placed21 3 (3, 10) required_677), (placed21 4 (4, 12) required_682), (placed21 1 (2, 2) required_694), (placed21 5 (13, 2) required_696), (placed21 3 (3, 11) required_698), (placed21 5 (13, 2) required_709), (placed21 5 (12, 4) required_710), (placed21 0 (3, 2) required_715), (placed21 4 (3, 13) required_717), (placed21 5 (13, 2) required_718), (placed21 5 (15, 2) required_724)] +def childrenD_726 : Fin 16 → Finset Cell := ![(placed21 1 (3, 6) envelope_459), (placed21 4 (6, 11) envelope_579), (placed21 1 (3, 3) envelope_581), (placed21 1 (4, 4) envelope_654), (placed21 5 (12, 3) envelope_661), (placed21 3 (3, 10) envelope_677), (placed21 4 (4, 12) envelope_682), (placed21 1 (2, 2) envelope_694), (placed21 5 (13, 2) envelope_696), (placed21 3 (3, 11) envelope_698), (placed21 5 (13, 2) envelope_709), (placed21 5 (12, 4) envelope_710), (placed21 0 (3, 2) envelope_715), (placed21 4 (3, 13) envelope_717), (placed21 5 (13, 2) envelope_718), (placed21 5 (15, 2) envelope_724)] +theorem common_sub_726 : commonEnvelope childrenD_726 ⊆ insert (8, 7) required_726 := by decide +kernel +theorem child_required_sub_726 : ∀ j, childrenC_726 j ⊆ insert (8, 7) required_726 := by decide +kernel +theorem child_envelope_sub_726 : ∀ j, childrenD_726 j ⊆ envelope_726 := by decide +kernel +theorem pivot_mem_726 : (8, 7) ∈ envelope_726 := by decide +kernel +theorem children_work_726 : ∀ j, Template HasSnaky 19 (childrenC_726 j) (childrenD_726 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_459 1 (3, 6)).mono (by decide +kernel) + · exact (placed21_template row_works_579 4 (6, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_581 1 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_654 1 (4, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_661 5 (12, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_677 3 (3, 10)).mono (by decide +kernel) + · exact (placed21_template row_works_682 4 (4, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_694 1 (2, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_696 5 (13, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_698 3 (3, 11)).mono (by decide +kernel) + · exact (placed21_template row_works_709 5 (13, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_710 5 (12, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_715 0 (3, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_717 4 (3, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_718 5 (13, 2)).mono (by decide +kernel) + · exact (placed21_template row_works_724 5 (15, 2)).mono (by decide +kernel) +theorem row_works_726 : Template HasSnaky 20 required_726 envelope_726 := by + refine compose HasSnaky 19 childrenC_726 childrenD_726 children_work_726 (8, 7) + required_726 envelope_726 pivot_mem_726 child_required_sub_726 child_envelope_sub_726 ?_ + intro b hb + exact common_sub_726 (mem_commonEnvelope childrenD_726 b hb) +def height_708_i2 : ℕ := 6 +def childrenH_708_i2 : Fin 3 → ℕ := ![height_7, height_234, height_241] +theorem height_exact_708_i2 : height_708_i2 = 1 + Finset.univ.sup childrenH_708_i2 := by decide +kernel +theorem required_origin_708_i2 : ∀ x ∈ required_708_i2, + (∃ j, x ∈ childrenC_708_i2 j) ∨ ∀ j, x ∈ childrenD_708_i2 j := by decide +kernel +theorem required_exact_708_i2 : required_708_i2 = + ((Finset.univ.biUnion childrenC_708_i2) ∪ commonEnvelope childrenD_708_i2).erase (5, 8) := by + exact required_eq_combination childrenC_708_i2 childrenD_708_i2 (5, 8) required_708_i2 + (by decide +kernel) child_required_sub_708_i2 common_sub_708_i2 required_origin_708_i2 +theorem envelope_origin_708_i2 : ∀ x ∈ envelope_708_i2, + x = (5, 8) ∨ ∃ j, x ∈ childrenD_708_i2 j := by decide +kernel +theorem envelope_exact_708_i2 : envelope_708_i2 = + insert (5, 8) (Finset.univ.biUnion childrenD_708_i2) := by + exact envelope_eq_combination childrenD_708_i2 (5, 8) envelope_708_i2 + pivot_mem_708_i2 child_envelope_sub_708_i2 envelope_origin_708_i2 +def checked_708_i2 : CheckedCard where + required := required_708_i2 + envelope := envelope_708_i2 + height := height_708_i2 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_708_i2 +def height_708_i4 : ℕ := 5 +def childrenH_708_i4 : Fin 3 → ℕ := ![height_7, height_9, height_92] +theorem height_exact_708_i4 : height_708_i4 = 1 + Finset.univ.sup childrenH_708_i4 := by decide +kernel +theorem required_origin_708_i4 : ∀ x ∈ required_708_i4, + (∃ j, x ∈ childrenC_708_i4 j) ∨ ∀ j, x ∈ childrenD_708_i4 j := by decide +kernel +theorem required_exact_708_i4 : required_708_i4 = + ((Finset.univ.biUnion childrenC_708_i4) ∪ commonEnvelope childrenD_708_i4).erase (7, 9) := by + exact required_eq_combination childrenC_708_i4 childrenD_708_i4 (7, 9) required_708_i4 + (by decide +kernel) child_required_sub_708_i4 common_sub_708_i4 required_origin_708_i4 +theorem envelope_origin_708_i4 : ∀ x ∈ envelope_708_i4, + x = (7, 9) ∨ ∃ j, x ∈ childrenD_708_i4 j := by decide +kernel +theorem envelope_exact_708_i4 : envelope_708_i4 = + insert (7, 9) (Finset.univ.biUnion childrenD_708_i4) := by + exact envelope_eq_combination childrenD_708_i4 (7, 9) envelope_708_i4 + pivot_mem_708_i4 child_envelope_sub_708_i4 envelope_origin_708_i4 +def checked_708_i4 : CheckedCard where + required := required_708_i4 + envelope := envelope_708_i4 + height := height_708_i4 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_708_i4 +def height_708_i3 : ℕ := 6 +def childrenH_708_i3 : Fin 3 → ℕ := ![height_44, height_52, height_708_i4] +theorem height_exact_708_i3 : height_708_i3 = 1 + Finset.univ.sup childrenH_708_i3 := by decide +kernel +theorem required_origin_708_i3 : ∀ x ∈ required_708_i3, + (∃ j, x ∈ childrenC_708_i3 j) ∨ ∀ j, x ∈ childrenD_708_i3 j := by decide +kernel +theorem required_exact_708_i3 : required_708_i3 = + ((Finset.univ.biUnion childrenC_708_i3) ∪ commonEnvelope childrenD_708_i3).erase (7, 6) := by + exact required_eq_combination childrenC_708_i3 childrenD_708_i3 (7, 6) required_708_i3 + (by decide +kernel) child_required_sub_708_i3 common_sub_708_i3 required_origin_708_i3 +theorem envelope_origin_708_i3 : ∀ x ∈ envelope_708_i3, + x = (7, 6) ∨ ∃ j, x ∈ childrenD_708_i3 j := by decide +kernel +theorem envelope_exact_708_i3 : envelope_708_i3 = + insert (7, 6) (Finset.univ.biUnion childrenD_708_i3) := by + exact envelope_eq_combination childrenD_708_i3 (7, 6) envelope_708_i3 + pivot_mem_708_i3 child_envelope_sub_708_i3 envelope_origin_708_i3 +def checked_708_i3 : CheckedCard where + required := required_708_i3 + envelope := envelope_708_i3 + height := height_708_i3 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_708_i3 +def height_708_i1 : ℕ := 7 +def childrenH_708_i1 : Fin 6 → ℕ := ![height_57, height_88, height_111, height_213, height_708_i2, height_708_i3] +theorem height_exact_708_i1 : height_708_i1 = 1 + Finset.univ.sup childrenH_708_i1 := by decide +kernel +theorem required_origin_708_i1 : ∀ x ∈ required_708_i1, + (∃ j, x ∈ childrenC_708_i1 j) ∨ ∀ j, x ∈ childrenD_708_i1 j := by decide +kernel +theorem required_exact_708_i1 : required_708_i1 = + ((Finset.univ.biUnion childrenC_708_i1) ∪ commonEnvelope childrenD_708_i1).erase (7, 7) := by + exact required_eq_combination childrenC_708_i1 childrenD_708_i1 (7, 7) required_708_i1 + (by decide +kernel) child_required_sub_708_i1 common_sub_708_i1 required_origin_708_i1 +theorem envelope_origin_708_i1 : ∀ x ∈ envelope_708_i1, + x = (7, 7) ∨ ∃ j, x ∈ childrenD_708_i1 j := by decide +kernel +theorem envelope_exact_708_i1 : envelope_708_i1 = + insert (7, 7) (Finset.univ.biUnion childrenD_708_i1) := by + exact envelope_eq_combination childrenD_708_i1 (7, 7) envelope_708_i1 + pivot_mem_708_i1 child_envelope_sub_708_i1 envelope_origin_708_i1 +def checked_708_i1 : CheckedCard where + required := required_708_i1 + envelope := envelope_708_i1 + height := height_708_i1 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_708_i1 +def height_708_i5 : ℕ := 7 +def childrenH_708_i5 : Fin 3 → ℕ := ![height_7, height_186, height_292] +theorem height_exact_708_i5 : height_708_i5 = 1 + Finset.univ.sup childrenH_708_i5 := by decide +kernel +theorem required_origin_708_i5 : ∀ x ∈ required_708_i5, + (∃ j, x ∈ childrenC_708_i5 j) ∨ ∀ j, x ∈ childrenD_708_i5 j := by decide +kernel +theorem required_exact_708_i5 : required_708_i5 = + ((Finset.univ.biUnion childrenC_708_i5) ∪ commonEnvelope childrenD_708_i5).erase (9, 8) := by + exact required_eq_combination childrenC_708_i5 childrenD_708_i5 (9, 8) required_708_i5 + (by decide +kernel) child_required_sub_708_i5 common_sub_708_i5 required_origin_708_i5 +theorem envelope_origin_708_i5 : ∀ x ∈ envelope_708_i5, + x = (9, 8) ∨ ∃ j, x ∈ childrenD_708_i5 j := by decide +kernel +theorem envelope_exact_708_i5 : envelope_708_i5 = + insert (9, 8) (Finset.univ.biUnion childrenD_708_i5) := by + exact envelope_eq_combination childrenD_708_i5 (9, 8) envelope_708_i5 + pivot_mem_708_i5 child_envelope_sub_708_i5 envelope_origin_708_i5 +def checked_708_i5 : CheckedCard where + required := required_708_i5 + envelope := envelope_708_i5 + height := height_708_i5 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_708_i5 +def height_708_i0 : ℕ := 9 +def childrenH_708_i0 : Fin 7 → ℕ := ![height_117, height_137, height_181, height_257, height_435, height_708_i1, height_708_i5] +theorem height_exact_708_i0 : height_708_i0 = 1 + Finset.univ.sup childrenH_708_i0 := by decide +kernel +theorem required_origin_708_i0 : ∀ x ∈ required_708_i0, + (∃ j, x ∈ childrenC_708_i0 j) ∨ ∀ j, x ∈ childrenD_708_i0 j := by decide +kernel +theorem required_exact_708_i0 : required_708_i0 = + ((Finset.univ.biUnion childrenC_708_i0) ∪ commonEnvelope childrenD_708_i0).erase (6, 8) := by + exact required_eq_combination childrenC_708_i0 childrenD_708_i0 (6, 8) required_708_i0 + (by decide +kernel) child_required_sub_708_i0 common_sub_708_i0 required_origin_708_i0 +theorem envelope_origin_708_i0 : ∀ x ∈ envelope_708_i0, + x = (6, 8) ∨ ∃ j, x ∈ childrenD_708_i0 j := by decide +kernel +theorem envelope_exact_708_i0 : envelope_708_i0 = + insert (6, 8) (Finset.univ.biUnion childrenD_708_i0) := by + exact envelope_eq_combination childrenD_708_i0 (6, 8) envelope_708_i0 + pivot_mem_708_i0 child_envelope_sub_708_i0 envelope_origin_708_i0 +def checked_708_i0 : CheckedCard where + required := required_708_i0 + envelope := envelope_708_i0 + height := height_708_i0 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_708_i0 +def height_708_i6 : ℕ := 13 +def childrenH_708_i6 : Fin 7 → ℕ := ![height_12, height_135, height_181, height_435, height_565, height_687, height_689] +theorem height_exact_708_i6 : height_708_i6 = 1 + Finset.univ.sup childrenH_708_i6 := by decide +kernel +theorem required_origin_708_i6 : ∀ x ∈ required_708_i6, + (∃ j, x ∈ childrenC_708_i6 j) ∨ ∀ j, x ∈ childrenD_708_i6 j := by decide +kernel +theorem required_exact_708_i6 : required_708_i6 = + ((Finset.univ.biUnion childrenC_708_i6) ∪ commonEnvelope childrenD_708_i6).erase (9, 8) := by + exact required_eq_combination childrenC_708_i6 childrenD_708_i6 (9, 8) required_708_i6 + (by decide +kernel) child_required_sub_708_i6 common_sub_708_i6 required_origin_708_i6 +theorem envelope_origin_708_i6 : ∀ x ∈ envelope_708_i6, + x = (9, 8) ∨ ∃ j, x ∈ childrenD_708_i6 j := by decide +kernel +theorem envelope_exact_708_i6 : envelope_708_i6 = + insert (9, 8) (Finset.univ.biUnion childrenD_708_i6) := by + exact envelope_eq_combination childrenD_708_i6 (9, 8) envelope_708_i6 + pivot_mem_708_i6 child_envelope_sub_708_i6 envelope_origin_708_i6 +def checked_708_i6 : CheckedCard where + required := required_708_i6 + envelope := envelope_708_i6 + height := height_708_i6 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_708_i6 +def height_708_i7 : ℕ := 14 +def childrenH_708_i7 : Fin 6 → ℕ := ![height_12, height_12, height_12, height_12, height_490, height_490] +theorem height_exact_708_i7 : height_708_i7 = 1 + Finset.univ.sup childrenH_708_i7 := by decide +kernel +theorem required_origin_708_i7 : ∀ x ∈ required_708_i7, + (∃ j, x ∈ childrenC_708_i7 j) ∨ ∀ j, x ∈ childrenD_708_i7 j := by decide +kernel +theorem required_exact_708_i7 : required_708_i7 = + ((Finset.univ.biUnion childrenC_708_i7) ∪ commonEnvelope childrenD_708_i7).erase (9, 8) := by + exact required_eq_combination childrenC_708_i7 childrenD_708_i7 (9, 8) required_708_i7 + (by decide +kernel) child_required_sub_708_i7 common_sub_708_i7 required_origin_708_i7 +theorem envelope_origin_708_i7 : ∀ x ∈ envelope_708_i7, + x = (9, 8) ∨ ∃ j, x ∈ childrenD_708_i7 j := by decide +kernel +theorem envelope_exact_708_i7 : envelope_708_i7 = + insert (9, 8) (Finset.univ.biUnion childrenD_708_i7) := by + exact envelope_eq_combination childrenD_708_i7 (9, 8) envelope_708_i7 + pivot_mem_708_i7 child_envelope_sub_708_i7 envelope_origin_708_i7 +def checked_708_i7 : CheckedCard where + required := required_708_i7 + envelope := envelope_708_i7 + height := height_708_i7 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_708_i7 +def height_708 : ℕ := 20 +def childrenH_708 : Fin 16 → ℕ := ![height_459, height_475, height_587, height_603, height_605, height_650, height_684, height_708_i0, height_708_i6, height_694, height_695, height_696, height_698, height_701, height_708_i7, height_707] +theorem height_exact_708 : height_708 = 1 + Finset.univ.sup childrenH_708 := by decide +kernel +theorem required_origin_708 : ∀ x ∈ required_708, + (∃ j, x ∈ childrenC_708 j) ∨ ∀ j, x ∈ childrenD_708 j := by decide +kernel +theorem required_exact_708 : required_708 = + ((Finset.univ.biUnion childrenC_708) ∪ commonEnvelope childrenD_708).erase (7, 8) := by + exact required_eq_combination childrenC_708 childrenD_708 (7, 8) required_708 + (by decide +kernel) child_required_sub_708 common_sub_708 required_origin_708 +theorem envelope_origin_708 : ∀ x ∈ envelope_708, + x = (7, 8) ∨ ∃ j, x ∈ childrenD_708 j := by decide +kernel +theorem envelope_exact_708 : envelope_708 = + insert (7, 8) (Finset.univ.biUnion childrenD_708) := by + exact envelope_eq_combination childrenD_708 (7, 8) envelope_708 + pivot_mem_708 child_envelope_sub_708 envelope_origin_708 +def checked_708 : CheckedCard where + required := required_708 + envelope := envelope_708 + height := height_708 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_708 +def height_725 : ℕ := 20 +def childrenH_725 : Fin 16 → ℕ := ![height_459, height_579, height_581, height_654, height_661, height_677, height_682, height_694, height_696, height_698, height_709, height_710, height_715, height_717, height_718, height_724] +theorem height_exact_725 : height_725 = 1 + Finset.univ.sup childrenH_725 := by decide +kernel +theorem required_origin_725 : ∀ x ∈ required_725, + (∃ j, x ∈ childrenC_725 j) ∨ ∀ j, x ∈ childrenD_725 j := by decide +kernel +theorem required_exact_725 : required_725 = + ((Finset.univ.biUnion childrenC_725) ∪ commonEnvelope childrenD_725).erase (7, 8) := by + exact required_eq_combination childrenC_725 childrenD_725 (7, 8) required_725 + (by decide +kernel) child_required_sub_725 common_sub_725 required_origin_725 +theorem envelope_origin_725 : ∀ x ∈ envelope_725, + x = (7, 8) ∨ ∃ j, x ∈ childrenD_725 j := by decide +kernel +theorem envelope_exact_725 : envelope_725 = + insert (7, 8) (Finset.univ.biUnion childrenD_725) := by + exact envelope_eq_combination childrenD_725 (7, 8) envelope_725 + pivot_mem_725 child_envelope_sub_725 envelope_origin_725 +def checked_725 : CheckedCard where + required := required_725 + envelope := envelope_725 + height := height_725 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_725 +def height_726 : ℕ := 20 +def childrenH_726 : Fin 16 → ℕ := ![height_459, height_579, height_581, height_654, height_661, height_677, height_682, height_694, height_696, height_698, height_709, height_710, height_715, height_717, height_718, height_724] +theorem height_exact_726 : height_726 = 1 + Finset.univ.sup childrenH_726 := by decide +kernel +theorem required_origin_726 : ∀ x ∈ required_726, + (∃ j, x ∈ childrenC_726 j) ∨ ∀ j, x ∈ childrenD_726 j := by decide +kernel +theorem required_exact_726 : required_726 = + ((Finset.univ.biUnion childrenC_726) ∪ commonEnvelope childrenD_726).erase (8, 7) := by + exact required_eq_combination childrenC_726 childrenD_726 (8, 7) required_726 + (by decide +kernel) child_required_sub_726 common_sub_726 required_origin_726 +theorem envelope_origin_726 : ∀ x ∈ envelope_726, + x = (8, 7) ∨ ∃ j, x ∈ childrenD_726 j := by decide +kernel +theorem envelope_exact_726 : envelope_726 = + insert (8, 7) (Finset.univ.biUnion childrenD_726) := by + exact envelope_eq_combination childrenD_726 (8, 7) envelope_726 + pivot_mem_726 child_envelope_sub_726 envelope_origin_726 +def checked_726 : CheckedCard where + required := required_726 + envelope := envelope_726 + height := height_726 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_726 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height21Part01.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height21Part01.lean new file mode 100644 index 0000000..71a637e --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height21Part01.lean @@ -0,0 +1,84 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height20Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def required_727 : Finset Cell := ∅ +def envelope_727 : Finset Cell := ⟨(([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11), (0, 12), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (9, 16), (10, 0), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (10, 16), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (11, 15), (11, 16), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (12, 16), (13, 1), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (13, 15), (14, 1), (14, 2), (14, 3), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 11), (14, 12), (14, 13), (14, 14), (15, 3), (15, 4), (15, 5), (15, 6), (15, 7), (15, 8), (15, 9), (15, 10), (15, 11), (15, 12), (15, 13), (15, 14), (16, 4), (16, 5), (16, 6), (16, 7), (16, 8), (16, 9), (16, 10), (16, 11)] : List Cell) : Multiset Cell), by decide +kernel⟩ +def childrenC_727 : Fin 32 → Finset Cell := ![(placed21 0 (4, 3) required_648), (placed21 1 (3, 4) required_648), (placed21 3 (3, 12) required_648), (placed21 4 (4, 13) required_648), (placed21 1 (0, 0) required_708), (placed21 2 (16, 0) required_708), (placed21 4 (0, 16) required_708), (placed21 7 (16, 16) required_708), (placed21 0 (3, 3) required_712), (placed21 1 (3, 3) required_712), (placed21 2 (13, 3) required_712), (placed21 3 (3, 13) required_712), (placed21 4 (3, 13) required_712), (placed21 5 (13, 3) required_712), (placed21 6 (13, 13) required_712), (placed21 7 (13, 13) required_712), (placed21 2 (13, 3) required_713), (placed21 3 (3, 13) required_713), (placed21 4 (3, 13) required_713), (placed21 5 (13, 3) required_713), (placed21 0 (1, 1) required_725), (placed21 1 (1, 1) required_725), (placed21 2 (15, 1) required_725), (placed21 3 (1, 15) required_725), (placed21 4 (1, 15) required_725), (placed21 5 (15, 1) required_725), (placed21 6 (15, 15) required_725), (placed21 7 (15, 15) required_725), (placed21 1 (1, 1) required_726), (placed21 2 (15, 1) required_726), (placed21 4 (1, 15) required_726), (placed21 6 (15, 15) required_726)] +def childrenD_727 : Fin 32 → Finset Cell := ![(placed21 0 (4, 3) envelope_648), (placed21 1 (3, 4) envelope_648), (placed21 3 (3, 12) envelope_648), (placed21 4 (4, 13) envelope_648), (placed21 1 (0, 0) envelope_708), (placed21 2 (16, 0) envelope_708), (placed21 4 (0, 16) envelope_708), (placed21 7 (16, 16) envelope_708), (placed21 0 (3, 3) envelope_712), (placed21 1 (3, 3) envelope_712), (placed21 2 (13, 3) envelope_712), (placed21 3 (3, 13) envelope_712), (placed21 4 (3, 13) envelope_712), (placed21 5 (13, 3) envelope_712), (placed21 6 (13, 13) envelope_712), (placed21 7 (13, 13) envelope_712), (placed21 2 (13, 3) envelope_713), (placed21 3 (3, 13) envelope_713), (placed21 4 (3, 13) envelope_713), (placed21 5 (13, 3) envelope_713), (placed21 0 (1, 1) envelope_725), (placed21 1 (1, 1) envelope_725), (placed21 2 (15, 1) envelope_725), (placed21 3 (1, 15) envelope_725), (placed21 4 (1, 15) envelope_725), (placed21 5 (15, 1) envelope_725), (placed21 6 (15, 15) envelope_725), (placed21 7 (15, 15) envelope_725), (placed21 1 (1, 1) envelope_726), (placed21 2 (15, 1) envelope_726), (placed21 4 (1, 15) envelope_726), (placed21 6 (15, 15) envelope_726)] +theorem common_sub_727 : commonEnvelope childrenD_727 ⊆ insert (8, 8) required_727 := by decide +kernel +theorem child_required_sub_727 : ∀ j, childrenC_727 j ⊆ insert (8, 8) required_727 := by decide +kernel +theorem child_envelope_sub_727 : ∀ j, childrenD_727 j ⊆ envelope_727 := by decide +kernel +theorem pivot_mem_727 : (8, 8) ∈ envelope_727 := by decide +kernel +theorem children_work_727 : ∀ j, Template HasSnaky 20 (childrenC_727 j) (childrenD_727 j) := by + intro j + fin_cases j + · exact (placed21_template row_works_648 0 (4, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_648 1 (3, 4)).mono (by decide +kernel) + · exact (placed21_template row_works_648 3 (3, 12)).mono (by decide +kernel) + · exact (placed21_template row_works_648 4 (4, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_708 1 (0, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_708 2 (16, 0)).mono (by decide +kernel) + · exact (placed21_template row_works_708 4 (0, 16)).mono (by decide +kernel) + · exact (placed21_template row_works_708 7 (16, 16)).mono (by decide +kernel) + · exact (placed21_template row_works_712 0 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_712 1 (3, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_712 2 (13, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_712 3 (3, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_712 4 (3, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_712 5 (13, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_712 6 (13, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_712 7 (13, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_713 2 (13, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_713 3 (3, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_713 4 (3, 13)).mono (by decide +kernel) + · exact (placed21_template row_works_713 5 (13, 3)).mono (by decide +kernel) + · exact (placed21_template row_works_725 0 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_725 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_725 2 (15, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_725 3 (1, 15)).mono (by decide +kernel) + · exact (placed21_template row_works_725 4 (1, 15)).mono (by decide +kernel) + · exact (placed21_template row_works_725 5 (15, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_725 6 (15, 15)).mono (by decide +kernel) + · exact (placed21_template row_works_725 7 (15, 15)).mono (by decide +kernel) + · exact (placed21_template row_works_726 1 (1, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_726 2 (15, 1)).mono (by decide +kernel) + · exact (placed21_template row_works_726 4 (1, 15)).mono (by decide +kernel) + · exact (placed21_template row_works_726 6 (15, 15)).mono (by decide +kernel) +theorem row_works_727 : Template HasSnaky 21 required_727 envelope_727 := by + refine compose HasSnaky 20 childrenC_727 childrenD_727 children_work_727 (8, 8) + required_727 envelope_727 pivot_mem_727 child_required_sub_727 child_envelope_sub_727 ?_ + intro b hb + exact common_sub_727 (mem_commonEnvelope childrenD_727 b hb) +def height_727 : ℕ := 21 +def childrenH_727 : Fin 32 → ℕ := ![height_648, height_648, height_648, height_648, height_708, height_708, height_708, height_708, height_712, height_712, height_712, height_712, height_712, height_712, height_712, height_712, height_713, height_713, height_713, height_713, height_725, height_725, height_725, height_725, height_725, height_725, height_725, height_725, height_726, height_726, height_726, height_726] +theorem height_exact_727 : height_727 = 1 + Finset.univ.sup childrenH_727 := by decide +kernel +theorem required_origin_727 : ∀ x ∈ required_727, + (∃ j, x ∈ childrenC_727 j) ∨ ∀ j, x ∈ childrenD_727 j := by decide +kernel +theorem required_exact_727 : required_727 = + ((Finset.univ.biUnion childrenC_727) ∪ commonEnvelope childrenD_727).erase (8, 8) := by + exact required_eq_combination childrenC_727 childrenD_727 (8, 8) required_727 + (by decide +kernel) child_required_sub_727 common_sub_727 required_origin_727 +theorem envelope_origin_727 : ∀ x ∈ envelope_727, + x = (8, 8) ∨ ∃ j, x ∈ childrenD_727 j := by decide +kernel +theorem envelope_exact_727 : envelope_727 = + insert (8, 8) (Finset.univ.biUnion childrenD_727) := by + exact envelope_eq_combination childrenD_727 (8, 8) envelope_727 + pivot_mem_727 child_envelope_sub_727 envelope_origin_727 +def checked_727 : CheckedCard where + required := required_727 + envelope := envelope_727 + height := height_727 + required_sub_envelope := by decide +kernel + height_positive := by decide +kernel + height_le_twenty_one := by decide +kernel + works := row_works_727 +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Certificate/Operations.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Certificate/Operations.lean new file mode 100644 index 0000000..5d67389 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Certificate/Operations.lean @@ -0,0 +1,101 @@ +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game +import OAI.GameTheory.SnakyTwentyOne.Semantics.Geometry + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def currentCode (s : Fin 8) : Fin 8 := ![0, 1, 4, 5, 2, 3, 6, 7] s +def currentOrient (s : Fin 8) (p : Cell) : Cell := + match s.val with + | 0 => (p.1, p.2) + | 1 => (p.2, p.1) + | 2 => (-p.1, p.2) + | 3 => (p.2, -p.1) + | 4 => (p.1, -p.2) + | 5 => (-p.2, p.1) + | 6 => (-p.1, -p.2) + | _ => (-p.2, -p.1) +theorem currentOrient_eq (s : Fin 8) (p : Cell) : + currentOrient s p = orient (currentCode s) p := by + fin_cases s <;> rfl +def placed21 (s : Fin 8) (t : Cell) (A : Finset Cell) : Finset Cell := + A.map (placementEquiv (currentCode s) t).toEmbedding +theorem placed21_eq_image (s : Fin 8) (t : Cell) (A : Finset Cell) : + placed21 s t A = A.image (fun p => currentOrient s p + t) := by + rw [placed21, Finset.map_eq_image] + apply Finset.image_congr + intro p _ + change orient (currentCode s) p + t = currentOrient s p + t + rw [currentOrient_eq] +theorem placed21_template {n : ℕ} {A T : Finset Cell} + (h : Template HasSnaky n A T) (s : Fin 8) (t : Cell) : + Template HasSnaky n (placed21 s t A) (placed21 s t T) := by + have hh := placed_template h (currentCode s) t + simpa only [placed21, Finset.map_eq_image, Equiv.toEmbedding, + Function.Embedding.coeFn_mk, coe_placementEquiv] using hh +def commonEnvelope {r : ℕ} (D : Fin (r + 1) → Finset Cell) : Finset Cell := + (D 0).filter (fun b => ∀ j, b ∈ D j) +theorem mem_commonEnvelope {r : ℕ} (D : Fin (r + 1) → Finset Cell) + (b : Cell) (hb : ∀ j, b ∈ D j) : b ∈ commonEnvelope D := + Finset.mem_filter.mpr ⟨hb 0, hb⟩ +theorem identity_target (M : Finset Cell) (h : snaky ⊆ M) : HasSnaky M := by + refine ⟨0, (0, 0), ?_⟩ + have hp : placement 0 (0, 0) = id := by + funext p + rcases p with ⟨x, y⟩ + simp [placement, orient] + rw [hp, Finset.image_id] + exact h +theorem required_eq_combination {r : ℕ} + (C D : Fin (r + 1) → Finset Cell) (p : Cell) (A : Finset Cell) + (hp : p ∉ A) + (hC : ∀ j, C j ⊆ insert p A) + (hcommon : commonEnvelope D ⊆ insert p A) + (horigin : ∀ x ∈ A, (∃ j, x ∈ C j) ∨ ∀ j, x ∈ D j) : + A = ((Finset.univ.biUnion C) ∪ commonEnvelope D).erase p := by + ext x + constructor + · intro hx + apply Finset.mem_erase.mpr + refine ⟨fun hxp => hp (hxp ▸ hx), ?_⟩ + rcases horigin x hx with hchild | hcommon' + · obtain ⟨j, hj⟩ := hchild + exact Finset.mem_union_left _ (Finset.mem_biUnion.mpr ⟨j, Finset.mem_univ j, hj⟩) + · exact Finset.mem_union_right _ (mem_commonEnvelope D x hcommon') + · intro hx + obtain ⟨hxp, hx⟩ := Finset.mem_erase.mp hx + have hin : x ∈ insert p A := by + rcases Finset.mem_union.mp hx with hchild | hcom + · obtain ⟨j, _, hj⟩ := Finset.mem_biUnion.mp hchild + exact hC j hj + · exact hcommon hcom + exact (Finset.mem_insert.mp hin).resolve_left hxp +theorem envelope_eq_combination {r : ℕ} + (D : Fin r → Finset Cell) (p : Cell) (T : Finset Cell) + (hp : p ∈ T) (hD : ∀ j, D j ⊆ T) + (horigin : ∀ x ∈ T, x = p ∨ ∃ j, x ∈ D j) : + T = insert p (Finset.univ.biUnion D) := by + ext x + constructor + · intro hx + rcases horigin x hx with hxp | hchild + · exact Finset.mem_insert.mpr (Or.inl hxp) + · obtain ⟨j, hj⟩ := hchild + exact Finset.mem_insert_of_mem (Finset.mem_biUnion.mpr ⟨j, Finset.mem_univ j, hj⟩) + · intro hx + rcases Finset.mem_insert.mp hx with hxp | hchild + · exact hxp ▸ hp + · obtain ⟨j, _, hj⟩ := Finset.mem_biUnion.mp hchild + exact hD j hj +structure CheckedCard where + required : Finset Cell + envelope : Finset Cell + height : ℕ + required_sub_envelope : required ⊆ envelope + height_positive : 1 ≤ height + height_le_twenty_one : height ≤ 21 + works : Template HasSnaky height required envelope +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Certificate/Summary.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Certificate/Summary.lean new file mode 100644 index 0000000..4152b6f --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Certificate/Summary.lean @@ -0,0 +1,154 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height01Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height02Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height03Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height04Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height05Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height06Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height07Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height08Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height09Part08 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height10Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height11Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height12Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part05 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part06 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height13Part07 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height14Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height15Part04 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height16Part03 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height17Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height17Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height18Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height18Part02 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height19Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height20Part01 +import OAI.GameTheory.SnakyTwentyOne.Cards.Height21Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.Certificate21 +def numberedCards : Array CheckedCard := #[checked_0, checked_1, checked_2, checked_3, checked_4, checked_5, checked_6, checked_7, checked_8, checked_9, checked_10, checked_11, checked_12, checked_13, checked_14, checked_15, checked_16, checked_17, checked_18, checked_19, checked_20, checked_21, checked_22, checked_23, checked_24, checked_25, checked_26, checked_27, checked_28, checked_29, checked_30, checked_31, checked_32, checked_33, checked_34, checked_35, checked_36, checked_37, checked_38, checked_39, checked_40, checked_41, checked_42, checked_43, checked_44, checked_45, checked_46, checked_47, checked_48, checked_49, checked_50, checked_51, checked_52, checked_53, checked_54, checked_55, checked_56, checked_57, checked_58, checked_59, checked_60, checked_61, checked_62, checked_63, checked_64, checked_65, checked_66, checked_67, checked_68, checked_69, checked_70, checked_71, checked_72, checked_73, checked_74, checked_75, checked_76, checked_77, checked_78, checked_79, checked_80, checked_81, checked_82, checked_83, checked_84, checked_85, checked_86, checked_87, checked_88, checked_89, checked_90, checked_91, checked_92, checked_93, checked_94, checked_95, checked_96, checked_97, checked_98, checked_99, checked_100, checked_101, checked_102, checked_103, checked_104, checked_105, checked_106, checked_107, checked_108, checked_109, checked_110, checked_111, checked_112, checked_113, checked_114, checked_115, checked_116, checked_117, checked_118, checked_119, checked_120, checked_121, checked_122, checked_123, checked_124, checked_125, checked_126, checked_127, checked_128, checked_129, checked_130, checked_131, checked_132, checked_133, checked_134, checked_135, checked_136, checked_137, checked_138, checked_139, checked_140, checked_141, checked_142, checked_143, checked_144, checked_145, checked_146, checked_147, checked_148, checked_149, checked_150, checked_151, checked_152, checked_153, checked_154, checked_155, checked_156, checked_157, checked_158, checked_159, checked_160, checked_161, checked_162, checked_163, checked_164, checked_165, checked_166, checked_167, checked_168, checked_169, checked_170, checked_171, checked_172, checked_173, checked_174, checked_175, checked_176, checked_177, checked_178, checked_179, checked_180, checked_181, checked_182, checked_183, checked_184, checked_185, checked_186, checked_187, checked_188, checked_189, checked_190, checked_191, checked_192, checked_193, checked_194, checked_195, checked_196, checked_197, checked_198, checked_199, checked_200, checked_201, checked_202, checked_203, checked_204, checked_205, checked_206, checked_207, checked_208, checked_209, checked_210, checked_211, checked_212, checked_213, checked_214, checked_215, checked_216, checked_217, checked_218, checked_219, checked_220, checked_221, checked_222, checked_223, checked_224, checked_225, checked_226, checked_227, checked_228, checked_229, checked_230, checked_231, checked_232, checked_233, checked_234, checked_235, checked_236, checked_237, checked_238, checked_239, checked_240, checked_241, checked_242, checked_243, checked_244, checked_245, checked_246, checked_247, checked_248, checked_249, checked_250, checked_251, checked_252, checked_253, checked_254, checked_255, checked_256, checked_257, checked_258, checked_259, checked_260, checked_261, checked_262, checked_263, checked_264, checked_265, checked_266, checked_267, checked_268, checked_269, checked_270, checked_271, checked_272, checked_273, checked_274, checked_275, checked_276, checked_277, checked_278, checked_279, checked_280, checked_281, checked_282, checked_283, checked_284, checked_285, checked_286, checked_287, checked_288, checked_289, checked_290, checked_291, checked_292, checked_293, checked_294, checked_295, checked_296, checked_297, checked_298, checked_299, checked_300, checked_301, checked_302, checked_303, checked_304, checked_305, checked_306, checked_307, checked_308, checked_309, checked_310, checked_311, checked_312, checked_313, checked_314, checked_315, checked_316, checked_317, checked_318, checked_319, checked_320, checked_321, checked_322, checked_323, checked_324, checked_325, checked_326, checked_327, checked_328, checked_329, checked_330, checked_331, checked_332, checked_333, checked_334, checked_335, checked_336, checked_337, checked_338, checked_339, checked_340, checked_341, checked_342, checked_343, checked_344, checked_345, checked_346, checked_347, checked_348, checked_349, checked_350, checked_351, checked_352, checked_353, checked_354, checked_355, checked_356, checked_357, checked_358, checked_359, checked_360, checked_361, checked_362, checked_363, checked_364, checked_365, checked_366, checked_367, checked_368, checked_369, checked_370, checked_371, checked_372, checked_373, checked_374, checked_375, checked_376, checked_377, checked_378, checked_379, checked_380, checked_381, checked_382, checked_383, checked_384, checked_385, checked_386, checked_387, checked_388, checked_389, checked_390, checked_391, checked_392, checked_393, checked_394, checked_395, checked_396, checked_397, checked_398, checked_399, checked_400, checked_401, checked_402, checked_403, checked_404, checked_405, checked_406, checked_407, checked_408, checked_409, checked_410, checked_411, checked_412, checked_413, checked_414, checked_415, checked_416, checked_417, checked_418, checked_419, checked_420, checked_421, checked_422, checked_423, checked_424, checked_425, checked_426, checked_427, checked_428, checked_429, checked_430, checked_431, checked_432, checked_433, checked_434, checked_435, checked_436, checked_437, checked_438, checked_439, checked_440, checked_441, checked_442, checked_443, checked_444, checked_445, checked_446, checked_447, checked_448, checked_449, checked_450, checked_451, checked_452, checked_453, checked_454, checked_455, checked_456, checked_457, checked_458, checked_459, checked_460, checked_461, checked_462, checked_463, checked_464, checked_465, checked_466, checked_467, checked_468, checked_469, checked_470, checked_471, checked_472, checked_473, checked_474, checked_475, checked_476, checked_477, checked_478, checked_479, checked_480, checked_481, checked_482, checked_483, checked_484, checked_485, checked_486, checked_487, checked_488, checked_489, checked_490, checked_491, checked_492, checked_493, checked_494, checked_495, checked_496, checked_497, checked_498, checked_499, checked_500, checked_501, checked_502, checked_503, checked_504, checked_505, checked_506, checked_507, checked_508, checked_509, checked_510, checked_511, checked_512, checked_513, checked_514, checked_515, checked_516, checked_517, checked_518, checked_519, checked_520, checked_521, checked_522, checked_523, checked_524, checked_525, checked_526, checked_527, checked_528, checked_529, checked_530, checked_531, checked_532, checked_533, checked_534, checked_535, checked_536, checked_537, checked_538, checked_539, checked_540, checked_541, checked_542, checked_543, checked_544, checked_545, checked_546, checked_547, checked_548, checked_549, checked_550, checked_551, checked_552, checked_553, checked_554, checked_555, checked_556, checked_557, checked_558, checked_559, checked_560, checked_561, checked_562, checked_563, checked_564, checked_565, checked_566, checked_567, checked_568, checked_569, checked_570, checked_571, checked_572, checked_573, checked_574, checked_575, checked_576, checked_577, checked_578, checked_579, checked_580, checked_581, checked_582, checked_583, checked_584, checked_585, checked_586, checked_587, checked_588, checked_589, checked_590, checked_591, checked_592, checked_593, checked_594, checked_595, checked_596, checked_597, checked_598, checked_599, checked_600, checked_601, checked_602, checked_603, checked_604, checked_605, checked_606, checked_607, checked_608, checked_609, checked_610, checked_611, checked_612, checked_613, checked_614, checked_615, checked_616, checked_617, checked_618, checked_619, checked_620, checked_621, checked_622, checked_623, checked_624, checked_625, checked_626, checked_627, checked_628, checked_629, checked_630, checked_631, checked_632, checked_633, checked_634, checked_635, checked_636, checked_637, checked_638, checked_639, checked_640, checked_641, checked_642, checked_643, checked_644, checked_645, checked_646, checked_647, checked_648, checked_649, checked_650, checked_651, checked_652, checked_653, checked_654, checked_655, checked_656, checked_657, checked_658, checked_659, checked_660, checked_661, checked_662, checked_663, checked_664, checked_665, checked_666, checked_667, checked_668, checked_669, checked_670, checked_671, checked_672, checked_673, checked_674, checked_675, checked_676, checked_677, checked_678, checked_679, checked_680, checked_681, checked_682, checked_683, checked_684, checked_685, checked_686, checked_687, checked_688, checked_689, checked_690, checked_691, checked_692, checked_693, checked_694, checked_695, checked_696, checked_697, checked_698, checked_699, checked_700, checked_701, checked_702, checked_703, checked_704, checked_705, checked_706, checked_707, checked_708, checked_709, checked_710, checked_711, checked_712, checked_713, checked_714, checked_715, checked_716, checked_717, checked_718, checked_719, checked_720, checked_721, checked_722, checked_723, checked_724, checked_725, checked_726, checked_727] +theorem numberedCards_size : numberedCards.size = 728 := by decide +kernel +def numberedCard (i : Fin 728) : CheckedCard := + numberedCards[i.val]'(by rw [numberedCards_size]; exact i.isLt) +theorem numbered_cards_valid (i : Fin 728) : + Template HasSnaky (numberedCard i).height (numberedCard i).required (numberedCard i).envelope := + (numberedCard i).works +theorem numbered_cards_standing_conditions (i : Fin 728) : + (numberedCard i).required ⊆ (numberedCard i).envelope ∧ + 1 ≤ (numberedCard i).height ∧ (numberedCard i).height ≤ 21 := + ⟨(numberedCard i).required_sub_envelope, (numberedCard i).height_positive, + (numberedCard i).height_le_twenty_one⟩ +theorem final_card_data : + (numberedCard 727).required = ∅ ∧ + (numberedCard 727).envelope.card = 251 ∧ + (numberedCard 727).height = 21 := by decide +kernel +theorem final_envelope_card : envelope_727.card = 251 := by decide +kernel +theorem final_children_requirements : + ∀ j, childrenC_727 j = {(8, 8)} := by decide +kernel +theorem final_children_intersection : + commonEnvelope childrenD_727 = {(8, 8)} := by + apply Finset.Subset.antisymm + · simpa [required_727] using common_sub_727 + · intro b hb + obtain rfl := Finset.mem_singleton.mp hb + exact mem_commonEnvelope _ (8, 8) (by decide +kernel) +theorem final_group_data : + (required_648 = {(4, 5)} ∧ envelope_648.card = 87 ∧ height_648 = 15) ∧ + (required_708 = {(8, 8)} ∧ envelope_708.card = 225 ∧ height_708 = 20) ∧ + (required_712 = {(5, 5)} ∧ envelope_712.card = 96 ∧ height_712 = 15) ∧ + (required_713 = {(5, 5)} ∧ envelope_713.card = 98 ∧ height_713 = 15) ∧ + (required_725 = {(7, 7)} ∧ envelope_725.card = 167 ∧ height_725 = 20) ∧ + (required_726 = {(7, 7)} ∧ envelope_726.card = 169 ∧ height_726 = 20) := by + decide +kernel +def finalPrefixIntersection (k : ℕ) : Finset Cell := + (childrenD_727 0).filter (fun b => ∀ j : Fin 32, j.val < k → b ∈ childrenD_727 j) +theorem final_prefix_count_4 : ((finalPrefixIntersection 4).erase (8, 8)).card = 35 := by decide +kernel +theorem final_prefix_count_8 : ((finalPrefixIntersection 8).erase (8, 8)).card = 31 := by decide +kernel +theorem final_prefix_count_16 : ((finalPrefixIntersection 16).erase (8, 8)).card = 21 := by decide +kernel +theorem final_prefix_count_20 : ((finalPrefixIntersection 20).erase (8, 8)).card = 12 := by decide +kernel +theorem final_prefix_count_28 : ((finalPrefixIntersection 28).erase (8, 8)).card = 4 := by decide +kernel +theorem final_prefix_count_32 : ((finalPrefixIntersection 32).erase (8, 8)).card = 0 := by decide +kernel +theorem numbered_line_count : numberedCards.size - 6 = 722 := by + rw [numberedCards_size] +theorem current_certificate_verified : + numberedCards.size = 728 ∧ + (∀ i : Fin 728, + (numberedCard i).required ⊆ (numberedCard i).envelope ∧ + 1 ≤ (numberedCard i).height ∧ (numberedCard i).height ≤ 21 ∧ + Template HasSnaky (numberedCard i).height + (numberedCard i).required (numberedCard i).envelope) ∧ + (numberedCard 727).required = ∅ ∧ + (numberedCard 727).envelope.card = 251 ∧ + (numberedCard 727).height = 21 := by + refine ⟨numberedCards_size, ?_, final_card_data⟩ + intro i + obtain ⟨hsub, hpos, hle⟩ := numbered_cards_standing_conditions i + exact ⟨hsub, hpos, hle, numbered_cards_valid i⟩ +end SnakyPrototype.Certificate21 + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Main.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Main.lean new file mode 100644 index 0000000..88f3c5a --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Main.lean @@ -0,0 +1,49 @@ +import OAI.GameTheory.SnakyTwentyOne.Cards.Height21Part01 +import OAI.GameTheory.SnakyTwentyOne.Certificate.Summary +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game +import OAI.GameTheory.SnakyTwentyOne.Semantics.Geometry +import OAI.GameTheory.SnakyTwentyOne.Semantics.Policy +import OAI.GameTheory.SnakyTwentyOne.Semantics.Replies + +namespace OAI + +namespace SnakyPrototype +theorem empty_board_wins_21 : WinsIn HasSnaky 21 ∅ ∅ := by + exact Certificate21.row_works_727 ∅ ∅ (by simp) + (by simp [Certificate21.required_727]) (by simp) +end SnakyPrototype +namespace SnakyPrototype +open OrdinaryStrategy +theorem snaky_winning_strategy_21_with_legal_states : + ∃ σ : Policy Cell, + (∀ r M B, σ r M B ∉ M ∧ σ r M B ∉ B) ∧ + ∀ β : ℕ → Cell, LegalRepliesBeforeFinal σ 21 β ∅ ∅ → + HasSnaky (playState σ 21 β ∅ ∅ 21).1 ∧ + (playState σ 21 β ∅ ∅ 21).1.card = 21 ∧ + Disjoint (playState σ 21 β ∅ ∅ 21).1 (playState σ 21 β ∅ ∅ 20).2 ∧ + ∀ k, k < 21 → + Disjoint (playState σ 21 β ∅ ∅ k).1 (playState σ 21 β ∅ ∅ k).2 ∧ + (playState σ 21 β ∅ ∅ k).2.card = k := by + refine ⟨policy HasSnaky, policy_fresh HasSnaky, ?_⟩ + intro β hβ + refine ⟨policy_wins (fun M N hMN hw => HasSnaky.mono hw hMN) + 21 β ∅ ∅ empty_board_wins_21 hβ, ?_, ?_, ?_⟩ + · simpa using playState_maker_card (policy HasSnaky) (policy_fresh HasSnaky) + 21 β ∅ ∅ 21 + · exact final_maker_disjoint (policy HasSnaky) (policy_fresh HasSnaky) + 20 β ∅ ∅ (by simp) hβ + · intro k hk + simpa using playState_legal_prefix (policy HasSnaky) (policy_fresh HasSnaky) + 21 β ∅ ∅ (by simp) hβ k hk +theorem snaky_winning_strategy_21 : + ∃ σ : Policy Cell, + (∀ r M B, σ r M B ∉ M ∧ σ r M B ∉ B) ∧ + ∀ β : ℕ → Cell, + LegalRepliesBeforeFinal σ 21 β ∅ ∅ → + HasSnaky (playState σ 21 β ∅ ∅ 21).1 := by + obtain ⟨σ, hσ, hw⟩ := snaky_winning_strategy_21_with_legal_states + exact ⟨σ, hσ, fun β hβ => (hw β hβ).1⟩ +end SnakyPrototype + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Model.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Model.lean new file mode 100644 index 0000000..bba3eae --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Model.lean @@ -0,0 +1,42 @@ +import Mathlib + +namespace OAI + +namespace SnakyPrototype +variable {α : Type*} [DecidableEq α] +abbrev Cell := ℤ × ℤ +def snaky : Finset Cell := {(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)} +def orient (r : Fin 8) (p : Cell) : Cell := + match r.val with + | 0 => (p.1, p.2) + | 1 => (p.2, p.1) + | 2 => (p.1, -p.2) + | 3 => (-p.2, p.1) + | 4 => (-p.1, p.2) + | 5 => (p.2, -p.1) + | 6 => (-p.1, -p.2) + | _ => (-p.2, -p.1) +def placement (r : Fin 8) (t p : Cell) : Cell := orient r p + t +def HasSnaky (M : Finset Cell) : Prop := + ∃ (r : Fin 8) (t : Cell), snaky.image (placement r t) ⊆ M +end SnakyPrototype +namespace SnakyPrototype.OrdinaryStrategy +variable {α : Type*} [DecidableEq α] [Infinite α] +abbrev Policy (α : Type*) := ℕ → Finset α → Finset α → α +def playState (σ : Policy α) (N : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) : + ℕ → Finset α × Finset α + | 0 => (M₀, B₀) + | k + 1 => + let state := playState σ N β M₀ B₀ k + (insert (σ (N - k) state.1 state.2) state.1, insert (β k) state.2) +def makerAt (σ : Policy α) (N : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) (k : ℕ) : α := + let state := playState σ N β M₀ B₀ k + σ (N - k) state.1 state.2 +def LegalRepliesBeforeFinal (σ : Policy α) (N : ℕ) (β : ℕ → α) + (M₀ B₀ : Finset α) : Prop := + ∀ k, k + 1 < N → + β k ∉ insert (makerAt σ N β M₀ B₀ k) (playState σ N β M₀ B₀ k).1 ∧ + β k ∉ (playState σ N β M₀ B₀ k).2 +end SnakyPrototype.OrdinaryStrategy + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Game.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Game.lean new file mode 100644 index 0000000..7baa698 --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Game.lean @@ -0,0 +1,194 @@ +import OAI.GameTheory.SnakyTwentyOne.Model + +namespace OAI + +namespace SnakyPrototype +variable {α : Type*} [DecidableEq α] +inductive WinsIn (win : Finset α → Prop) : ℕ → Finset α → Finset α → Prop + | done {n M B} : win M → WinsIn win n M B + | move {n M B} (x : α) (hxM : x ∉ M) (hxB : x ∉ B) + (next : ∀ b, b ∉ insert x M → b ∉ B → + WinsIn win n (insert x M) (insert b B)) : + WinsIn win (n + 1) M B +theorem WinsIn.weaken {win : Finset α → Prop} {n : ℕ} {M B : Finset α} + (h : WinsIn win n M B) : ∀ k, WinsIn win (n + k) M B := by + induction h with + | done hw => + intro k + exact WinsIn.done hw + | @move n M B x hxM hxB next ih => + intro k + simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using + (WinsIn.move x hxM hxB (fun b hbM hbB => ih b hbM hbB k)) +theorem WinsIn.mono {win : Finset α → Prop} {n m : ℕ} {M B : Finset α} + (h : WinsIn win n M B) (hnm : n ≤ m) : WinsIn win m M B := by + obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hnm + exact h.weaken k +def Template (win : Finset α → Prop) (n : ℕ) (A H : Finset α) : Prop := + ∀ M B, Disjoint M B → A ⊆ M → Disjoint B H → WinsIn win n M B +theorem WinsIn.transport {win : Finset α → Prop} {n : ℕ} {M B : Finset α} + (h : WinsIn win n M B) (e : α ≃ α) + (hwin : ∀ X, win X → win (X.image e)) : + WinsIn win n (M.image e) (B.image e) := by + induction h with + | done hw => exact WinsIn.done (hwin _ hw) + | @move n M B x hxM hxB next ih => + apply WinsIn.move (e x) + · intro hx + obtain ⟨y, hy, he⟩ := Finset.mem_image.mp hx + exact hxM (e.injective he ▸ hy) + · intro hx + obtain ⟨y, hy, he⟩ := Finset.mem_image.mp hx + exact hxB (e.injective he ▸ hy) + · intro b hbM hbB + have hbM' : e.symm b ∉ insert x M := by + intro hb + apply hbM + simpa [Finset.image_insert] using Finset.mem_image_of_mem e hb + have hbB' : e.symm b ∉ B := by + intro hb + apply hbB + simpa using Finset.mem_image_of_mem e hb + simpa [Finset.image_insert] using ih (e.symm b) hbM' hbB' +theorem Template.mono {win : Finset α → Prop} {n m : ℕ} {A H : Finset α} + (h : Template win n A H) (hnm : n ≤ m) : Template win m A H := by + intro M B hMB hAM hBH + exact (h M B hMB hAM hBH).mono hnm +theorem Template.transport {win : Finset α → Prop} {n : ℕ} {A H : Finset α} + (h : Template win n A H) (e : α ≃ α) + (hwin : ∀ X, win X → win (X.image e)) : + Template win n (A.image e) (H.image e) := by + intro M B hMB hAM hBH + have hMB' : Disjoint (M.image e.symm) (B.image e.symm) := by + refine Finset.disjoint_left.mpr ?_ + intro z hzM hzB + obtain ⟨x, hx, hxe⟩ := Finset.mem_image.mp hzM + obtain ⟨y, hy, hye⟩ := Finset.mem_image.mp hzB + have hxy : x = y := e.symm.injective (hxe.trans hye.symm) + exact Finset.disjoint_left.mp hMB hx (hxy.symm ▸ hy) + have hAM' : A ⊆ M.image e.symm := by + intro z hz + exact Finset.mem_image.mpr ⟨e z, hAM (Finset.mem_image_of_mem e hz), by simp⟩ + have hBH' : Disjoint (B.image e.symm) H := by + refine Finset.disjoint_left.mpr ?_ + intro z hzB hzH + obtain ⟨x, hx, he⟩ := Finset.mem_image.mp hzB + have hxH : x ∈ H.image e := by + exact Finset.mem_image.mpr ⟨z, hzH, by rw [← he]; simp⟩ + exact Finset.disjoint_left.mp hBH hx hxH + have h' := (h (M.image e.symm) (B.image e.symm) hMB' hAM' hBH').transport e hwin + simpa [Finset.image_image, Function.comp_def] using h' +theorem immediate_template (win : Finset α → Prop) (H : Finset α) (pivot : α) + (hp : pivot ∈ H) (hwin : ∀ M, H ⊆ M → win M) : + Template win 1 (H.erase pivot) H := by + intro M B _ hAM hBH + have hsub : H ⊆ insert pivot M := by + intro y hy + by_cases hyp : y = pivot + · simp [hyp] + · exact Finset.mem_insert_of_mem (hAM (Finset.mem_erase.mpr ⟨hyp, hy⟩)) + by_cases hpM : pivot ∈ M + · exact WinsIn.done (hwin M (by simpa [Finset.insert_eq_of_mem hpM] using hsub)) + · apply WinsIn.move pivot hpM + · exact fun hpB => Finset.disjoint_left.mp hBH hpB hp + · intro b _ _ + exact WinsIn.done (hwin (insert pivot M) hsub) +theorem surviving_child {ι : Type*} [Nonempty ι] + (C D : ι → Finset α) (M B H : Finset α) + (hC : ∀ j, C j ⊆ M) (hD : ∀ j, D j ⊆ H) + (hcommon : ∀ b, (∀ j, b ∈ D j) → b ∈ M) + (hBH : Disjoint B H) (b : α) (hbM : b ∉ M) : + ∃ j, C j ⊆ M ∧ Disjoint (insert b B) (D j) := by + classical + have hex : ∃ j, b ∉ D j := by + by_contra h + push Not at h + exact hbM (hcommon b h) + obtain ⟨j, hj⟩ := hex + refine ⟨j, hC j, Finset.disjoint_left.mpr ?_⟩ + intro x hx hxd + rcases Finset.mem_insert.mp hx with hxb | hxB + · subst x + exact hj hxd + · exact Finset.disjoint_left.mp hBH hxB (hD j hxd) +theorem legal_pivot_or_replacement [Infinite α] + (pivot : α) (M B : Finset α) (hpB : pivot ∉ B) : + ∃ x, x ∉ M ∧ x ∉ B ∧ pivot ∈ insert x M := by + classical + by_cases hpM : pivot ∈ M + · obtain ⟨x, hx⟩ := (M ∪ B).exists_notMem + refine ⟨x, ?_, ?_, Finset.mem_insert_of_mem hpM⟩ + · exact fun hxM => hx (Finset.mem_union_left B hxM) + · exact fun hxB => hx (Finset.mem_union_right M hxB) + · exact ⟨pivot, hpM, hpB, Finset.mem_insert_self pivot M⟩ +theorem breaker_turn {ι : Type*} [Nonempty ι] + (win : Finset α → Prop) (n : ℕ) (C D : ι → Finset α) + (hchild : ∀ j, Template win n (C j) (D j)) + (M B H : Finset α) (hMB : Disjoint M B) + (hC : ∀ j, C j ⊆ M) (hD : ∀ j, D j ⊆ H) + (hcommon : ∀ b, (∀ j, b ∈ D j) → b ∈ M) + (hBH : Disjoint B H) : + ∀ b, b ∉ M → b ∉ B → WinsIn win n M (insert b B) := by + intro b hbM _ + obtain ⟨j, hjC, hjD⟩ := surviving_child C D M B H hC hD hcommon hBH b hbM + apply hchild j M (insert b B) _ hjC hjD + refine Finset.disjoint_left.mpr ?_ + intro x hxM hxB + rcases Finset.mem_insert.mp hxB with hxb | hxB + · subst x + exact hbM hxM + · exact Finset.disjoint_left.mp hMB hxM hxB +theorem compose [Infinite α] {ι : Type*} [Nonempty ι] + (win : Finset α → Prop) (n : ℕ) (C D : ι → Finset α) + (hchild : ∀ j, Template win n (C j) (D j)) + (pivot : α) (A H : Finset α) (hpH : pivot ∈ H) + (hC : ∀ j, C j ⊆ insert pivot A) + (hD : ∀ j, D j ⊆ H) + (hcommon : ∀ b, (∀ j, b ∈ D j) → b ∈ insert pivot A) : + Template win (n + 1) A H := by + intro M B hMB hAM hBH + have hpB : pivot ∉ B := fun hp => Finset.disjoint_left.mp hBH hp hpH + obtain ⟨x, hxM, hxB, hpx⟩ := legal_pivot_or_replacement pivot M B hpB + have howned : insert pivot A ⊆ insert x M := by + intro y hy + rcases Finset.mem_insert.mp hy with hyp | hyA + · subst y + exact hpx + · exact Finset.mem_insert_of_mem (hAM hyA) + have hMB' : Disjoint (insert x M) B := by + refine Finset.disjoint_left.mpr ?_ + intro y hy hyB + rcases Finset.mem_insert.mp hy with hyx | hyM + · subst y + exact hxB hyB + · exact Finset.disjoint_left.mp hMB hyM hyB + apply WinsIn.move x hxM hxB + exact breaker_turn win n C D hchild (insert x M) B H hMB' + (fun j => (hC j).trans howned) hD + (fun b hb => howned (hcommon b hb)) hBH +theorem one_stone_after_distant_reply {ι : Type*} [Nonempty ι] + (win : Finset α → Prop) (n : ℕ) (o : α) (N : Finset α) + (D : ι → Finset α) + (hchild : ∀ j, Template win n {o} (D j)) + (hcommon : ∀ q, (∀ j, q ∈ D j) → q ∈ N) + (q : α) (hqo : q ≠ o) (hqN : q ∉ N) : + WinsIn win n {o} {q} := by + classical + have hex : ∃ j, q ∉ D j := by + by_contra h + push Not at h + exact hqN (hcommon q h) + obtain ⟨j, hj⟩ := hex + apply hchild j {o} {q} + · simpa [Finset.disjoint_singleton_left, eq_comm] using hqo + · exact Finset.Subset.refl _ + · exact Finset.disjoint_singleton_left.mpr hj +theorem from_first_reply (win : Finset α → Prop) (n : ℕ) (o : α) + (h : ∀ q, q ≠ o → WinsIn win n {o} {q}) : + WinsIn win (n + 1) ∅ ∅ := by + apply WinsIn.move o (by simp) (by simp) + intro q hq _ + simpa using h q (by simpa using hq) +end SnakyPrototype + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Geometry.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Geometry.lean new file mode 100644 index 0000000..5f94d6c --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Geometry.lean @@ -0,0 +1,83 @@ +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype +variable {α : Type*} [DecidableEq α] +def inverseOrientation (r : Fin 8) : Fin 8 := + if r = 3 then 5 else if r = 5 then 3 else r +theorem orient_inverse_left (r : Fin 8) (p : Cell) : + orient (inverseOrientation r) (orient r p) = p := by + fin_cases r <;> rcases p with ⟨x, y⟩ <;> simp [orient, inverseOrientation] +theorem orient_inverse_right (r : Fin 8) (p : Cell) : + orient r (orient (inverseOrientation r) p) = p := by + fin_cases r <;> rcases p with ⟨x, y⟩ <;> simp [orient, inverseOrientation] +def orientationEquiv (r : Fin 8) : Cell ≃ Cell where + toFun := orient r + invFun := orient (inverseOrientation r) + left_inv := orient_inverse_left r + right_inv := orient_inverse_right r +def translationEquiv (t : Cell) : Cell ≃ Cell where + toFun := fun p => p + t + invFun := fun p => p - t + left_inv := fun p => add_sub_cancel_right p t + right_inv := fun p => sub_add_cancel p t +def placementEquiv (r : Fin 8) (t : Cell) : Cell ≃ Cell := + (orientationEquiv r).trans (translationEquiv t) +@[simp] theorem placementEquiv_apply (r : Fin 8) (t p : Cell) : + placementEquiv r t p = placement r t p := rfl +@[simp] theorem coe_placementEquiv (r : Fin 8) (t : Cell) : + (placementEquiv r t : Cell → Cell) = placement r t := rfl +def composeOrientation (r s : Fin 8) : Fin 8 := + ![![0,1,2,3,4,5,6,7], ![1,0,3,2,5,4,7,6], + ![2,5,0,7,6,1,4,3], ![3,4,1,6,7,0,5,2], + ![4,3,6,1,0,7,2,5], ![5,2,7,0,1,6,3,4], + ![6,7,4,5,2,3,0,1], ![7,6,5,4,3,2,1,0]] r s +theorem orient_comp (r s : Fin 8) (p : Cell) : + orient r (orient s p) = orient (composeOrientation r s) p := by + fin_cases r <;> fin_cases s <;> rcases p with ⟨x, y⟩ <;> + simp [orient, composeOrientation] +theorem orient_add (r : Fin 8) (p q : Cell) : + orient r (p + q) = orient r p + orient r q := by + fin_cases r <;> rcases p with ⟨x, y⟩ <;> rcases q with ⟨u, v⟩ <;> + simp [orient, add_comm] +theorem placement_comp (r s : Fin 8) (t u p : Cell) : + placement r t (placement s u p) = + placement (composeOrientation r s) (orient r u + t) p := by + simp only [placement, orient_add, orient_comp, add_assoc] +theorem HasSnaky.mono {M N : Finset Cell} (h : HasSnaky M) (hMN : M ⊆ N) : + HasSnaky N := by + obtain ⟨r, t, hrt⟩ := h + exact ⟨r, t, hrt.trans hMN⟩ +theorem HasSnaky.placed (r : Fin 8) (t : Cell) (M : Finset Cell) + (h : HasSnaky M) : HasSnaky (M.image (placement r t)) := by + obtain ⟨s, u, hsu⟩ := h + refine ⟨composeOrientation r s, orient r u + t, ?_⟩ + intro z hz + obtain ⟨p, hp, hpz⟩ := Finset.mem_image.mp hz + refine Finset.mem_image.mpr ⟨placement s u p, + hsu (Finset.mem_image_of_mem (placement s u) hp), ?_⟩ + exact (placement_comp r s t u p).trans hpz +theorem placed_template {n : ℕ} {A H : Finset Cell} + (h : Template HasSnaky n A H) (r : Fin 8) (t : Cell) : + Template HasSnaky n (A.image (placement r t)) (H.image (placement r t)) := by + have hw : ∀ X, HasSnaky X → HasSnaky (X.image (placementEquiv r t)) := by + intro X hx + simpa only [coe_placementEquiv] using HasSnaky.placed r t X hx + simpa only [coe_placementEquiv] using h.transport (placementEquiv r t) hw +def basePoint (i : Fin 6) : Cell := ![(0,0),(1,0),(2,0),(3,0),(3,1),(4,1)] i +def baseEnvelope (i : Fin 6) : Finset Cell := + snaky.image (placement 0 (-basePoint i)) +def baseRequired (i : Fin 6) : Finset Cell := (baseEnvelope i).erase (0, 0) +theorem basePoint_mem (i : Fin 6) : basePoint i ∈ snaky := by + fin_cases i <;> decide +theorem base_works (i : Fin 6) : + Template HasSnaky 1 (baseRequired i) (baseEnvelope i) := by + apply immediate_template HasSnaky (baseEnvelope i) (0, 0) + · exact Finset.mem_image.mpr ⟨basePoint i, basePoint_mem i, by simp [placement, orient]; rfl⟩ + · intro M hM + exact ⟨0, -basePoint i, hM⟩ +end SnakyPrototype + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Policy.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Policy.lean new file mode 100644 index 0000000..fb88d0a --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Policy.lean @@ -0,0 +1,176 @@ +import OAI.GameTheory.SnakyTwentyOne.Model +import OAI.GameTheory.SnakyTwentyOne.Semantics.Game + +namespace OAI + +namespace SnakyPrototype.OrdinaryStrategy +variable {α : Type*} [DecidableEq α] [Infinite α] +def GoodMove (win : Finset α → Prop) (nextBudget : ℕ) + (M B : Finset α) (x : α) : Prop := + x ∉ M ∧ x ∉ B ∧ ∀ b, b ∉ insert x M → b ∉ B → + WinsIn win nextBudget (insert x M) (insert b B) +omit [Infinite α] in +theorem winsIn_zero_iff {win : Finset α → Prop} {M B : Finset α} : + WinsIn win 0 M B ↔ win M := by + constructor + · intro h; cases h with | done hw => exact hw + · exact WinsIn.done +theorem exists_good_move {win : Finset α → Prop} + (hmono : ∀ M N, M ⊆ N → win M → win N) + {n : ℕ} {M B : Finset α} (h : WinsIn win (n + 1) M B) : + ∃ x, GoodMove win n M B x := by + cases h with + | done hw => + obtain ⟨x, hx⟩ := (M ∪ B).exists_notMem + refine ⟨x, ?_, ?_, ?_⟩ + · exact fun hxM => hx (Finset.mem_union_left B hxM) + · exact fun hxB => hx (Finset.mem_union_right M hxB) + · intro b _ _ + exact WinsIn.done (hmono M (insert x M) (Finset.subset_insert x M) hw) + | move x hxM hxB next => exact ⟨x, hxM, hxB, next⟩ +noncomputable def policy (win : Finset α → Prop) (r : ℕ) (M B : Finset α) : α := by + classical + exact if h : ∃ x, GoodMove win (r - 1) M B x then Classical.choose h + else Classical.choose ((M ∪ B).exists_notMem) +theorem policy_fresh (win : Finset α → Prop) (r : ℕ) (M B : Finset α) : + policy win r M B ∉ M ∧ policy win r M B ∉ B := by + classical + unfold policy + split_ifs with h + · exact ⟨(Classical.choose_spec h).1, (Classical.choose_spec h).2.1⟩ + · have hx := Classical.choose_spec ((M ∪ B).exists_notMem) + exact ⟨fun hxM => hx (Finset.mem_union_left B hxM), + fun hxB => hx (Finset.mem_union_right M hxB)⟩ +theorem policy_good {win : Finset α → Prop} + (hmono : ∀ M N, M ⊆ N → win M → win N) + {n : ℕ} {M B : Finset α} (h : WinsIn win (n + 1) M B) : + GoodMove win n M B (policy win (n + 1) M B) := by + classical + have hex := exists_good_move hmono h + unfold policy + simp only [Nat.add_sub_cancel] + rw [dite_eq_left hex] + exact Classical.choose_spec hex +theorem policy_last_move_wins {win : Finset α → Prop} + (hmono : ∀ M N, M ⊆ N → win M → win N) + {M B : Finset α} (h : WinsIn win 1 M B) : + win (insert (policy win 1 M B) M) := by + have hg := policy_good hmono h + obtain ⟨b, hb⟩ := ((insert (policy win 1 M B) M) ∪ B).exists_notMem + apply winsIn_zero_iff.mp + exact hg.2.2 b + (fun hbM => hb (Finset.mem_union_left B hbM)) + (fun hbB => hb (Finset.mem_union_right _ hbB)) +omit [Infinite α] in +theorem disjoint_after_round {M B : Finset α} {x b : α} + (hMB : Disjoint M B) (hxB : x ∉ B) (hbM : b ∉ insert x M) : + Disjoint (insert x M) (insert b B) := by + refine Finset.disjoint_left.mpr ?_ + intro y hyM hyB + rcases Finset.mem_insert.mp hyM with rfl | hyM + · rcases Finset.mem_insert.mp hyB with rfl | hx + · exact hbM (Finset.mem_insert_self _ _) + · exact hxB hx + · rcases Finset.mem_insert.mp hyB with rfl | hyB + · exact hbM (Finset.mem_insert_of_mem hyM) + · exact Finset.disjoint_left.mp hMB hyM hyB +omit [Infinite α] in +theorem playState_maker_card (σ : Policy α) + (hfresh : ∀ r M B, σ r M B ∉ M ∧ σ r M B ∉ B) + (N : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) : + ∀ k, (playState σ N β M₀ B₀ k).1.card = M₀.card + k := by + intro k + induction k with + | zero => simp [playState] + | succ k ih => + change (insert (σ (N - k) (playState σ N β M₀ B₀ k).1 + (playState σ N β M₀ B₀ k).2) (playState σ N β M₀ B₀ k).1).card = _ + rw [Finset.card_insert_of_notMem (hfresh _ _ _).1, ih] + omega +omit [Infinite α] in +theorem playState_legal_prefix (σ : Policy α) + (hfresh : ∀ r M B, σ r M B ∉ M ∧ σ r M B ∉ B) + (N : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) + (h₀ : Disjoint M₀ B₀) (hβ : LegalRepliesBeforeFinal σ N β M₀ B₀) : + ∀ k, k < N → Disjoint (playState σ N β M₀ B₀ k).1 + (playState σ N β M₀ B₀ k).2 ∧ + (playState σ N β M₀ B₀ k).2.card = B₀.card + k := by + intro k + induction k with + | zero => intro _; exact ⟨h₀, by simp [playState]⟩ + | succ k ih => + intro hk + obtain ⟨hi, hc⟩ := ih (by omega) + obtain ⟨hbM, hbB⟩ := hβ k hk + constructor + · exact disjoint_after_round hi (hfresh _ _ _).2 hbM + · change (insert (β k) (playState σ N β M₀ B₀ k).2).card = _ + rw [Finset.card_insert_of_notMem hbB, hc] + omega +omit [Infinite α] in + + +theorem final_maker_disjoint (σ : Policy α) + (hfresh : ∀ r M B, σ r M B ∉ M ∧ σ r M B ∉ B) + (n : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) + (h₀ : Disjoint M₀ B₀) (hβ : LegalRepliesBeforeFinal σ (n + 1) β M₀ B₀) : + Disjoint (playState σ (n + 1) β M₀ B₀ (n + 1)).1 + (playState σ (n + 1) β M₀ B₀ n).2 := by + have hi := (playState_legal_prefix σ hfresh (n + 1) β M₀ B₀ h₀ hβ n (by omega)).1 + change Disjoint (insert (σ ((n + 1) - n) (playState σ (n + 1) β M₀ B₀ n).1 + (playState σ (n + 1) β M₀ B₀ n).2) (playState σ (n + 1) β M₀ B₀ n).1) + (playState σ (n + 1) β M₀ B₀ n).2 + exact Finset.disjoint_insert_left.mpr ⟨(hfresh _ _ _).2, hi⟩ +theorem policy_wins_round_invariant {win : Finset α → Prop} + (hmono : ∀ M N, M ⊆ N → win M → win N) + (N : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) + (hstart : WinsIn win N M₀ B₀) + (hβ : LegalRepliesBeforeFinal (policy win) N β M₀ B₀) : + ∀ k, k < N → WinsIn win (N - k) + (playState (policy win) N β M₀ B₀ k).1 + (playState (policy win) N β M₀ B₀ k).2 := by + intro k + induction k with + | zero => intro _; simpa [playState] using hstart + | succ k ih => + intro hk + have ih' := ih (by omega) + have hbudget : N - k = (N - (k + 1)) + 1 := by omega + rw [hbudget] at ih' + have hg := policy_good hmono ih' + obtain ⟨hbM, hbB⟩ := hβ k hk + have hstep := hg.2.2 (β k) + have hx : policy win ((N - (k + 1)) + 1) + (playState (policy win) N β M₀ B₀ k).1 + (playState (policy win) N β M₀ B₀ k).2 = + makerAt (policy win) N β M₀ B₀ k := by + simp only [makerAt, hbudget] + rw [hx] at hstep + simpa only [playState, makerAt] using hstep hbM hbB +theorem policy_wins {win : Finset α → Prop} + (hmono : ∀ M N, M ⊆ N → win M → win N) + (N : ℕ) (β : ℕ → α) (M₀ B₀ : Finset α) + (hstart : WinsIn win N M₀ B₀) + (hβ : LegalRepliesBeforeFinal (policy win) N β M₀ B₀) : + win (playState (policy win) N β M₀ B₀ N).1 := by + cases N with + | zero => exact winsIn_zero_iff.mp hstart + | succ n => + have hi := policy_wins_round_invariant hmono (n + 1) β M₀ B₀ hstart hβ n (by omega) + have hi' : WinsIn win 1 (playState (policy win) (n + 1) β M₀ B₀ n).1 + (playState (policy win) (n + 1) β M₀ B₀ n).2 := by simpa using hi + have hw := policy_last_move_wins hmono hi' + simpa [playState] using hw +theorem winsIn_has_ordinary_policy {win : Finset α → Prop} + (hmono : ∀ M N, M ⊆ N → win M → win N) + {N : ℕ} {M₀ B₀ : Finset α} (hstart : WinsIn win N M₀ B₀) : + ∃ σ : Policy α, + (∀ r M B, σ r M B ∉ M ∧ σ r M B ∉ B) ∧ + ∀ β, LegalRepliesBeforeFinal σ N β M₀ B₀ → + win (playState σ N β M₀ B₀ N).1 := by + refine ⟨policy win, policy_fresh win, ?_⟩ + intro β hβ + exact policy_wins hmono N β M₀ B₀ hstart hβ +end SnakyPrototype.OrdinaryStrategy + +end OAI diff --git a/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Replies.lean b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Replies.lean new file mode 100644 index 0000000..9ab14ba --- /dev/null +++ b/lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Replies.lean @@ -0,0 +1,39 @@ +import OAI.GameTheory.SnakyTwentyOne.Model + +namespace OAI + +namespace SnakyPrototype.OrdinaryStrategy +variable {α : Type*} [DecidableEq α] [Infinite α] +noncomputable def freshReply (M B : Finset α) : α := + Classical.choose ((M ∪ B).exists_notMem) +theorem freshReply_not_owned (M B : Finset α) : + freshReply M B ∉ M ∧ freshReply M B ∉ B := by + have h := Classical.choose_spec ((M ∪ B).exists_notMem) + exact ⟨fun hM => h (Finset.mem_union_left B hM), + fun hB => h (Finset.mem_union_right M hB)⟩ +noncomputable def freshReplyState (σ : Policy α) (N : ℕ) (M₀ B₀ : Finset α) : + ℕ → Finset α × Finset α + | 0 => (M₀, B₀) + | k + 1 => + let state := freshReplyState σ N M₀ B₀ k + let M' := insert (σ (N - k) state.1 state.2) state.1 + (M', insert (freshReply M' state.2) state.2) +noncomputable def freshReplies (σ : Policy α) (N : ℕ) (M₀ B₀ : Finset α) + (k : ℕ) : α := + let state := freshReplyState σ N M₀ B₀ k + freshReply (insert (σ (N - k) state.1 state.2) state.1) state.2 +theorem playState_freshReplies (σ : Policy α) (N : ℕ) (M₀ B₀ : Finset α) (k : ℕ) : + playState σ N (freshReplies σ N M₀ B₀) M₀ B₀ k = + freshReplyState σ N M₀ B₀ k := by + induction k with + | zero => rfl + | succ k ih => simp only [playState, freshReplyState, ih, freshReplies] +theorem exists_legal_replies (σ : Policy α) (N : ℕ) (M₀ B₀ : Finset α) : + ∃ β, LegalRepliesBeforeFinal σ N β M₀ B₀ := by + refine ⟨freshReplies σ N M₀ B₀, ?_⟩ + intro k _ + simp only [makerAt, playState_freshReplies, freshReplies] + exact freshReply_not_owned _ _ +end SnakyPrototype.OrdinaryStrategy + +end OAI diff --git a/lean/snaky/SnakyBinding.lean b/lean/snaky/SnakyBinding.lean new file mode 100644 index 0000000..88c8a9d --- /dev/null +++ b/lean/snaky/SnakyBinding.lean @@ -0,0 +1,25 @@ +-- Generated by scripts/snaky_proof.py generate; checked without rewriting. +import SnakyFinite +namespace FiniteCongruenceChecks.SnakyFinite.Binding +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 +private def target : Finset Cell := ([(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)] : List Cell).toFinset +private def envelope : Finset Cell := ([(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (0, 9), (0, 10), (0, 11), (0, 12), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (2, 9), (2, 10), (2, 11), (2, 12), (2, 13), (2, 14), (2, 15), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (3, 10), (3, 11), (3, 12), (3, 13), (3, 14), (3, 15), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (4, 8), (4, 9), (4, 10), (4, 11), (4, 12), (4, 13), (4, 14), (4, 15), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (5, 9), (5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (6, 8), (6, 9), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7), (7, 8), (7, 9), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4), (8, 5), (8, 6), (8, 7), (8, 8), (8, 9), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (9, 0), (9, 1), (9, 2), (9, 3), (9, 4), (9, 5), (9, 6), (9, 7), (9, 8), (9, 9), (9, 10), (9, 11), (9, 12), (9, 13), (9, 14), (9, 15), (9, 16), (10, 0), (10, 1), (10, 2), (10, 3), (10, 4), (10, 5), (10, 6), (10, 7), (10, 8), (10, 9), (10, 10), (10, 11), (10, 12), (10, 13), (10, 14), (10, 15), (10, 16), (11, 0), (11, 1), (11, 2), (11, 3), (11, 4), (11, 5), (11, 6), (11, 7), (11, 8), (11, 9), (11, 10), (11, 11), (11, 12), (11, 13), (11, 14), (11, 15), (11, 16), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5), (12, 6), (12, 7), (12, 8), (12, 9), (12, 10), (12, 11), (12, 12), (12, 13), (12, 14), (12, 15), (12, 16), (13, 1), (13, 2), (13, 3), (13, 4), (13, 5), (13, 6), (13, 7), (13, 8), (13, 9), (13, 10), (13, 11), (13, 12), (13, 13), (13, 14), (13, 15), (14, 1), (14, 2), (14, 3), (14, 4), (14, 5), (14, 6), (14, 7), (14, 8), (14, 9), (14, 10), (14, 11), (14, 12), (14, 13), (14, 14), (15, 3), (15, 4), (15, 5), (15, 6), (15, 7), (15, 8), (15, 9), (15, 10), (15, 11), (15, 12), (15, 13), (15, 14), (16, 4), (16, 5), (16, 6), (16, 7), (16, 8), (16, 9), (16, 10), (16, 11)] : List Cell).toFinset +private def square : Finset Cell := (Finset.Icc (0 : ℤ) 16).product (Finset.Icc (0 : ℤ) 16) +private def initialM : Finset Cell := ([] : List Cell).toFinset +private def initialB : Finset Cell := ([] : List Cell).toFinset +private def targetWin (M : Finset Cell) : Prop := ∃ (r : Fin 8) (t : Cell), target.image (placement r t) ⊆ M +theorem target_exact : snaky = target := by decide +kernel +theorem envelope_exact : envelope_727 = envelope := by decide +kernel +theorem square_exact : square17 = square := by decide +kernel +theorem inputs_exact : initialM = ∅ ∧ initialB = ∅ ∧ (727 : Nat) = 727 := by decide +kernel +theorem counts_exact : envelope.card = 251 ∧ square.card = 289 := by decide +kernel +private theorem win_exact : HasSnaky = targetWin := by + funext M + simp only [HasSnaky, targetWin, target_exact] +theorem checked_envelope : FiniteWins envelope targetWin 21 initialM initialB := by + rw [← envelope_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.envelope_wins +theorem checked_square : FiniteWins square targetWin 21 initialM initialB := by + rw [← square_exact, ← win_exact, inputs_exact.1, inputs_exact.2.1] + exact FiniteCongruenceChecks.SnakyFinite.square_wins +end FiniteCongruenceChecks.SnakyFinite.Binding diff --git a/lean/snaky/SnakyFinite.lean b/lean/snaky/SnakyFinite.lean new file mode 100644 index 0000000..4268a43 --- /dev/null +++ b/lean/snaky/SnakyFinite.lean @@ -0,0 +1,40 @@ +import FiniteCards.Height21Part01 + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 + +/-- The exact coordinate board 0 ≤ x,y ≤ 16, including all 289 cells. -/ +def square17 : Finset Cell := (Finset.Icc (0 : ℤ) 16).product (Finset.Icc (0 : ℤ) 16) + +theorem envelope_card : envelope_727.card = 251 := by decide +kernel + +theorem square_card : square17.card = 289 := by decide +kernel + +theorem envelope_subset_square : envelope_727 ⊆ square17 := by decide +kernel + +theorem square_membership (p : Cell) : + p ∈ square17 ↔ 0 ≤ p.1 ∧ p.1 ≤ 16 ∧ 0 ≤ p.2 ∧ p.2 ≤ 16 := by + simp [square17, and_assoc] + +/-- Every containing finite board with at least 42 cells supports this strategy. +All Maker choices and legal Breaker replies are quantified within U. -/ +theorem board_wins (U : Finset Cell) (hU : envelope_727 ⊆ U) (hsize : 42 ≤ U.card) : + FiniteWins U HasSnaky 21 ∅ ∅ := by + apply finite_row_works_727 U ∅ ∅ hU + · simp + · simp + · simp + · simp [required_727] + · simp + · simpa using hsize + +theorem envelope_wins : FiniteWins envelope_727 HasSnaky 21 ∅ ∅ := + board_wins envelope_727 (Finset.Subset.refl _) (by rw [envelope_card]; decide) + +theorem square_wins : FiniteWins square17 HasSnaky 21 ∅ ∅ := + board_wins square17 envelope_subset_square (by rw [square_card]; decide) + +/-- The public result refers to the upstream six-cell Snaky target exactly. -/ +theorem target_exact : snaky = {(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)} := rfl + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/SnakySemantics.lean b/lean/snaky/SnakySemantics.lean new file mode 100644 index 0000000..a23fd44 --- /dev/null +++ b/lean/snaky/SnakySemantics.lean @@ -0,0 +1,199 @@ +/- The finite-board composition and transport arguments adapt +openai/math SnakyTwentyOne/Semantics/Game.lean at commit +1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0). +Changes: explicit finite board, fresh-cell budget, immediate victory, +and nonempty legal Breaker response requirements. See UPSTREAM_LICENSE. -/ +import OAI.GameTheory.SnakyTwentyOne.Certificate.Operations + +namespace FiniteCongruenceChecks.SnakyFinite +open OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21 +variable {α : Type*} [DecidableEq α] + +/-- A finite-board strategy tree counting actual fresh Maker claims. Victory can +end immediately; a nonwinning turn requires an available legal Breaker reply. -/ +inductive FiniteWins (U : Finset α) (win : Finset α → Prop) : ℕ → Finset α → Finset α → Prop + | done {n M B} : win M → FiniteWins U win n M B + | finish {n M B} (x : α) (hxU : x ∈ U) (hxM : x ∉ M) (hxB : x ∉ B) + (won : win (insert x M)) : FiniteWins U win (n + 1) M B + | move {n M B} (x : α) (hxU : x ∈ U) (hxM : x ∉ M) (hxB : x ∉ B) + (available : ∃ b ∈ U, b ∉ insert x M ∧ b ∉ B) + (next : ∀ b ∈ U, b ∉ insert x M → b ∉ B → + FiniteWins U win n (insert x M) (insert b B)) : + FiniteWins U win (n + 1) M B + +theorem FiniteWins.weaken {U : Finset α} {win : Finset α → Prop} {n M B} + (h : FiniteWins U win n M B) : ∀ k, FiniteWins U win (n + k) M B := by + induction h with + | done hw => intro k; exact .done hw + | @finish n M B x hxU hxM hxB hw => + intro k + simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using + (FiniteWins.finish (n := n + k) x hxU hxM hxB hw) + | move x hxU hxM hxB ha next ih => + intro k + simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using + (FiniteWins.move x hxU hxM hxB ha (fun b hbU hbM hbB => ih b hbU hbM hbB k)) + +theorem FiniteWins.mono {U : Finset α} {win : Finset α → Prop} {n m M B} + (h : FiniteWins U win n M B) (hnm : n ≤ m) : FiniteWins U win m M B := by + obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hnm + exact h.weaken k + +/-- The budget leaves two fresh cells per remaining Maker turn. It applies to +all larger boards, so Breaker may also play outside the certificate envelope. -/ +def FiniteTemplate (win : Finset α → Prop) (n : ℕ) (A H : Finset α) : Prop := + ∀ U M B, H ⊆ U → M ⊆ U → B ⊆ U → Disjoint M B → A ⊆ M → Disjoint B H → + M.card + B.card + 2 * n ≤ U.card → FiniteWins U win n M B + +theorem FiniteTemplate.mono {win : Finset α → Prop} {n m A H} + (h : FiniteTemplate win n A H) (hnm : n ≤ m) : FiniteTemplate win m A H := by + intro U M B hHU hMU hBU hMB hAM hBH hcard + exact (h U M B hHU hMU hBU hMB hAM hBH (by omega)).mono hnm + +theorem fresh_cell (U M B : Finset α) (h : M.card + B.card < U.card) : + ∃ x ∈ U, x ∉ M ∧ x ∉ B := by + obtain ⟨x, hxU, hx⟩ := Finset.exists_mem_notMem_of_card_lt_card + (lt_of_le_of_lt (Finset.card_union_le M B) h) + exact ⟨x, hxU, (fun hM => hx (Finset.mem_union_left B hM)), + (fun hB => hx (Finset.mem_union_right M hB))⟩ + +theorem finite_immediate (win : Finset α → Prop) (H : Finset α) (pivot : α) + (hp : pivot ∈ H) (hwin : ∀ M, H ⊆ M → win M) : + FiniteTemplate win 1 (H.erase pivot) H := by + intro U M B hHU _ _ _ hAM hBH _ + have hsub : H ⊆ insert pivot M := by + intro y hy + by_cases hyp : y = pivot + · simp [hyp] + · exact Finset.mem_insert_of_mem (hAM (Finset.mem_erase.mpr ⟨hyp, hy⟩)) + by_cases hpM : pivot ∈ M + · exact .done (hwin M (by simpa [Finset.insert_eq_of_mem hpM] using hsub)) + · exact .finish pivot (hHU hp) hpM + (fun hpB => Finset.disjoint_left.mp hBH hpB hp) (hwin _ hsub) + +theorem finite_compose {ι : Type*} [Nonempty ι] + (win : Finset α → Prop) (n : ℕ) (C D : ι → Finset α) + (hchild : ∀ j, FiniteTemplate win n (C j) (D j)) + (pivot : α) (A H : Finset α) (hpH : pivot ∈ H) + (hC : ∀ j, C j ⊆ insert pivot A) + (hD : ∀ j, D j ⊆ H) + (hcommon : ∀ b, (∀ j, b ∈ D j) → b ∈ insert pivot A) : + FiniteTemplate win (n + 1) A H := by + intro U M B hHU hMU hBU hMB hAM hBH hcard + have hpB : pivot ∉ B := fun hp => Finset.disjoint_left.mp hBH hp hpH + have hex : ∃ x ∈ U, x ∉ M ∧ x ∉ B ∧ pivot ∈ insert x M := by + by_cases hpM : pivot ∈ M + · obtain ⟨x, hxU, hxM, hxB⟩ := fresh_cell U M B (by omega) + exact ⟨x, hxU, hxM, hxB, Finset.mem_insert_of_mem hpM⟩ + · exact ⟨pivot, hHU hpH, hpM, hpB, Finset.mem_insert_self _ _⟩ + obtain ⟨x, hxU, hxM, hxB, hpx⟩ := hex + have howned : insert pivot A ⊆ insert x M := by + intro y hy + rcases Finset.mem_insert.mp hy with hyp | hyA + · subst y; exact hpx + · exact Finset.mem_insert_of_mem (hAM hyA) + have hMcard : (insert x M).card = M.card + 1 := Finset.card_insert_of_notMem hxM + apply FiniteWins.move x hxU hxM hxB + · exact fresh_cell U (insert x M) B (by omega) + · intro b hbU hbM hbB + obtain ⟨j, hjC, hjD⟩ := surviving_child C D (insert x M) B H + (fun j => (hC j).trans howned) hD (fun y hy => howned (hcommon y hy)) hBH b hbM + refine hchild j U (insert x M) (insert b B) ((hD j).trans hHU) + (Finset.insert_subset hxU hMU) (Finset.insert_subset hbU hBU) ?_ hjC hjD ?_ + · refine Finset.disjoint_left.mpr ?_ + intro y hyM hyB + rcases Finset.mem_insert.mp hyB with hyb | hyB + · subst y; exact hbM hyM + · rcases Finset.mem_insert.mp hyM with hyx | hyM + · subst y; exact hxB hyB + · exact Finset.disjoint_left.mp hMB hyM hyB + · rw [hMcard, Finset.card_insert_of_notMem hbB] + omega + +theorem FiniteWins.transport {U : Finset α} {win : Finset α → Prop} {n M B} + (h : FiniteWins U win n M B) (e : α ≃ α) + (hwin : ∀ X, win X → win (X.image e)) : + FiniteWins (U.image e) win n (M.image e) (B.image e) := by + induction h with + | done hw => exact .done (hwin _ hw) + | finish x hxU hxM hxB hw => + apply FiniteWins.finish (e x) (Finset.mem_image_of_mem e hxU) + · simpa only [Finset.mem_image, e.injective.eq_iff, exists_eq_right] using hxM + · simpa only [Finset.mem_image, e.injective.eq_iff, exists_eq_right] using hxB + · simpa only [Finset.image_insert] using hwin _ hw + | @move n M B x hxU hxM hxB ha next ih => + apply FiniteWins.move (e x) (Finset.mem_image_of_mem e hxU) + · simpa only [Finset.mem_image, e.injective.eq_iff, exists_eq_right] using hxM + · simpa only [Finset.mem_image, e.injective.eq_iff, exists_eq_right] using hxB + · obtain ⟨b, hbU, hbM, hbB⟩ := ha + refine ⟨e b, Finset.mem_image_of_mem e hbU, ?_, ?_⟩ + · simpa only [← Finset.image_insert, Finset.mem_image, e.injective.eq_iff, + exists_eq_right] using hbM + · simpa only [Finset.mem_image, e.injective.eq_iff, exists_eq_right] using hbB + · intro b hbU hbM hbB + have hbU' : e.symm b ∈ U := by + obtain ⟨y, hy, he⟩ := Finset.mem_image.mp hbU + simpa [← he] using hy + have hbM' : e.symm b ∉ insert x M := by + intro hb + apply hbM + simpa [Finset.image_insert] using Finset.mem_image_of_mem e hb + have hbB' : e.symm b ∉ B := by + intro hb + apply hbB + simpa using Finset.mem_image_of_mem e hb + simpa [Finset.image_insert] using ih (e.symm b) hbU' hbM' hbB' + +theorem FiniteTemplate.transport {win : Finset α → Prop} {n A H} + (h : FiniteTemplate win n A H) (e : α ≃ α) + (hwin : ∀ X, win X → win (X.image e)) : + FiniteTemplate win n (A.image e) (H.image e) := by + intro U M B hHU hMU hBU hMB hAM hBH hcard + have hHU' : H ⊆ U.image e.symm := by + intro z hz + exact Finset.mem_image.mpr ⟨e z, hHU (Finset.mem_image_of_mem e hz), by simp⟩ + have hMB' : Disjoint (M.image e.symm) (B.image e.symm) := by + exact (Finset.disjoint_image e.symm.injective).mpr hMB + have hAM' : A ⊆ M.image e.symm := by + intro z hz + exact Finset.mem_image.mpr ⟨e z, hAM (Finset.mem_image_of_mem e hz), by simp⟩ + have hBH' : Disjoint (B.image e.symm) H := by + refine Finset.disjoint_left.mpr ?_ + intro z hzB hzH + obtain ⟨x, hx, he⟩ := Finset.mem_image.mp hzB + have hxH : x ∈ H.image e := by + exact Finset.mem_image.mpr ⟨z, hzH, by rw [← he]; simp⟩ + exact Finset.disjoint_left.mp hBH hx hxH + have hcard' : (M.image e.symm).card + (B.image e.symm).card + 2 * n ≤ + (U.image e.symm).card := by + simpa only [Finset.card_image_of_injective _ e.symm.injective] using hcard + have hh := (h (U.image e.symm) (M.image e.symm) (B.image e.symm) + hHU' (Finset.image_subset_image hMU) (Finset.image_subset_image hBU) + hMB' hAM' hBH' hcard').transport e hwin + simpa [Finset.image_image, Function.comp_def] using hh + +theorem finite_placed21_template {n : ℕ} {A H : Finset Cell} + (h : FiniteTemplate HasSnaky n A H) (s : Fin 8) (t : Cell) : + FiniteTemplate HasSnaky n (placed21 s t A) (placed21 s t H) := by + have hh := h.transport (placementEquiv (currentCode s) t) + (fun X hx => by simpa only [coe_placementEquiv] using HasSnaky.placed (currentCode s) t X hx) + simpa only [placed21, Finset.map_eq_image, Equiv.toEmbedding, + Function.Embedding.coeFn_mk, coe_placementEquiv] using hh + +/-- Empty response sets cannot manufacture a strategy for an impossible target. -/ +theorem FiniteWins.false_impossible {U : Finset α} {n M B} + (h : FiniteWins U (fun _ => False) n M B) : False := by + induction h with + | done hw => exact hw + | finish x hxU hxM hxB hw => exact hw + | move x hxU hxM hxB ha next ih => + obtain ⟨b, hbU, hbM, hbB⟩ := ha + exact ih b hbU hbM hbB + +theorem FiniteWins.zero_iff {U : Finset α} {win : Finset α → Prop} {M B} : + FiniteWins U win 0 M B ↔ win M := by + constructor + · intro h; cases h with | done hw => exact hw + · exact FiniteWins.done + +end FiniteCongruenceChecks.SnakyFinite diff --git a/lean/snaky/UPSTREAM_LICENSE b/lean/snaky/UPSTREAM_LICENSE new file mode 100644 index 0000000..261eeb9 --- /dev/null +++ b/lean/snaky/UPSTREAM_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/lean/snaky/UPSTREAM_NOTICE.md b/lean/snaky/UPSTREAM_NOTICE.md new file mode 100644 index 0000000..e232853 --- /dev/null +++ b/lean/snaky/UPSTREAM_NOTICE.md @@ -0,0 +1,16 @@ +# Upstream Snaky formalization + +`OAI/GameTheory/SnakyTwentyOne/` is an exact byte copy from +[openai/math commit 1581d4cbdd69a0faf34b2089614fe2a814316a6a](https://github.com/openai/math/tree/1581d4cbdd69a0faf34b2089614fe2a814316a6a/lean/OAI/GameTheory/SnakyTwentyOne). +The corresponding upstream Apache-2.0 license is retained as `UPSTREAM_LICENSE`. +The file list and SHA-256 hashes are in `vendor-manifest.json`. + +`FiniteCards/` contains mechanically adapted semantic derivations from those +upstream proof scripts. They replace the infinite-board template semantics with +this project's finite-board strategy semantics. The original upstream files are +unchanged. The generator is not trusted evidence; Lean checks its output. + +`SnakySemantics.lean` adapts the upstream composition and transport arguments +with an explicit finite board, a fresh-cell budget, immediate victory, and a +nonempty legal Breaker response requirement. It retains the same Apache-2.0 +origin notice; the finite-board changes are described in its source header. diff --git a/lean/snaky/generate_finite_cards.py b/lean/snaky/generate_finite_cards.py new file mode 100644 index 0000000..bf997fe --- /dev/null +++ b/lean/snaky/generate_finite_cards.py @@ -0,0 +1,52 @@ +"""Generate finite-board semantic derivations from pinned upstream card proofs. + +This textual generator is not a verifier. Lean checks every resulting proof. +Exact upstream data and combinatorial lemmas remain in their original modules. +""" +from pathlib import Path +import argparse +import hashlib +import json +import re + +ROOT = Path(__file__).resolve().parent + +def generated(): + manifest = json.loads((ROOT / "vendor-manifest.json").read_text(encoding="utf-8")) + for item in manifest["files"]: + actual = (ROOT / item["path"]).read_bytes() + if hashlib.sha256(actual).hexdigest() != item["sha256"]: + raise ValueError("vendored source hash mismatch: " + item["path"]) + count = 0 + for source in sorted((ROOT / "OAI/GameTheory/SnakyTwentyOne/Cards").glob("*.lean")): + text = source.read_text(encoding="utf-8") + parts = re.findall(r"theorem (?:row_works_[0-9]+(?:_i[0-9]+)*|children_work_[0-9]+(?:_i[0-9]+)*)\b.*?(?=\ntheorem |\ndef |\nend )", text, re.S) + count += len(parts) + imports = ["import SnakySemantics", "import " + ".".join(source.relative_to(ROOT).with_suffix("").parts)] + imports += ["import FiniteCards." + name for name in re.findall(r"import OAI\.GameTheory\.SnakyTwentyOne\.Cards\.(\w+)", text)] + body = "\n\n".join(parts) + for old, new in [("placed21_template", "finite_placed21_template"), ("immediate_template", "finite_immediate"), ("row_works_", "finite_row_works_"), ("children_work_", "finite_children_work_"), ("Template", "FiniteTemplate")]: + body = body.replace(old, new) + body = re.sub(r"\bcompose\b", "finite_compose", body) + result = "/- Derived from openai/math SnakyTwentyOne card proofs at\n1581d4cbdd69a0faf34b2089614fe2a814316a6a (Apache-2.0).\nModified here to use bounded finite-board semantics; see UPSTREAM_LICENSE. -/\n" + "\n".join(imports) + "\n\nnamespace FiniteCongruenceChecks.SnakyFinite\nopen OAI.SnakyPrototype OAI.SnakyPrototype.Certificate21\n\n" + body + "\n\nend FiniteCongruenceChecks.SnakyFinite\n" + yield ROOT / "FiniteCards" / source.name, result + if count != 3246: + raise ValueError(f"expected 3246 semantic derivations, found {count}") + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--check", action="store_true") + args = parser.parse_args() + results = list(generated()) + for path, text in results: + expected = text.encode("utf-8") + if args.check: + if path.read_bytes().replace(b"\r\n", b"\n") != expected: + raise ValueError("stale finite proof: " + str(path)) + else: + path.parent.mkdir(exist_ok=True) + path.write_bytes(expected) + print(f"{len(results)} finite-card modules: 3246 Lean derivations {'match' if args.check else 'generated'}") + +if __name__ == "__main__": + main() diff --git a/lean/snaky/lake-manifest.json b/lean/snaky/lake-manifest.json new file mode 100644 index 0000000..8afe57d --- /dev/null +++ b/lean/snaky/lake-manifest.json @@ -0,0 +1,117 @@ +{ + "version": "1.2.0", + "packagesDir": ".lake/packages", + "packages": [ + { + "url": "https://github.com/leanprover-community/mathlib4.git", + "type": "git", + "subDir": null, + "scope": "", + "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "name": "mathlib", + "manifestFile": "lake-manifest.json", + "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612", + "inherited": false, + "configFile": "lakefile.lean" + }, + { + "url": "https://github.com/leanprover-community/plausible", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c", + "name": "plausible", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover-community/LeanSearchClient", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707", + "name": "LeanSearchClient", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover-community/import-graph", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "e928b72544873815af278d38681b31c0293588e3", + "name": "importGraph", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover-community/ProofWidgets4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5", + "name": "proofwidgets", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.lean" + }, + { + "url": "https://github.com/leanprover-community/aesop", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "355695d523e41d0554926416cba2a2b3544fbbc9", + "name": "aesop", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover-community/quote4", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259", + "name": "Qq", + "manifestFile": "lake-manifest.json", + "inputRev": "master", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover-community/batteries", + "type": "git", + "subDir": null, + "scope": "leanprover-community", + "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2", + "name": "batteries", + "manifestFile": "lake-manifest.json", + "inputRev": "main", + "inherited": true, + "configFile": "lakefile.toml" + }, + { + "url": "https://github.com/leanprover/lean4-cli", + "type": "git", + "subDir": null, + "scope": "leanprover", + "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204", + "name": "Cli", + "manifestFile": "lake-manifest.json", + "inputRev": "v4.34.0", + "inherited": true, + "configFile": "lakefile.toml" + } + ], + "name": "snakyFinite", + "lakeDir": ".lake", + "fixedToolchain": false +} diff --git a/lean/snaky/lakefile.toml b/lean/snaky/lakefile.toml new file mode 100644 index 0000000..ac0686e --- /dev/null +++ b/lean/snaky/lakefile.toml @@ -0,0 +1,26 @@ +name = "snakyFinite" +version = "0.1.0" +defaultTargets = ["SnakyFinite", "SnakyBinding"] +moreLeanArgs = ["-j1"] + +[[require]] +name = "mathlib" +git = "https://github.com/leanprover-community/mathlib4.git" +rev = "d13f23b723b8a846827a245b89c10fc7d3f11612" + +[[lean_lib]] +name = "OAI" +globs = ["OAI.+"] + +[[lean_lib]] +name = "FiniteCards" +globs = ["FiniteCards.+"] + +[[lean_lib]] +name = "SnakySemantics" + +[[lean_lib]] +name = "SnakyFinite" + +[[lean_lib]] +name = "SnakyBinding" diff --git a/lean/snaky/lean-toolchain b/lean/snaky/lean-toolchain new file mode 100644 index 0000000..ba8ebf2 --- /dev/null +++ b/lean/snaky/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.34.1 diff --git a/lean/snaky/vendor-manifest.json b/lean/snaky/vendor-manifest.json new file mode 100644 index 0000000..4245748 --- /dev/null +++ b/lean/snaky/vendor-manifest.json @@ -0,0 +1,476 @@ +{ + "repository": "https://github.com/openai/math", + "commit": "1581d4cbdd69a0faf34b2089614fe2a814316a6a", + "files": [ + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height01Part01.lean", + "sha256": "b721851d44936e696a7ca108bc258a9cff38340751b3d779e2cbbf8d8b5b5036", + "bytes": 6498 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part01.lean", + "sha256": "59d96363dfcfba2711d08567a0f536af7f4ec54cc777c823c78d4b5f6b905aa4", + "bytes": 64348 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part02.lean", + "sha256": "0d57456db981f46183771645e5176837cf7d22bfddbb1a9ee2651bc0cfe900e4", + "bytes": 49722 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part01.lean", + "sha256": "09869ff7e389b199966af69e5e2b1b8c4a617656d6277698a8c96aa4b021a4b9", + "bytes": 64534 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part02.lean", + "sha256": "f229e04ff8b7d9176d39b26b24bfaa88b3f26d2710340db46e5b1b1d22144fc6", + "bytes": 66354 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part03.lean", + "sha256": "1b9ddf7e48a2d55d51fc18ddc0f93bcb7b4dc048bd648d2d4e5a72d8bbdf17a3", + "bytes": 61734 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part01.lean", + "sha256": "f9e2556bf69c4f88311787cf0d663f0a24d2bfdd43762a6774f9133241b82b5b", + "bytes": 66124 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part02.lean", + "sha256": "b7371990d1a053b8dad99d5e3d0bdbfb4be5fc147d8ee5c7d886d89d4bc584e0", + "bytes": 66420 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part03.lean", + "sha256": "e80807a7f939ffebcdc234e68c234a3ac1c77e0571ee72c6aac569ff9f3e7b7d", + "bytes": 67434 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part04.lean", + "sha256": "93a6c395d391c2f2d73c0a6d6274c53904ed6a6b3e1f88a73781388ffdff6e34", + "bytes": 62808 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part05.lean", + "sha256": "878e72c12b9e84fef33a3ea7d649574d08e19565c5560441d7d863117b89e8c3", + "bytes": 31977 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part01.lean", + "sha256": "e8bbd9bc6e87400a19e7a80e23eb2a0d3424199590ca3803befc6ecd6ee5a25a", + "bytes": 68339 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part02.lean", + "sha256": "dd932253e77d2f7292d44782e4b6e37a8ff93c2df170a1340f27834c37894cc3", + "bytes": 68684 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part03.lean", + "sha256": "53b601dc52ccff754ccf70084ef44d606d93b41beaf2f7dd61cca127fa799933", + "bytes": 70003 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part04.lean", + "sha256": "dd7bf148b9ad98c1430be052ef1f6e9e437ee111a32166443790f15175506777", + "bytes": 64468 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part05.lean", + "sha256": "aea13ebf283c4d058d25ada4ed15cec3c3b0ce062b05769aecbac509d309dda5", + "bytes": 67226 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part06.lean", + "sha256": "649732e2efb25248b34b40715c91d769d5074fc03c89ba0a43065aa09ebf93f7", + "bytes": 68261 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part07.lean", + "sha256": "ba0397ab80d2c5744520d4ea44eb6f857aabe35c7d1bfd787bbdd22f06269397", + "bytes": 6193 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part01.lean", + "sha256": "25631c997e43e5d2b93a65de3fa7b445be17232674796aba2572e7fea6f15852", + "bytes": 69070 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part02.lean", + "sha256": "c9676996ed11ffa3e24f78308318b2cd9100f36edca21633434ba629198ec813", + "bytes": 68568 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part03.lean", + "sha256": "9a6db2aec95eced43911499fbc2841ab1f831885bc087882be027b41b303a046", + "bytes": 68690 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part04.lean", + "sha256": "edb074c085baafc8a5dd469ff28d1650d0f51b99a0e46455f30a36a7996dbd7c", + "bytes": 59602 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part05.lean", + "sha256": "fb883f0172b0d7195cbc41290c6c2de9879221913ee699494f7179ed9fa5d162", + "bytes": 65932 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part06.lean", + "sha256": "d16fbbc1233561d5fa5295174fce0c97805b32c8351374413c7038982392ea33", + "bytes": 66245 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part01.lean", + "sha256": "25cd3b6dfb5d18f99a0a9a3a50a5b54f0bf2bf600c942b1fc17cefb7fef79b12", + "bytes": 69667 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part02.lean", + "sha256": "11eb252c6d440ed9f51bb56e78af089e155bbe71c9a560a69fc12c331695b1bd", + "bytes": 69700 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part03.lean", + "sha256": "706d293c21868a010c5b8eda2cd1cfdbfdf9378e60e8053c190e15f29b8d034f", + "bytes": 66656 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part04.lean", + "sha256": "b6ada6198549c57e2c1780de45025ea71667386a45e1a7e551b437ed5fda6a47", + "bytes": 72465 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part05.lean", + "sha256": "8f0684cca8d7bc6258c368e7ad5d14f55972a411f64f26e7ccc6f3258a673acc", + "bytes": 72488 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part06.lean", + "sha256": "243c2861da61125a2ae538143bd1016c70d888c90030174a43ba55f95f62e919", + "bytes": 12836 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part01.lean", + "sha256": "82c6d8311c44ad8d40aea9f0237156dad735197c0ae7986fd5c9169cd76eaf3b", + "bytes": 69336 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part02.lean", + "sha256": "78a39d42a9ce6b5ba0450598209571689a8ffd3ddecdf788c9080d2964b08694", + "bytes": 64539 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part03.lean", + "sha256": "a502d65803e3611d7df6e7933edb50a86a0f5d74ebfb134203864996c9a6efca", + "bytes": 69482 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part04.lean", + "sha256": "d383e19ead30aa84f8dfc1d91cba6bc899aea830b1bd8e75a71d535d8ac72753", + "bytes": 72682 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part05.lean", + "sha256": "aac655834b86fccaf58a123116ef69a4503d0254e74bf3a5313e87169b7e03d7", + "bytes": 66645 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part01.lean", + "sha256": "eb041abc50134f6a894027720e1f5a72d210885e27e798fa25ecbd40cfcc7b8e", + "bytes": 68779 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part02.lean", + "sha256": "d70ef317bc9b10e88176c5299878b37fea8ff32ef13d2705dc5f2e11fe6cd744", + "bytes": 55059 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part03.lean", + "sha256": "51e58151811ea564c431a3354866283620e588e911873f91232e57dff26f5d2d", + "bytes": 66161 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part04.lean", + "sha256": "c67800b85780fbc0a017ac90bb69aa43474735fbcd36eae20230cb56bacdd792", + "bytes": 69160 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part05.lean", + "sha256": "a96acbd788ebbc4414d0e61a7d06e3a65d860c83f1db354511eda3543d4e9076", + "bytes": 43746 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part06.lean", + "sha256": "e483d02b0f566c62b17bd12614bce69f9589b9de4d93000c9305bc645c84dc82", + "bytes": 58830 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part07.lean", + "sha256": "c64b6fc7441de2c2d3b92daf23c7fdba4448d42589bc46f79ebfb7dae00209a8", + "bytes": 67163 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part08.lean", + "sha256": "0d711b1ba2d8f0caf5e6188100216e78d3fb76ebfd63d7e8935d70a4f779681e", + "bytes": 55565 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part01.lean", + "sha256": "d8a501150730c5868dc1e87fa4e8f691df984e817b9b87fb454e9b86d12ebaf6", + "bytes": 77714 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part02.lean", + "sha256": "47128473825a65bb8a7c6edf869345edb33197e1b08b64452f7413b0b258ca5a", + "bytes": 74217 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part03.lean", + "sha256": "90591ceddfdfb8a7109f4ec3ba1feac0c777d4aa8f98ef448a2081be2907c335", + "bytes": 74070 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part04.lean", + "sha256": "995aeb639e7a2ea3fc12b19382d26465d447e8fbfd12bfa275931f3dd05b3416", + "bytes": 63172 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part05.lean", + "sha256": "adbd7834740f2e09d435c743cb00ad078165321a388e86d7f0e4a07593e22846", + "bytes": 67601 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part06.lean", + "sha256": "941557ad54a116a5c5353f3abb2d347e995a301ed6d3fb9dd482ddae01c73a7d", + "bytes": 69473 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part07.lean", + "sha256": "16bb244088a706cb45bba2c479a60c1ee525d46ab52069c5e27018251c199c6a", + "bytes": 19625 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part01.lean", + "sha256": "2afe7b6b6d805fec07aef8b1560f7c7c10f5ee1ea2e60131cd2991c132a14425", + "bytes": 61334 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part02.lean", + "sha256": "6052574dc2afcc7933532c978ae9f50104b000d3f9e7d23bde74c7a984aafd33", + "bytes": 72515 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part03.lean", + "sha256": "c955d181f3d7e17739df4ce36a8e306f067e7ecd47dad1e301a603fbaeccbd24", + "bytes": 57110 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part04.lean", + "sha256": "3e15ffd5811c739975a3cccd95bd44abe635f97b9baaed944841b751365afd22", + "bytes": 66597 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part05.lean", + "sha256": "75f02f38d91fec7e334a0aa89450a0c27b728be98221d7559964ae0eb0e811e0", + "bytes": 77995 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part06.lean", + "sha256": "744342de6ed465e062d443e918dcbf298636856e35958cc7afa32f827dde6da1", + "bytes": 49737 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part01.lean", + "sha256": "98ada75cffa280d9bfe02e5510507cdb7a425d326652119fd676e2a612b7de98", + "bytes": 73924 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part02.lean", + "sha256": "92978a0d11d3c74f49f2fed81eb75f7296610af3a4c4cd890f0b695009d9bb63", + "bytes": 74230 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part03.lean", + "sha256": "9caf9a13e979d827a4c0d74deca5f32c54f4b85c2e7d87ffde7015f02e82e0fb", + "bytes": 73308 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part04.lean", + "sha256": "45ab2b20c2db4517ef9db6d8c10849f623b78b4e0e90ed33532f2c456c47646a", + "bytes": 66987 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part05.lean", + "sha256": "844faee78ca99c9bf2644389ae17459584ed4bd76b1183b44407ea336a001e00", + "bytes": 61987 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part01.lean", + "sha256": "c7d05c2ae8c69a2b0d985c2e18edeab63af7e03276ecf47ed80768f730f43cec", + "bytes": 64984 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part02.lean", + "sha256": "98283cc58c87f7dbd87cb88ff0ba4b897e7683cafee56c1341610fc81f9a4c55", + "bytes": 73324 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part03.lean", + "sha256": "4e604e82c10e2d76f1b2c9a39d96f2f7472c0a8d3fc5f3c109668ba193d1bfa5", + "bytes": 78951 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part04.lean", + "sha256": "c6eb8cd09091be55e2bd853d8d0a02c6f3b01e56cf187831d866fe7c72481d16", + "bytes": 55050 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part05.lean", + "sha256": "f13ea4353c6cda2dbf684a2734e92f5064822170665155699c5113771be3f3a3", + "bytes": 65234 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part06.lean", + "sha256": "b4eb63c7fefeb0a5da6d8a047be13a9bb988a0abc0fa0b2e8e090e7952c2b3a4", + "bytes": 62882 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part07.lean", + "sha256": "608570161b4a67b15a575d09664f5032ae854a881950cf6a98e9cf7c972138ca", + "bytes": 23996 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part01.lean", + "sha256": "cdcae9363b98149cce6a8a6d95b255bbb928b19226ad53a0efbe0283de9a2f68", + "bytes": 74722 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part02.lean", + "sha256": "536089a57e85902db6c1d5b125a4346fc8669ae9aba55099faba30ed1bbbc78a", + "bytes": 75908 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part03.lean", + "sha256": "78867488bf9599a41719f74e42c34d5bd21047308382079ba3b59b408d5120a3", + "bytes": 68216 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part04.lean", + "sha256": "ce1b0fa24cc8ed5050692cc200401c05f27c80ec295e2337cf687055efe7a751", + "bytes": 51167 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part01.lean", + "sha256": "95030470ead192c47b9115eed23c003978646393f5ca4f6257a0a1dde0ba7195", + "bytes": 78755 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part02.lean", + "sha256": "8d849760c2d74d70cf77c7ccbceca941ebe3fdf867f86afd13911f8e5b194ca2", + "bytes": 81934 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part03.lean", + "sha256": "d859675955b216884012b25c82b2c86f0ee159ed7d8fd51320fac584339946ac", + "bytes": 80615 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part04.lean", + "sha256": "03498c2351fbd34ae0d95e0e971856f79593df844fc0190a7a0c921cd951da52", + "bytes": 30128 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part01.lean", + "sha256": "486549710154751edc1a3b719d1780e0b7bf0aa2955b7d3961e7f4a251ed7248", + "bytes": 72771 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part02.lean", + "sha256": "03dfedd9067aaf0644c6d76d75b470141dfd6eb48495eed2c9d3b7bc0a49aed7", + "bytes": 48651 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part03.lean", + "sha256": "a9b209921b6691c59d893c8d58eaab64f359707778b8785da65959491164610c", + "bytes": 37527 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part01.lean", + "sha256": "060e3a5d9d3b5123433eb50d186c38679892e6663a7c1405ae21c77bc001e862", + "bytes": 58108 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part02.lean", + "sha256": "4bd93d460827cf7c577fa113136abd40a53f5a8da1c6cd31f945ddd38d7c24ea", + "bytes": 40234 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part01.lean", + "sha256": "154698a2eafd7ab3118236a2f7c772c1b2057846780457f55f074703c267765b", + "bytes": 73483 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part02.lean", + "sha256": "fc1ea2edfb94e051c937f84b1add1adc18fd106fcc5e2bf8a60ba5b26328acc9", + "bytes": 31641 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height19Part01.lean", + "sha256": "59c407a3ab501823540cf7732c8a9589ecb1a87a73af2776abdfa06c6da30bbb", + "bytes": 13196 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height20Part01.lean", + "sha256": "579f5ac435486638f55cba08fe32d2762291d7d3eecd2f54056f491e396fb6c1", + "bytes": 51003 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Cards/Height21Part01.lean", + "sha256": "4f89721d3d39ac9e4e253edc1cbe367f5a4b7db7a15d6241e28951899fa32845", + "bytes": 10088 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Certificate/Operations.lean", + "sha256": "e69c168bfdf68f10052ceb9963a4013ddf536bd15ac79f5522fe932e82364a03", + "bytes": 4003 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Certificate/Summary.lean", + "sha256": "93ec0b599d3ed2628af92fe631dcf1c185fa0a44c3a532cf3c9179edfe1c9f87", + "bytes": 18019 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Main.lean", + "sha256": "a62fa55a65fd74a1bb9a06509a668feba17a0ce589586e72ffee0c6d83134e28", + "bytes": 2191 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Model.lean", + "sha256": "e2b6365603299d20d407519c365561f330d03af3e579c0042f19cdc2657df8b0", + "bytes": 1546 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Semantics/Game.lean", + "sha256": "1d20aa7e7c30c525e6daf2a0145668bbd50b42386e2f4523a96fa982b295730a", + "bytes": 8245 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Semantics/Geometry.lean", + "sha256": "0d07595a7c774d1a7c6954f2241d32635457f84500ab32016f55a48e563655db", + "bytes": 3954 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Semantics/Policy.lean", + "sha256": "c5feb030221603a62c91caaff754700b20da2c519a5bc05cf797f2dcd79598e5", + "bytes": 7983 + }, + { + "path": "OAI/GameTheory/SnakyTwentyOne/Semantics/Replies.lean", + "sha256": "b7571f5cce7fa672f93e00a74b2cd5d5a1f8d694f4ba791a9d421e27bf3c56b2", + "bytes": 1710 + } + ] +} diff --git a/scripts/build_snaky_chart.py b/scripts/build_snaky_chart.py new file mode 100644 index 0000000..1e0ce5e --- /dev/null +++ b/scripts/build_snaky_chart.py @@ -0,0 +1,101 @@ +"""Draw the independently reconstructed final Snaky support as an accessible SVG.""" +from __future__ import annotations + +import argparse +from html import escape +from pathlib import Path + +import check_snaky + +ROOT = Path(__file__).resolve().parents[1] +OUTPUT = ROOT / "docs/assets/snaky-board.svg" + + +def render(): + report = check_snaky.replay() + support = {tuple(p) for p in report["final"]["support"]} + # Pick an interior example of the unrotated six-cell target, independently + # of any choice that a particular strategy execution would make. + candidates = [(x, y) for x in range(17) for y in range(17) + if {(x + dx, y + dy) for dx, dy in check_snaky.SNAKY} <= support + and (8, 8) not in {(x + dx, y + dy) for dx, dy in check_snaky.SNAKY}] + check_snaky.require(bool(candidates), "No illustrative target fits in the support") + dx, dy = min(candidates, key=lambda p: ((p[0] - 5)**2 + (p[1] - 5)**2, p)) + target = {(x + dx, y + dy): i + 1 for i, (x, y) in enumerate(check_snaky.SNAKY)} + items = [ + '', + 'The 251-cell Snaky certificate support inside a 17 by 17 board', + 'Coordinates run from 0 to 16 on both axes. Blue cells form the 251-cell support of card 727. P marks the root pivot at (8,8). Six green cells labelled S1 through S6 illustrate one Snaky target; they are not occupied starting cells or an execution trace. Before Maker move 21, at most 40 cells are occupied, leaving at least 211 support cells free.', + '', + '', + 'A finite board with room for every required move', + 'Exact certificate: 728 cards · final support: 251 cells · height: 21 Maker moves', + ] + left, top, step = 64, 118, 27 + for y in range(17): + for x in range(17): + px, py = left + x * step, top + (16 - y) * step + point = (x, y) + fill = "#d8e9f6" if point in support else "#ffffff" + stroke = "#91b5d1" if point in support else "#d5dce4" + if point in target: + fill, stroke = "#146d62", "#0b4f49" + elif point == (8, 8): + fill, stroke = "#a95f00", "#774200" + label = f"({x},{y}): " + ("certificate support" if point in support else "square cell outside the support") + if point in target: + label += f"; illustrative target cell S{target[point]}" + if point == (8, 8): + label += "; root pivot P" + items.append(f'{escape(label)}') + if point in target or point == (8, 8): + name = f"S{target[point]}" if point in target else "P" + items.append(f'{name}') + for i in range(17): + items.append(f'{i}') + items.append(f'{i}') + items.extend([ + 'x coordinate', + 'y coordinate', + 'How to read the board', + '', + '251 cells in the final support', + '', + '38 other cells of the square board', + '', + 'P: first prescribed pivot, (8,8)', + '', + 'S1–S6: one illustrative Snaky target', + '', + 'Why a replacement cell is available', + 'If play reaches Maker move 21:', + '20 Maker claims + 20 Breaker claims', + 'occupy at most 40 cells.', + '251 − 40 = 211', + 'At least 211 support cells are still free.', + 'All cells start unclaimed. The highlighted', + 'target is an illustration; no play trace is shown.', + 'The diagram shows a fixed support. The proof', + 'also handles every legal Breaker reply.', + 'Generated from the pinned certificate and independent audit · finite-congruence-checks', + '', + ]) + return "\n".join(items) + "\n" + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--check", action="store_true") + args = parser.parse_args() + content = render() + if args.check: + check_snaky.require(OUTPUT.read_text(encoding="utf-8") == content, "Snaky board SVG is stale") + print("Snaky board SVG matches the independent computational receipt.") + else: + OUTPUT.parent.mkdir(parents=True, exist_ok=True) + OUTPUT.write_bytes(content.encode("utf-8")) + print(OUTPUT) + + +if __name__ == "__main__": + main() diff --git a/scripts/build_snaky_play.py b/scripts/build_snaky_play.py new file mode 100644 index 0000000..ad55d54 --- /dev/null +++ b/scripts/build_snaky_play.py @@ -0,0 +1,225 @@ +"""Generate one illustrative Snaky execution, independently replayed before saving. + +This is an adapter over the frozen certificate evaluator. It is not extracted +from Lean and does not establish an eight-move winning guarantee. +""" +from __future__ import annotations + +import argparse +from pathlib import Path + +import check_snaky as oracle + +ROOT = Path(__file__).resolve().parents[1] +OUTPUT = "evidence/snaky-play-v1/example.json" +SOURCE = "scripts/build_snaky_play.py" +VALIDATOR = "scripts/check_snaky_play.py" +EXAMPLE_ID = "example:family-187:snaky:eight-claim-branch:v1" +IDENTITY = (1, 0, 0, 1, 0, 0) +PREFIX = ((7, 8), (8, 6)) +LIMITS = [ + "One illustrative checked execution with chosen legal Breaker replies.", + "Eight Maker claims in this example do not establish an eight-move guarantee.", + "The Python move adapter is not an extracted formally verified policy.", + "This record binds certificate and implementation inputs, not a successful Lean proof receipt.", + "The 21-move universal theorem and its proof receipt are separate evidence.", +] + + +def affine(placement, point): + a, b, c, d, tx, ty = placement + x, y = point + return a*x + b*y + tx, c*x + d*y + ty + + +def compose(outer, reference): + a, b, c, d, tx, ty = outer + e, f, g, h = oracle.MATRICES[reference.symmetry] + dx, dy = reference.translation + return (a*e + b*g, a*f + b*h, c*e + d*g, c*f + d*h, + a*dx + b*dy + tx, c*dx + d*dy + ty) + + +def placement_json(placement): + a, b, c, d, tx, ty = placement + return {"matrix": [[a, b], [c, d]], "translation": [tx, ty]} + + +def local_node(cursor, expressions): + card, path, _ = cursor + if card < 6: + return None + node = expressions[card - 6] + for index in path: + node = node.children[index] + return node + + +def data_at(cursor, cards, expressions): + card, _, placement = cursor + node = local_node(cursor, expressions) + local = cards[card] if card < 6 else oracle.evaluate(node, cards[:card]) + return oracle.Card(frozenset(affine(placement, p) for p in local.required), + frozenset(affine(placement, p) for p in local.support), local.height) + + +def source_reference(reference): + if reference.symmetry == 0 and reference.translation == (0, 0): + return str(reference.index) + dx, dy = reference.translation + return f"{reference.index}:{reference.symmetry}{oracle.ALPHABET[dx]}{oracle.ALPHABET[dy]}" + + +def next_cursor(cursor, index, child): + card, path, placement = cursor + if isinstance(child, oracle.Reference): + return child.index, (), compose(placement, child) + return card, path + (index,), placement + + +def active_json(cursor, cards, expressions): + card, path, placement = cursor + data = data_at(cursor, cards, expressions) + base_url = f"https://github.com/openai/math/blob/{oracle.UPSTREAM_COMMIT}/{oracle.UPSTREAM_PATH}" + line = card - 5 + if card < 6: + base_url = f"https://github.com/openai/math/blob/{oracle.UPSTREAM_COMMIT}/lean/OAI/GameTheory/SnakyTwentyOne/Cards/Height01Part01.lean" + line = 8 + 7*card + node_name = f"card {card}" + "".join(f" / child {i}" for i in path) + return {"card": card, "inline_path": list(path), "height": data.height, + "required": oracle.points_json(data.required), "envelope": oracle.points_json(data.support), + "placement": placement_json(placement), + "certificate_ref": {"line": line, "url": base_url + f"#L{line}", + "node": node_name}} + + +def targets_on(board): + targets = [] + for symmetry in range(8): + shape = oracle.transform(oracle.SNAKY, symmetry, (0, 0)) + for dx in range(-min(x for x, _ in shape), 17 - max(x for x, _ in shape)): + for dy in range(-min(y for _, y in shape), 17 - max(y for _, y in shape)): + target = frozenset((x + dx, y + dy) for x, y in shape) + if target <= board: + targets.append((symmetry, (dx, dy), target)) + return targets + + +def winning_target(maker, targets): + for symmetry, translation, cells in targets: + if cells <= maker: + return {"symmetry": symmetry, "translation": list(translation), "cells": oracle.points_json(cells)} + return None + + +def build_step(cursor, maker, breaker, move, reply, board, cards, expressions, targets): + """Also usable for isolated replacement fixtures; not a claim of reachability.""" + data = data_at(cursor, cards, expressions) + oracle.require(not winning_target(maker, targets), "Play already ended") + oracle.require(data.required <= maker and not data.support & breaker, "Active card hypotheses fail") + oracle.require(data.support <= board, "Active support leaves board") + card, _, placement = cursor + if card < 6: + prescribed = next(iter(data.support - data.required)) + kind = "base_completion" + else: + prescribed = affine(placement, local_node(cursor, expressions).pivot) + kind = "pivot" + played = prescribed + if prescribed in maker: + played = min(board - maker - breaker) + kind = "replacement" + oracle.require(played in board - maker - breaker, "Maker move is not fresh and on board") + maker_after = maker | {played} + witness = winning_target(maker_after, targets) + step = {"move": move, "active": active_json(cursor, cards, expressions), + "maker_before": oracle.points_json(maker), "breaker_before": oracle.points_json(breaker), + "global_budget_before": 22 - move, "global_budget_after": 21 - move, + "maker": {"cell": list(played), "kind": kind, "prescribed_cell": list(prescribed)}, + "maker_after": oracle.points_json(maker_after), "breaker": None, + "breaker_after": oracle.points_json(breaker), "continuation": None, + "won": witness is not None, "witness": witness} + if witness is not None: + return step, None, maker_after, breaker + oracle.require(card >= 6, "Base completion did not win") + if reply is None: + reply = min(board - maker_after - breaker) + oracle.require(reply in board - maker_after - breaker, "Breaker reply is not fresh and on board") + breaker_after = breaker | {reply} + for index, child in enumerate(local_node(cursor, expressions).children): + nxt = next_cursor(cursor, index, child) + child_data = data_at(nxt, cards, expressions) + if reply not in child_data.support: + step["breaker"] = {"cell": list(reply)} + step["breaker_after"] = oracle.points_json(breaker_after) + step["continuation"] = { + "child_index": index, "kind": "reference" if isinstance(child, oracle.Reference) else "inline", + "source_reference": source_reference(child) if isinstance(child, oracle.Reference) else None, + "card": nxt[0], "inline_path": list(nxt[1]), "height": child_data.height, + "placement": placement_json(nxt[2]), + } + return step, nxt, maker_after, breaker_after + raise ValueError("No surviving child") + + +def build(root=ROOT): + root = Path(root) + oracle.replay(root) + payload = (root / oracle.INPUT).read_bytes() + cards, expressions, _ = oracle.reconstruct(payload) + board = cards[727].support + targets = targets_on(board) + cursor, maker, breaker = (727, (), IDENTITY), frozenset(), frozenset() + steps = [] + for move in range(1, 22): + reply = PREFIX[move - 1] if move <= len(PREFIX) else None + step, cursor, maker, breaker = build_step(cursor, maker, breaker, move, reply, board, + cards, expressions, targets) + steps.append(step) + if step["won"]: + break + oracle.require(steps[-1]["won"], "Example did not terminate within the initial move bound") + return { + "schema_version": 1, "id": EXAMPLE_ID, "title": "One Snaky play: eight Maker claims", + "kind": "illustrative_checked_execution", + "sources": { + "certificate": {"path": oracle.INPUT, "sha256": oracle.raw_digest(payload), + "url": f"https://github.com/openai/math/blob/{oracle.UPSTREAM_COMMIT}/{oracle.UPSTREAM_PATH}", + "commit": oracle.UPSTREAM_COMMIT}, + "oracle": {"path": oracle.SOURCE, "sha256": oracle.digest(root / oracle.SOURCE)}, + "generator": {"path": SOURCE, "sha256": oracle.digest(root / SOURCE)}, + "validator": {"path": VALIDATOR, "sha256": oracle.digest(root / VALIDATOR)}, + "root_claim_id": oracle.CLAIM_ID, + }, + "board": {"name": "251-cell envelope of card 727", "cells": oracle.points_json(board), + "bounds": {"x_min": 0, "x_max": 16, "y_min": 0, "y_max": 16}, "cell_count": 251}, + "choices": {"maker": "Prescribed pivot, or first free envelope cell if already owned; stop at first Snaky copy.", + "breaker": "Two displayed paper replies, then first free envelope cell in lexicographic (x,y) order.", + "breaker_prefix": [list(p) for p in PREFIX], + "continuation": "First printed child whose placed envelope avoids the legal reply."}, + "steps": steps, + "result": {"maker_claims": len(maker), "breaker_claims": len(breaker), "won": True, + "target": steps[-1]["witness"], "remaining_global_budget": 21 - len(maker)}, + "limits": LIMITS, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--check", action="store_true") + args = parser.parse_args() + import check_snaky_play + result = build() + check_snaky_play.validate(result) + path = ROOT / OUTPUT + if args.check: + oracle.require(oracle.encode(oracle.read(path)) == oracle.encode(result), "Snaky example is stale") + print("Snaky example matches its deterministic adapter and independent replay.") + else: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(oracle.encode(result)) + print(path) + + +if __name__ == "__main__": + main() diff --git a/scripts/build_snaky_presentation.py b/scripts/build_snaky_presentation.py new file mode 100644 index 0000000..f0a3eff --- /dev/null +++ b/scripts/build_snaky_presentation.py @@ -0,0 +1,101 @@ +"""Export a checked example play and exact claim with immutable evidence links. + +Saved evidence is replayed; this command does not execute Lean or a model. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path +import re +import subprocess + +import check_snaky_play as play_check +import query_context as query +import snaky_proof as proof + +ROOT = Path(__file__).resolve().parents[1] +PLAY = "evidence/snaky-play-v1/example.json" +ANCHOR = "specs/snaky-play-source-anchor.json" +OUTPUTS = ("space/snaky-play.json", "space/snaky-play-data.js") +GITHUB = "https://github.com/Maverick0351a/finite-congruence-checks/blob/" + + +def inputs(root=ROOT): + receipt = proof.replay(root=root) + record = query.explain_claim(proof.CLAIM_ID, root=root) + proof.require(query.check_record(record, root=root)["status"] == "supported", "claim query differs") + play = json.loads((root / PLAY).read_text(encoding="utf-8")) + play_check.validate(play, root=root) + proof.require(play["sources"]["root_claim_id"] == proof.CLAIM_ID, "play refers to another claim") + proof.require(play["board"]["cells"] == record["claim"]["values"]["envelope"], "play board differs from proved envelope") + paths = set(receipt["source_hashes"]) + paths.update(proof.RECEIPT + "/" + name for name in receipt["artifacts"]) + paths.update((proof.RECEIPT + "/summary.json", proof.finite.OUTPUT, PLAY, + "scripts/build_snaky_play.py", "scripts/check_snaky_play.py")) + return play, record, sorted(paths) + + +def check_anchor(root, anchor, paths): + proof.require(type(anchor) is dict and set(anchor) == {"schema_version", "revision", "files"}, "invalid source anchor fields") + proof.require(type(anchor["schema_version"]) is int and anchor["schema_version"] == 1, "invalid source anchor version") + proof.require(type(anchor.get("revision")) is str and re.fullmatch(r"[0-9a-f]{40}", anchor["revision"]), "invalid source revision") + proof.require(type(anchor["files"]) is dict and all(type(value) is str and re.fullmatch(r"[0-9a-f]{64}", value) for value in anchor["files"].values()), "invalid source anchor hashes") + proof.require(set(anchor["files"]) == set(paths), "source anchor coverage differs") + for path in paths: + proof.require(proof.digest(root / path) == anchor["files"][path], "local anchored source changed: " + path) + result = subprocess.run(["git", "show", anchor["revision"] + ":" + path], cwd=root, + capture_output=True, timeout=30) + proof.require(result.returncode == 0, "anchored Git file unavailable: " + path + "; use a full checkout") + proof.require(proof.finite.raw_digest(result.stdout.replace(b"\r\n", b"\n")) == anchor["files"][path], "Git bytes differ: " + path) + + +def build(root=ROOT): + play, record, paths = inputs(root) + anchor = proof.read(root / ANCHOR) + check_anchor(root, anchor, paths) + base = GITHUB + anchor["revision"] + "/" + evidence = [ + {"title": "The exact recorded execution", "description": "All chosen moves, complete ownership sets, certificate placements and the six-cell winning witness. The independent checker replays this one branch.", "path": PLAY}, + {"title": "The formal strategy guarantee", "description": "The Lean theorem covers every legal reply on the exact finite board, within 21 Maker claims. The source paper already states this finite-board result.", "path": proof.PROJECT + "/SnakyFinite.lean"}, + {"title": "The claim and its verification", "description": "The receipt records the build, kernel replay, allowed axioms and deliberate mismatched-claim rejections. Offline receipt replay is not a new proof execution.", "path": proof.RECEIPT + "/summary.json"}, + ] + for entry in evidence: + entry.update(url=base + entry["path"], sha256=anchor["files"][entry["path"]]) + return {"schema_version": 1, "id": "context:family-187:snaky:illustrative-play:v1", + "source_revision": anchor["revision"], "play": play, "claim_record": record, + "evidence": evidence, + "commands": ["python scripts/check_snaky_play.py", + "python scripts/query_context.py explain " + proof.CLAIM_ID + " --out snaky.json", + "python scripts/query_context.py check snaky.json", + "python scripts/snaky_proof.py run --out runs/snaky-fresh"]} + + +def output_texts(data): + payload = proof.encode(data).decode() + return payload, "window.SNAKY_PLAY_DATA = " + payload.rstrip() + ";\n" + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--check", action="store_true") + parser.add_argument("--anchor", help="Commit containing every checked proof and play input") + args = parser.parse_args() + if args.anchor: + proof.require(not args.check, "anchor creation and checking are separate operations") + _, _, paths = inputs() + anchor = {"schema_version": 1, "revision": args.anchor, + "files": {path: proof.digest(ROOT / path) for path in paths}} + check_anchor(ROOT, anchor, paths) + (ROOT / ANCHOR).write_bytes(proof.encode(anchor)) + data = build() + for path, text in zip(OUTPUTS, output_texts(data)): + if args.check: + proof.require((ROOT / path).read_text(encoding="utf-8") == text, "stale presentation: " + path) + else: + (ROOT / path).write_bytes(text.encode()) + print("PASS: illustrative Snaky play, exact claim, and immutable evidence links agree") + + +if __name__ == "__main__": + main() diff --git a/scripts/check_snaky.py b/scripts/check_snaky.py new file mode 100644 index 0000000..c5b76ad --- /dev/null +++ b/scripts/check_snaky.py @@ -0,0 +1,319 @@ +"""Independent reconstruction of the exact 728-card Snaky certificate. + +This evaluator uses an explicit syntax tree, eight integer matrices, and literal +finite sets. It imports neither the upstream evaluator nor Lean-generated data. +It checks finite certificate arithmetic, not the game-strategy theorem. +""" +from __future__ import annotations + +import argparse +from dataclasses import dataclass +from functools import reduce +import hashlib +import json +from pathlib import Path +import re +import sys + +ROOT = Path(__file__).resolve().parents[1] +INPUT = "evidence/snaky-finite-v1/certificate.txt" +OUTPUT = "evidence/snaky-finite-v1/computational.json" +SOURCE = "scripts/check_snaky.py" +CLAIM_ID = "context:family-187:snaky:finite-board-21:v1" +HASH_ENCODING = "SHA-256 of UTF-8 file bytes with CRLF normalized to LF; no other byte changes." +UPSTREAM_COMMIT = "1581d4cbdd69a0faf34b2089614fe2a814316a6a" +UPSTREAM_PATH = "preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt" +CERTIFICATE_SHA256 = "3fa12d36a6d4dbb185e3f2808c8dfde13d85ee309afbca030d6ad17ae9fe3d04" +ALPHABET = "0123456789ABCDEFG" +SNAKY = ((0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)) +# Rows (a,b,c,d) mean (x,y) -> (a*x+b*y,c*x+d*y). +MATRICES = ((1, 0, 0, 1), (0, 1, 1, 0), (-1, 0, 0, 1), + (0, 1, -1, 0), (1, 0, 0, -1), (0, -1, 1, 0), + (-1, 0, 0, -1), (0, -1, -1, 0)) +Point = tuple[int, int] + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def encode(value): + return (json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n").encode("utf-8") + + +def _unique_object(pairs): + result = {} + for key, value in pairs: + require(key not in result, "Duplicate JSON key: " + key) + result[key] = value + return result + + +def read(path): + return json.loads(Path(path).read_text(encoding="utf-8"), object_pairs_hook=_unique_object) + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes().replace(b"\r\n", b"\n")).hexdigest() + + +def raw_digest(payload): + return hashlib.sha256(payload).hexdigest() + + +def points_json(points): + return [list(p) for p in sorted(points)] + + +def point_digest(points): + return raw_digest(encode(points_json(points))) + + +@dataclass(frozen=True) +class Reference: + index: int + symmetry: int = 0 + translation: Point = (0, 0) + + +@dataclass(frozen=True) +class Combination: + pivot: Point + children: tuple[Reference | Combination, ...] + + +@dataclass(frozen=True) +class Card: + required: frozenset[Point] + support: frozenset[Point] + height: int + + +def parse_point(word): + require(len(word) == 2 and all(c in ALPHABET for c in word), + "Invalid encoded point: " + word) + return tuple(ALPHABET.index(c) for c in word) + + +def parse_reference(word, earlier_count): + require(re.fullmatch(r"(?:0|[1-9][0-9]*)(?::[0-7][0-9A-G]{2})?", word) is not None, + "Invalid reference: " + word) + pieces = word.split(":") + index = int(pieces[0]) + require(index < earlier_count, "Reference must name an earlier card: " + word) + if len(pieces) == 1: + return Reference(index) + return Reference(index, int(pieces[1][0]), parse_point(pieces[1][1:])) + + +def parse_line(line, expected_index): + """Parse before evaluating; every nested reference shares the line's bound.""" + words = re.findall(r"[()]|[^\s()]+", line) + require(len(words) >= 3, "A card needs an index, pivot, and nonempty child list") + require(words[0] == str(expected_index), "Unexpected card number: " + words[0]) + cursor = 1 + + def combine(nested, depth): + nonlocal cursor + require(depth <= 128, "Expression nesting exceeds the parser limit") + require(cursor < len(words), "Missing pivot") + pivot = parse_point(words[cursor]) + cursor += 1 + children = [] + while cursor < len(words) and words[cursor] != ")": + word = words[cursor] + cursor += 1 + if word == "(": + children.append(combine(True, depth + 1)) + else: + children.append(parse_reference(word, expected_index)) + require(bool(children), "A combination needs at least one child") + if nested: + require(cursor < len(words) and words[cursor] == ")", "Unclosed expression") + cursor += 1 + return Combination(pivot, tuple(children)) + + expression = combine(False, 0) + require(cursor == len(words), "Unexpected closing parenthesis or trailing tokens") + return expression + + +def transform(points, symmetry, translation): + require(type(symmetry) is int and 0 <= symmetry < 8, "Invalid symmetry index") + require(len(translation) == 2 and all(type(c) is int for c in translation), + "Translation must be two integers") + a, b, c, d = MATRICES[symmetry] + dx, dy = translation + require(abs(a * d - b * c) == 1, "Placement matrix must be invertible") + return frozenset((a*x + b*y + dx, c*x + d*y + dy) for x, y in points) + + +def place(card, reference): + placed = Card(transform(card.required, reference.symmetry, reference.translation), + transform(card.support, reference.symmetry, reference.translation), card.height) + require(len(placed.required) == len(card.required) and len(placed.support) == len(card.support), + "Placement must preserve cardinalities") + return placed + + +def combine_cards(pivot, children): + require(bool(children), "A combination needs at least one child") + require(all(type(c.height) is int and c.height >= 1 for c in children), "Child height must be a positive integer") + require(all(c.required <= c.support for c in children), "Child requirements leave its support") + common = reduce(frozenset.intersection, (c.support for c in children)) + requirements = frozenset().union(*(c.required for c in children)) + required = (requirements | common) - {pivot} + support = frozenset({pivot}).union(*(c.support for c in children)) + result = Card(required, support, 1 + max(c.height for c in children)) + # These are the local hypotheses used by the separate game proof. + require(result.required <= result.support, "Parent requirements leave its support") + require(pivot in result.support, "Pivot leaves parent support") + require(all(c.support <= result.support for c in children), "Child support leaves parent support") + require(all(c.required <= result.required | {pivot} for c in children), "Unprepared child requirement") + require(common <= result.required | {pivot}, "Common support is not prepared by the pivot") + require(all(c.height < result.height for c in children), "Child height must decrease") + return result + + +def evaluate(expression, earlier_cards, counters=None, depth=0): + if isinstance(expression, Reference): + if counters is not None: + counters["reference_nodes"] += 1 + return place(earlier_cards[expression.index], expression) + if counters is not None: + counters["combination_nodes"] += 1 + counters["maximum_inline_depth"] = max(counters["maximum_inline_depth"], depth) + children = [evaluate(c, earlier_cards, counters, depth + 1) for c in expression.children] + return combine_cards(expression.pivot, children) + + +def reconstruct(payload): + require(isinstance(payload, bytes), "Certificate input must be bytes") + try: + source = payload.decode("ascii") + except UnicodeDecodeError as exc: + raise ValueError("Certificate must be ASCII") from exc + lines = source.splitlines() + require(bool(lines) and all(line.strip() for line in lines), "Empty certificate or blank data line") + target = frozenset(SNAKY) + cards = [Card(target - {point}, target, 1) for point in SNAKY] + expressions = [] + counters = {"combination_nodes": 0, "reference_nodes": 0, "maximum_inline_depth": 0} + for index, line in enumerate(lines, start=6): + expression = parse_line(line, index) + cards.append(evaluate(expression, cards, counters)) + expressions.append(expression) + return tuple(cards), tuple(expressions), counters + + +def validate_endpoint(cards, expressions, *, board_bounds=(0, 16, 0, 16), move_bound=21): + require(len(board_bounds) == 4 and all(type(c) is int for c in board_bounds) + and board_bounds == (0, 16, 0, 16), "This claim is bound to the exact 17 by 17 square") + require(type(move_bound) is int and move_bound == 21, "This claim is bound to 21 Maker moves") + require(len(cards) == 728 and len(expressions) == 722, "Expected 728 cards including six bases") + final = cards[-1] + require(expressions[-1].pivot == (8, 8), "Final pivot must be (8,8)") + require(not final.required, "Final required set must be empty") + require(len(final.support) == 251, "Final support must contain exactly 251 cells") + require(final.height == 21 and max(c.height for c in cards) == 21, "Incorrect certificate height") + require(all(0 <= x <= 16 and 0 <= y <= 16 for x, y in final.support), "Final support leaves the board") + # Occupancy is a finite arithmetic bound; the separate Lean proof supplies + # its connection to legal alternating play and actual Maker claims. + require(2 * (move_bound - 1) == 40 < len(final.support), "Insufficient room for replacement moves") + + +def audit(root=ROOT): + root = Path(root) + payload = (root / INPUT).read_bytes() + require(raw_digest(payload) == CERTIFICATE_SHA256, "Pinned certificate raw-byte SHA256 mismatch") + cards, expressions, counters = reconstruct(payload) + validate_endpoint(cards, expressions) + final = cards[-1] + top = expressions[-1] + require(len(top.children) == 32 and all(isinstance(c, Reference) for c in top.children), + "Expected the final 32 placed references") + child_records = [] + common = final.support + for number, reference in enumerate(top.children): + child = evaluate(reference, cards[:727]) + require(child.required == {(8, 8)}, "Final child requirement must be the pivot") + common &= child.support + child_records.append({"position": number, "card": reference.index, + "symmetry": reference.symmetry, "translation": list(reference.translation), + "height": child.height, "required": points_json(child.required), + "support_count": len(child.support), "support_sha256": point_digest(child.support), + "common_cells_other_than_pivot": len(common - {(8, 8)})}) + require(common == {(8, 8)}, "Final child intersection must be the singleton pivot") + group_sizes = (4, 4, 8, 4, 8, 4) + ends = [] + offset = 0 + for size in group_sizes: + offset += size + record = child_records[offset - 1] + ends.append({"card": record["card"], "placements": size, + "remaining_cells_other_than_pivot": record["common_cells_other_than_pivot"]}) + require([r["card"] for r in ends] == [648, 708, 712, 713, 725, 726], "Unexpected final child groups") + require([r["remaining_cells_other_than_pivot"] for r in ends] == [35, 31, 21, 12, 4, 0], + "Unexpected successive final intersections") + return { + "schema_version": 1, "id": CLAIM_ID, "kind": "independent_finite_certificate_audit", "status": "PASS", + "upstream": {"repository": "openai/math", "commit": UPSTREAM_COMMIT, "path": UPSTREAM_PATH, + "url": f"https://github.com/openai/math/blob/{UPSTREAM_COMMIT}/{UPSTREAM_PATH}", + "certificate_sha256": raw_digest(payload), "byte_length": len(payload), + "hash_encoding": "SHA-256 of exact original certificate bytes; no newline normalization."}, + "checker": {"path": SOURCE, "sha256": digest(root / SOURCE), "hash_encoding": HASH_ENCODING}, + "counts": {"numbered_cards": len(cards), "explicit_lines": len(expressions), "base_cards": 6, + "maximum_height": max(c.height for c in cards), **counters}, + "checked_local_obligations": ["Backward references and nonempty child lists at every expression", + "All eight placements are invertible signed coordinate permutations", + "Every requirement lies in its support", + "Every child support and pivot lies in its parent support", + "Child requirements and common support lie in parent requirements plus pivot", + "Height strictly decreases when passing to a child"], + "final": {"index": 727, "pivot": list(top.pivot), "required": points_json(final.required), + "support": points_json(final.support), "required_count": len(final.required), + "support_count": len(final.support), "height": final.height, + "support_sha256": point_digest(final.support)}, + "finite_board": {"bounds": {"x_min": 0, "x_max": 16, "y_min": 0, "y_max": 16}, + "square_cells": 289, "envelope_cells": 251, "max_maker_moves": 21, + "max_occupied_before_maker_move": 40, "min_free_envelope_cells": 211, + "occupancy_assumptions": "Empty board; alternating single fresh-cell claims; Maker first."}, + "cards": [{"index": i, "required_count": len(c.required), "support_count": len(c.support), + "height": c.height, "required_sha256": point_digest(c.required), + "support_sha256": point_digest(c.support)} for i, c in enumerate(cards)], + "final_children": child_records, "successive_intersections": ends, + "limits": ["Reconstruction checks this exact finite certificate, not a complete strategy search.", + "The game-strategy implication and quantifier order require the separate Lean theorem.", + "The 728-card theorem certificate is distinct from the historical 616-row comparator.", + "The 21-move bound and finite-board result are already stated in the source paper.", + "No claim of a 20-move strategy, novelty, or improved agent reasoning."]} + + +def replay(root=ROOT): + root = Path(root) + actual = audit(root) + saved = read(root / OUTPUT) + require(encode(saved) == encode(actual), "Saved Snaky computational receipt differs from independent reconstruction") + return actual + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("command", choices=("check", "replay")) + args = parser.parse_args(argv) + try: + result = audit() if args.command == "check" else replay() + if args.command == "check": + (ROOT / OUTPUT).write_bytes(encode(result)) + print(json.dumps({"status": "PASS", "command": args.command, "claim_id": CLAIM_ID, + "cards": result["counts"]["numbered_cards"], "final_cells": result["final"]["support_count"], + "height": result["final"]["height"], "output": OUTPUT}, sort_keys=True)) + return 0 + except (OSError, ValueError, KeyError, TypeError) as exc: + print("Snaky audit failed: " + str(exc), file=sys.stderr) + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/check_snaky_play.py b/scripts/check_snaky_play.py new file mode 100644 index 0000000..ba939c2 --- /dev/null +++ b/scripts/check_snaky_play.py @@ -0,0 +1,287 @@ +"""Replay one Snaky example without importing its move generator. + +The frozen oracle supplies the pinned certificate grammar only. This module +reconstructs sets using separate coordinate formulas, composes placements by +their action on basis points, and checks each supplied move against the actual +position. This is finite execution evidence, not a verified policy extraction. +""" +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import check_snaky as oracle + +ROOT = Path(__file__).resolve().parents[1] +INPUT = "evidence/snaky-play-v1/example.json" +SOURCE = "scripts/check_snaky_play.py" +GENERATOR = "scripts/build_snaky_play.py" +EXAMPLE_ID = "example:family-187:snaky:eight-claim-branch:v1" +IDENTITY = (1, 0, 0, 1, 0, 0) +SHAPE = ((0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 1)) +FORMS = (lambda x,y:(x,y), lambda x,y:(y,x), lambda x,y:(-x,y), lambda x,y:(y,-x), + lambda x,y:(x,-y), lambda x,y:(-y,x), lambda x,y:(-x,-y), lambda x,y:(-y,-x)) +LIMITS = [ + "One illustrative checked execution with chosen legal Breaker replies.", + "Eight Maker claims in this example do not establish an eight-move guarantee.", + "The Python move adapter is not an extracted formally verified policy.", + "This record binds certificate and implementation inputs, not a successful Lean proof receipt.", + "The 21-move universal theorem and its proof receipt are separate evidence.", +] + + +def same(actual, expected, label): + oracle.require(json.dumps(actual, sort_keys=True, allow_nan=False) == + json.dumps(expected, sort_keys=True, allow_nan=False), label + " mismatch") + + +def keys(value, required, label): + oracle.require(isinstance(value, dict) and set(value) == set(required.split()), label + " fields mismatch") + + +def points(value, label): + oracle.require(isinstance(value, list), label + " must be a list") + for point in value: + oracle.require(isinstance(point, list) and len(point) == 2 and all(type(c) is int for c in point), + label + " must contain integer coordinate pairs") + result = frozenset(tuple(p) for p in value) + same(value, oracle.points_json(result), label + " canonical coordinates") + return result + + +def transform(points_, symmetry, translation): + f = FORMS[symmetry] + return frozenset((f(x, y)[0] + translation[0], f(x, y)[1] + translation[1]) for x, y in points_) + + +def evaluate(node, earlier): + if isinstance(node, oracle.Reference): + required, support, height = earlier[node.index] + return transform(required, node.symmetry, node.translation), transform(support, node.symmetry, node.translation), height + children = [evaluate(c, earlier) for c in node.children] + support = {node.pivot} + required = set() + for a, t, _ in children: + support.update(t) + required.update(a) + common = {p for p in children[0][1] if all(p in child[1] for child in children[1:])} + required.update(common) + required.discard(node.pivot) + return frozenset(required), frozenset(support), 1 + max(c[2] for c in children) + + +def reconstruct(root=ROOT): + root = Path(root) + payload = (root / oracle.INPUT).read_bytes() + oracle.require(oracle.raw_digest(payload) == oracle.CERTIFICATE_SHA256, "Pinned certificate bytes changed") + cards = [(frozenset(SHAPE) - {p}, frozenset(SHAPE), 1) for p in SHAPE] + expressions = [] + for index, line in enumerate(payload.decode("ascii").splitlines(), 6): + node = oracle.parse_line(line, index) + cards.append(evaluate(node, cards)) + expressions.append(node) + oracle.require(len(cards) == 728 and len(cards[-1][1]) == 251 and cards[-1][2] == 21 and not cards[-1][0], + "Certificate endpoint mismatch") + return cards, expressions + + +def apply(placement, point): + a, b, c, d, tx, ty = placement + return a*point[0] + b*point[1] + tx, c*point[0] + d*point[1] + ty + + +def compose(placement, ref): + # Determine F o G by its images of 0,e1,e2, independently of the + # generator's symbolic matrix-product formula. + f = FORMS[ref.symmetry] + def image(point): + x, y = f(*point) + return apply(placement, (x + ref.translation[0], y + ref.translation[1])) + zero, first, second = image((0, 0)), image((1, 0)), image((0, 1)) + return (first[0]-zero[0], second[0]-zero[0], first[1]-zero[1], second[1]-zero[1], *zero) + + +def place_json(placement): + return {"matrix": [list(placement[:2]), list(placement[2:4])], "translation": list(placement[4:])} + + +def node_at(cursor, expressions): + card, path, _ = cursor + if card < 6: + oracle.require(not path, "A base has no inline children") + return None + node = expressions[card-6] + for index in path: + oracle.require(isinstance(node, oracle.Combination) and 0 <= index < len(node.children), "Invalid inline path") + node = node.children[index] + oracle.require(isinstance(node, oracle.Combination), "Inline path must end at a combination") + return node + + +def data_at(cursor, cards, expressions): + card, _, placement = cursor + data = cards[card] if card < 6 else evaluate(node_at(cursor, expressions), cards[:card]) + return frozenset(apply(placement, p) for p in data[0]), frozenset(apply(placement, p) for p in data[1]), data[2] + + +def child_cursor(cursor, index, child): + if isinstance(child, oracle.Reference): + return child.index, (), compose(cursor[2], child) + return cursor[0], cursor[1] + (index,), cursor[2] + + +def snapshot(cursor, cards, expressions): + required, support, height = data_at(cursor, cards, expressions) + card, path, placement = cursor + url = f"https://github.com/openai/math/blob/{oracle.UPSTREAM_COMMIT}/{oracle.UPSTREAM_PATH}" + line = card-5 + if card < 6: + url = f"https://github.com/openai/math/blob/{oracle.UPSTREAM_COMMIT}/lean/OAI/GameTheory/SnakyTwentyOne/Cards/Height01Part01.lean" + line = 8 + 7*card + return {"card": card, "inline_path": list(path), "height": height, + "required": oracle.points_json(required), "envelope": oracle.points_json(support), + "placement": place_json(placement), + "certificate_ref": {"line": line, "url": url + f"#L{line}", + "node": f"card {card}" + "".join(f" / child {i}" for i in path)}} + + +def witness(maker, board): + # Every transformed copy includes the image of (0,0), its translation. + # Thus every possible translation lies in Maker's current cells. + for symmetry, f in enumerate(FORMS): + for translation in sorted(maker): + cells = frozenset((f(x, y)[0] + translation[0], f(x, y)[1] + translation[1]) for x, y in SHAPE) + if cells <= maker and cells <= board: + return {"symmetry": symmetry, "translation": list(translation), "cells": oracle.points_json(cells)} + return None + + +def validate_step(step, cursor, maker, breaker, board, cards, expressions): + """Check one local transition. Whole-play reachability is checked by validate.""" + keys(step, "move active maker_before breaker_before global_budget_before global_budget_after maker maker_after breaker breaker_after continuation won witness", "Step") + move = step["move"] + oracle.require(type(move) is int and 1 <= move <= 21, "Invalid Maker move count") + oracle.require(len(maker) == len(breaker) == move-1, "Alternating move counts mismatch") + oracle.require(maker <= board and breaker <= board and not maker & breaker, "Invalid ownership position") + same(step["maker_before"], oracle.points_json(maker), "Maker state before") + same(step["breaker_before"], oracle.points_json(breaker), "Breaker state before") + same(step["active"], snapshot(cursor, cards, expressions), "Active certificate placement") + same(step["global_budget_before"], 22-move, "Global budget before") + same(step["global_budget_after"], 21-move, "Global budget after") + required, support, height = data_at(cursor, cards, expressions) + oracle.require(required <= maker and not support & breaker and support <= board, "Active card hypotheses fail") + oracle.require(height <= 22-move and len(maker) + len(breaker) + 2*height <= len(board), "Insufficient remaining move budget") + oracle.require(witness(maker, board) is None, "Play continued after an earlier win") + card, _, placement = cursor + if card < 6: + missing = support - required + oracle.require(len(missing) == 1, "Base must have exactly one completion cell") + prescribed = next(iter(missing)) + kind = "base_completion" + else: + prescribed = apply(placement, node_at(cursor, expressions).pivot) + kind = "pivot" + expected = prescribed + if prescribed in maker: + free = board - maker - breaker + oracle.require(bool(free), "No replacement cell available") + expected, kind = min(free), "replacement" + oracle.require(expected in board - maker - breaker, "Maker claim must be fresh and on board") + same(step["maker"], {"cell": list(expected), "kind": kind, "prescribed_cell": list(prescribed)}, "Maker claim") + after_maker = maker | {expected} + same(step["maker_after"], oracle.points_json(after_maker), "Maker state after") + won = witness(after_maker, board) + same(step["won"], won is not None, "Terminal status") + same(step["witness"], won, "Complete target witness") + if won is not None: + oracle.require(step["breaker"] is None and step["continuation"] is None, "No Breaker reply or continuation after victory") + same(step["breaker_after"], oracle.points_json(breaker), "Breaker state at victory") + return None, after_maker, breaker + oracle.require(card >= 6, "Base completion must win") + keys(step["breaker"], "cell", "Breaker reply") + reply_points = points([step["breaker"]["cell"]], "Breaker reply") + reply = next(iter(reply_points)) + oracle.require(reply in board - after_maker - breaker, "Breaker reply must be fresh and on board") + expected_reply = ((7, 8), (8, 6))[move-1] if move <= 2 else min(board - after_maker - breaker) + oracle.require(reply == expected_reply, "Breaker reply differs from this example's declared choices") + after_breaker = breaker | {reply} + same(step["breaker_after"], oracle.points_json(after_breaker), "Breaker state after") + candidates = [] + for index, child in enumerate(node_at(cursor, expressions).children): + nxt = child_cursor(cursor, index, child) + child_required, child_support, child_height = data_at(nxt, cards, expressions) + oracle.require(child_required <= after_maker and child_support <= support and child_height < height, + "Child requirement, containment, or decreasing-height condition failed") + candidates.append((index, child, nxt, child_required, child_support, child_height)) + common = set(candidates[0][4]).intersection(*(c[4] for c in candidates[1:])) + oracle.require(common <= after_maker, "Common envelope was not secured by Maker") + chosen = next((c for c in candidates if reply not in c[4]), None) + oracle.require(chosen is not None, "No child survives the legal Breaker reply") + index, child, nxt, _, child_support, child_height = chosen + oracle.require(not child_support & after_breaker, "Chosen child contains an older Breaker claim") + reference = None + if isinstance(child, oracle.Reference): + reference = str(child.index) + if child.symmetry != 0 or child.translation != (0, 0): + reference += f":{child.symmetry}{oracle.ALPHABET[child.translation[0]]}{oracle.ALPHABET[child.translation[1]]}" + same(step["continuation"], {"child_index": index, "kind": "reference" if reference is not None else "inline", + "source_reference": reference, "card": nxt[0], "inline_path": list(nxt[1]), + "height": child_height, "placement": place_json(nxt[2])}, "Surviving continuation") + return nxt, after_maker, after_breaker + + +def validate(record, root=ROOT): + root = Path(root) + keys(record, "schema_version id title kind sources board choices steps result limits", "Example") + same(record["schema_version"], 1, "Schema version") + same(record["id"], EXAMPLE_ID, "Example identity") + same(record["title"], "One Snaky play: eight Maker claims", "Example title") + same(record["kind"], "illustrative_checked_execution", "Evidence kind") + same(record["limits"], LIMITS, "Evidence limits") + url = f"https://github.com/openai/math/blob/{oracle.UPSTREAM_COMMIT}/{oracle.UPSTREAM_PATH}" + same(record["sources"], { + "certificate": {"path": oracle.INPUT, "sha256": oracle.CERTIFICATE_SHA256, "url": url, "commit": oracle.UPSTREAM_COMMIT}, + "oracle": {"path": oracle.SOURCE, "sha256": oracle.digest(root / oracle.SOURCE)}, + "generator": {"path": GENERATOR, "sha256": oracle.digest(root / GENERATOR)}, + "validator": {"path": SOURCE, "sha256": oracle.digest(root / SOURCE)}, + "root_claim_id": oracle.CLAIM_ID}, "Exact input and implementation hashes") + cards, expressions = reconstruct(root) + board = cards[727][1] + same(record["board"], {"name": "251-cell envelope of card 727", "cells": oracle.points_json(board), + "bounds": {"x_min": 0, "x_max": 16, "y_min": 0, "y_max": 16}, "cell_count": 251}, "Exact board") + same(record["choices"], { + "maker": "Prescribed pivot, or first free envelope cell if already owned; stop at first Snaky copy.", + "breaker": "Two displayed paper replies, then first free envelope cell in lexicographic (x,y) order.", + "breaker_prefix": [[7, 8], [8, 6]], + "continuation": "First printed child whose placed envelope avoids the legal reply."}, "Declared example choices") + steps = record["steps"] + oracle.require(isinstance(steps, list) and 1 <= len(steps) <= 21, "Invalid trace length") + cursor, maker, breaker = (727, (), IDENTITY), frozenset(), frozenset() + for number, step in enumerate(steps, 1): + oracle.require(cursor is not None, "Extra step after victory") + oracle.require(isinstance(step, dict), "Each step must be an object") + same(step.get("move"), number, "Consecutive move number") + cursor, maker, breaker = validate_step(step, cursor, maker, breaker, board, cards, expressions) + oracle.require(cursor is None and witness(maker, board) is not None, "Trace stops before a checked win") + same(record["result"], {"maker_claims": len(maker), "breaker_claims": len(breaker), "won": True, + "target": witness(maker, board), "remaining_global_budget": 21-len(maker)}, "Final result") + oracle.require(len(maker) == 8 and len(breaker) == 7, "This registered example has eight Maker claims and seven replies") + return record + + +def replay(root=ROOT): + return validate(oracle.read(Path(root) / INPUT), root) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--path", type=Path, default=ROOT / INPUT) + args = parser.parse_args() + result = validate(oracle.read(args.path)) + print(json.dumps({"status": "PASS", "example_id": result["id"], "maker_claims": 8, "breaker_replies": 7, + "scope": "One illustrative execution; no eight-move guarantee or verified policy extraction."}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/scripts/check_snaky_play_ui.cjs b/scripts/check_snaky_play_ui.cjs new file mode 100644 index 0000000..6fb2a2b --- /dev/null +++ b/scripts/check_snaky_play_ui.cjs @@ -0,0 +1,153 @@ +/* Exercise the actual Snaky renderer against every saved state, without Lean. */ +'use strict'; +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const vm = require('node:vm'); +const root = path.resolve(__dirname, '..'); +const app = require('../space/snaky-play.js'); +const read = relative => fs.readFileSync(path.join(root, relative), 'utf8'); +const json = relative => JSON.parse(read(relative)); +const plain = value => JSON.parse(JSON.stringify(value)); +const sorted = cells => cells.map(p => p.join(',')).sort(); +assert(process.argv.slice(2).every(arg => arg === '--example-only'), 'Unknown command option'); +const exampleOnly = process.argv.includes('--example-only'); +const play = json('evidence/snaky-play-v1/example.json'); +let data; +if (exampleOnly) { + // Explicit development mode: this checks real saved states, with no proof claim. + data = {schema_version: 1, play, evidence: [], commands: []}; +} else { + // No fallback: CI must fail if publication prerequisites have not been created. + data = json('space/snaky-play.json'); + const context = {window: {}}; + vm.runInNewContext(read('space/snaky-play-data.js'), context); + assert.deepEqual(plain(context.window.SNAKY_PLAY_DATA), data, 'Offline JS and download JSON must agree'); + assert.deepEqual(data.play, play, 'The displayed play must match the independently checked record'); + const anchor = json('specs/snaky-play-source-anchor.json'); + assert.match(data.source_revision, /^[0-9a-f]{40}$/); + assert.equal(data.source_revision, anchor.revision); + assert.equal(data.claim_record.claim.id, play.sources.root_claim_id); + assert.deepEqual(data.claim_record.claim.values.envelope, play.board.cells); + assert.equal(data.claim_record.claim.conclusion.maker_claims_at_most, 21); + assert.equal(data.evidence.length, 3); + for (const item of data.evidence) { + assert.equal(item.url, `https://github.com/Maverick0351a/finite-congruence-checks/blob/${anchor.revision}/${item.path}`); + assert.equal(item.sha256, anchor.files[item.path]); + assert.match(item.sha256, /^[0-9a-f]{64}$/); + } +} + +assert.equal(play.steps.length, 8); +assert.equal(play.board.cells.length, 251); +const finalCells = [[8,7],[8,8],[8,9],[8,10],[9,10],[9,11]]; +assert.deepEqual(play.result.target.cells, finalCells); +assert.deepEqual(play.steps.map(s => s.active.height), [21,20,18,14,7,3,2,1]); +assert.equal(play.result.remaining_global_budget, 13); +for (const invalid of [-1, 8, 0.5, NaN, '1', null]) { + assert.throws(() => app.viewOf(data, invalid), /Unknown move/); +} + +const html = read('space/snaky-play.html'); +const js = read('space/snaky-play.js'); +const ids = [...html.matchAll(/\bid="([^"]+)"/g)].map(m => m[1]); +assert.equal(new Set(ids).size, ids.length, 'HTML IDs must be unique'); +for (const [, id] of js.matchAll(/el\("([^"]+)"\)/g)) assert(ids.includes(id), `Missing renderer target ${id}`); +assert(html.includes('for="snaky-step"')); +assert(/ +
+
● M: Maker× B: BreakerOutlined cells: surviving plan's envelopeMuted cells: outside this board

Coordinates label individual squares. Numbers inside occupied squares give the round they were claimed. Each displayed state is after the selected round, or immediately after the winning Maker claim. On a narrow screen, scroll the board sideways; keyboard users can focus it and use the arrow keys.

+ +
+
Read the complete move list without the diagram
+ + + +

02 / The local reason

One reply cannot block every route.

Start from a certificate card

A card lists cells Maker must already own, an envelope free of Breaker cells, and a bound on the additional Maker claims needed.

Make a fresh claim

Maker claims the card's pivot. If Maker already owns it, a fresh replacement still costs one move. The finite-board argument ensures such a square is available.

Keep a surviving continuation

Every cell shared by all child envelopes is already owned by Maker. Breaker must claim a fresh cell, so its reply cannot spoil every child. Maker follows one that remains available.

TWO DIFFERENT COUNTS

The chosen child may have a much smaller bound. That does not mean Maker played several moves at once. The viewer keeps actual claims, the 21-claim allowance, and each card's remaining bound separate.

+

03 / Follow the exact evidence

What supports this explanation?

The browser displays saved states; it does not run Lean. A separate checker replays this particular execution. The Lean theorem establishes the strategy guarantee under its formal game rules. The displayed execution is not a formally verified extraction of that strategy.

The paper already supplies the finite-board result. This project checks the certificate and formalizes the finite-board guarantee. The example does not establish a better move bound, optimality, or improved AI reasoning.

+ + + + diff --git a/space/snaky-play.js b/space/snaky-play.js new file mode 100644 index 0000000..b39374d --- /dev/null +++ b/space/snaky-play.js @@ -0,0 +1,105 @@ +(function () { + "use strict"; + const pointKey = cell => cell.join(","); + const pointText = cell => `(${cell[0]}, ${cell[1]})`; + + function viewOf(data, index) { + if (!Number.isInteger(index) || index < 0 || index >= data.play.steps.length) throw new Error("Unknown move"); + const step = data.play.steps[index]; + const next = data.play.steps[index + 1]; + const envelope = next ? next.active.envelope : []; + return {step, envelope, winner: step.witness ? step.witness.cells : [], + makerTurns: new Map(data.play.steps.slice(0, index + 1).map(s => [pointKey(s.maker.cell), s.move])), + breakerTurns: new Map(data.play.steps.slice(0, index + 1).filter(s => s.breaker).map(s => [pointKey(s.breaker.cell), s.move]))}; + } + + if (typeof module !== "undefined" && module.exports) module.exports = {pointKey, pointText, viewOf}; + if (typeof document === "undefined") return; + const el = id => document.getElementById(id); + const node = (tag, text, className) => { + const result = document.createElement(tag); + if (text !== undefined) result.textContent = text; + if (className) result.className = className; + return result; + }; + const svgNode = (tag, attrs, text) => { + const result = document.createElementNS("http://www.w3.org/2000/svg", tag); + for (const [key, value] of Object.entries(attrs)) result.setAttribute(key, String(value)); + if (text !== undefined) result.textContent = text; + return result; + }; + + function drawBoard(data, view) { + const svg = svgNode("svg", {viewBox: "0 0 468 472", role: "img", "aria-labelledby": "snaky-board-title snaky-board-desc"}); + svg.append(svgNode("title", {id: "snaky-board-title"}, `Board after Maker move ${view.step.move}`)); + svg.append(svgNode("desc", {id: "snaky-board-desc"}, `${view.step.maker_after.length} Maker cells and ${view.step.breaker_after.length} Breaker cells. ${view.step.won ? "Maker owns a complete Snaky." : "The outlined continuation envelope remains free of Breaker cells."} The complete coordinates are available in the move list and download.`)); + const board = new Set(data.play.board.cells.map(pointKey)); + const envelope = new Set(view.envelope.map(pointKey)); + const winner = new Set(view.winner.map(pointKey)); + for (let y = 0; y <= 16; y++) for (let x = 0; x <= 16; x++) { + const key = pointKey([x, y]), px = 28 + 25 * x, py = 12 + 25 * (16 - y); + const classes = ["snaky-grid-cell", board.has(key) ? "on-board" : "", envelope.has(key) ? "in-envelope" : "", winner.has(key) ? "winning" : ""].filter(Boolean).join(" "); + const cell = svgNode("rect", {x: px, y: py, width: 23, height: 23, rx: 2, class: classes}); + cell.append(svgNode("title", {}, `${pointText([x, y])}: ${view.makerTurns.has(key) ? "Maker, move " + view.makerTurns.get(key) : view.breakerTurns.has(key) ? "Breaker, reply " + view.breakerTurns.get(key) : board.has(key) ? "free" : "outside board"}`)); + svg.append(cell); + if (view.makerTurns.has(key)) { + svg.append(svgNode("circle", {cx: px + 8, cy: py + 9, r: 5, class: "snaky-maker"})); + svg.append(svgNode("text", {x: px + 14, y: py + 19, class: "snaky-turn-label"}, view.makerTurns.get(key))); + } else if (view.breakerTurns.has(key)) { + svg.append(svgNode("path", {d: `M${px+4},${py+4} l9,9 m-9,0 l9,-9`, class: "snaky-breaker"})); + svg.append(svgNode("text", {x: px + 14, y: py + 19, class: "snaky-turn-label"}, view.breakerTurns.get(key))); + } + } + for (let value = 0; value <= 16; value++) { + svg.append(svgNode("text", {x: 39.5 + 25 * value, y: 451, "text-anchor": "middle", class: "snaky-board-axis"}, value)); + svg.append(svgNode("text", {x: 17, y: 28 + 25 * (16 - value), "text-anchor": "end", class: "snaky-board-axis"}, value)); + } + svg.append(svgNode("text", {x: 452, y: 466, class: "snaky-board-axis"}, "x")); + svg.append(svgNode("text", {x: 3, y: 10, class: "snaky-board-axis"}, "y")); + el("snaky-board").replaceChildren(svg); + } + + function render(data, index) { + const view = viewOf(data, index), step = view.step; + el("snaky-step").value = String(index); + el("snaky-prev").disabled = index === 0; + el("snaky-next").disabled = index === data.play.steps.length - 1; + drawBoard(data, view); + el("snaky-card-label").textContent = `CARD ${step.active.card}${step.active.inline_path.length ? " · INLINE PATH " + step.active.inline_path.join(" → ") : ""}`; + el("snaky-move-title").textContent = step.won ? "The six-square shape is complete." : `Maker claims ${pointText(step.maker.cell)}.`; + const explanation = [node("p", `Move ${step.move}: Maker takes the fresh cell ${pointText(step.maker.cell)}. ${step.maker.kind === "replacement" ? "The prescribed pivot is already owned, so this replacement still consumes one claim." : step.maker.kind === "base_completion" ? "This completes the base card's target." : "This is the selected card's pivot."}`)]; + explanation.push(node("p", step.breaker ? `Breaker then claims ${pointText(step.breaker.cell)}. The next card's envelope avoids this reply and all earlier Breaker cells.` : "Maker has won, so no Breaker reply is required.")); + el("snaky-move-text").replaceChildren(...explanation); + const rows = [["Actual Maker claims used", step.move], ["Remaining from 21-claim allowance", step.global_budget_after], ["Active card bound before this move", step.active.height], ["Next card bound", step.continuation ? step.continuation.height : "Won"]]; + el("snaky-budget").replaceChildren(...rows.flatMap(([label, value]) => [node("dt", label), node("dd", String(value))])); + const detail = step.won ? `Winning cells: ${step.witness.cells.map(pointText).join(", ")}.` : `Continue with ${step.continuation.kind === "inline" ? "the nested combination" : "card " + step.continuation.card}. Its required cells are owned by Maker and its envelope is free of Breaker cells.`; + el("snaky-continuation").replaceChildren(node("p", detail, step.won ? "notice" : "")); + el("snaky-card-source").href = step.active.certificate_ref.url; + } + + function start(data) { + if (!data || data.schema_version !== 1 || !data.play || !Array.isArray(data.play.steps)) throw new Error("The checked presentation data is unavailable."); + const select = el("snaky-step"); + data.play.steps.forEach((step, index) => { + const option = node("option", `${step.move} · Maker ${pointText(step.maker.cell)}${step.won ? " · Win" : ""}`); + option.value = String(index); select.append(option); + }); + select.addEventListener("change", () => render(data, Number(select.value))); + el("snaky-prev").addEventListener("click", () => render(data, Number(select.value) - 1)); + el("snaky-next").addEventListener("click", () => render(data, Number(select.value) + 1)); + const table = node("table"), caption = node("caption", "All chosen moves in this illustrative play"); + const head = node("thead"), tr = node("tr"); + ["Move", "Maker cell", "Breaker reply", "Card bound before move", "Continuation bound"].forEach(label => { const th = node("th", label); th.scope = "col"; tr.append(th); }); + head.append(tr); table.append(caption, head); + const body = node("tbody"); + data.play.steps.forEach(step => {const row = node("tr"); [step.move, pointText(step.maker.cell), step.breaker ? pointText(step.breaker.cell) : "Game won", step.active.height, step.continuation ? step.continuation.height : "Won"].forEach(value => row.append(node("td", String(value)))); body.append(row);}); + table.append(body); el("snaky-move-table").replaceChildren(table); + el("snaky-evidence").replaceChildren(...data.evidence.map(item => {const card = node("article"); card.append(node("h3", item.title), node("p", item.description)); const link = node("a", "Inspect the exact source ↗"); link.href = item.url; card.append(link); if (item.sha256) card.append(node("code", "SHA-256 " + item.sha256, "snaky-evidence-code")); return card;})); + el("snaky-query").textContent = data.commands.join("\n"); + el("snaky-content").hidden = false; + render(data, 0); + } + + try { start(window.SNAKY_PLAY_DATA); } + catch (error) { el("snaky-content").hidden = true; el("snaky-error").hidden = false; el("snaky-error").textContent = "The example could not be loaded: " + error.message; } +}()); diff --git a/space/snaky-play.json b/space/snaky-play.json new file mode 100644 index 0000000..15b17cc --- /dev/null +++ b/space/snaky-play.json @@ -0,0 +1,6860 @@ +{ + "schema_version": 1, + "id": "context:family-187:snaky:illustrative-play:v1", + "source_revision": "3bd96caa445c459371128e882fe420479084924e", + "play": { + "schema_version": 1, + "id": "example:family-187:snaky:eight-claim-branch:v1", + "title": "One Snaky play: eight Maker claims", + "kind": "illustrative_checked_execution", + "sources": { + "certificate": { + "path": "evidence/snaky-finite-v1/certificate.txt", + "sha256": "3fa12d36a6d4dbb185e3f2808c8dfde13d85ee309afbca030d6ad17ae9fe3d04", + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt", + "commit": "1581d4cbdd69a0faf34b2089614fe2a814316a6a" + }, + "oracle": { + "path": "scripts/check_snaky.py", + "sha256": "39557ec80096081efac4f5f8f0182383a4d23af855bb652a8108fa4228ee2d42" + }, + "generator": { + "path": "scripts/build_snaky_play.py", + "sha256": "77b0701590f0bd022240db0ca93bf46acc931024475454de143fc99c5bbafeac" + }, + "validator": { + "path": "scripts/check_snaky_play.py", + "sha256": "1d9cd05e8865fbf1965f8948e6369f2b9011ae48e9658e1404313161ac08e1ae" + }, + "root_claim_id": "context:family-187:snaky:finite-board-21:v1" + }, + "board": { + "name": "251-cell envelope of card 727", + "cells": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 0, + 12 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 1, + 12 + ], + [ + 1, + 13 + ], + [ + 2, + 1 + ], + [ + 2, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 2, + 14 + ], + [ + 2, + 15 + ], + [ + 3, + 1 + ], + [ + 3, + 2 + ], + [ + 3, + 3 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 3, + 14 + ], + [ + 3, + 15 + ], + [ + 4, + 0 + ], + [ + 4, + 1 + ], + [ + 4, + 2 + ], + [ + 4, + 3 + ], + [ + 4, + 4 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 4, + 15 + ], + [ + 5, + 0 + ], + [ + 5, + 1 + ], + [ + 5, + 2 + ], + [ + 5, + 3 + ], + [ + 5, + 4 + ], + [ + 5, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 5, + 16 + ], + [ + 6, + 0 + ], + [ + 6, + 1 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 8 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 7, + 16 + ], + [ + 8, + 0 + ], + [ + 8, + 1 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 0 + ], + [ + 9, + 1 + ], + [ + 9, + 2 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 9, + 16 + ], + [ + 10, + 0 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 11, + 16 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 12, + 15 + ], + [ + 12, + 16 + ], + [ + 13, + 1 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 13, + 15 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 14, + 14 + ], + [ + 15, + 3 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 4 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "bounds": { + "x_min": 0, + "x_max": 16, + "y_min": 0, + "y_max": 16 + }, + "cell_count": 251 + }, + "choices": { + "maker": "Prescribed pivot, or first free envelope cell if already owned; stop at first Snaky copy.", + "breaker": "Two displayed paper replies, then first free envelope cell in lexicographic (x,y) order.", + "breaker_prefix": [ + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": "First printed child whose placed envelope avoids the legal reply." + }, + "steps": [ + { + "move": 1, + "active": { + "card": 727, + "inline_path": [], + "height": 21, + "required": [], + "envelope": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 0, + 12 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 1, + 12 + ], + [ + 1, + 13 + ], + [ + 2, + 1 + ], + [ + 2, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 2, + 14 + ], + [ + 2, + 15 + ], + [ + 3, + 1 + ], + [ + 3, + 2 + ], + [ + 3, + 3 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 3, + 14 + ], + [ + 3, + 15 + ], + [ + 4, + 0 + ], + [ + 4, + 1 + ], + [ + 4, + 2 + ], + [ + 4, + 3 + ], + [ + 4, + 4 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 4, + 15 + ], + [ + 5, + 0 + ], + [ + 5, + 1 + ], + [ + 5, + 2 + ], + [ + 5, + 3 + ], + [ + 5, + 4 + ], + [ + 5, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 5, + 16 + ], + [ + 6, + 0 + ], + [ + 6, + 1 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 8 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 7, + 16 + ], + [ + 8, + 0 + ], + [ + 8, + 1 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 0 + ], + [ + 9, + 1 + ], + [ + 9, + 2 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 9, + 16 + ], + [ + 10, + 0 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 11, + 16 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 12, + 15 + ], + [ + 12, + 16 + ], + [ + 13, + 1 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 13, + 15 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 14, + 14 + ], + [ + 15, + 3 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 4 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "placement": { + "matrix": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "translation": [ + 0, + 0 + ] + }, + "certificate_ref": { + "line": 722, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L722", + "node": "card 727" + } + }, + "maker_before": [], + "breaker_before": [], + "global_budget_before": 21, + "global_budget_after": 20, + "maker": { + "cell": [ + 8, + 8 + ], + "kind": "pivot", + "prescribed_cell": [ + 8, + 8 + ] + }, + "maker_after": [ + [ + 8, + 8 + ] + ], + "breaker": { + "cell": [ + 7, + 8 + ] + }, + "breaker_after": [ + [ + 7, + 8 + ] + ], + "continuation": { + "child_index": 4, + "kind": "reference", + "source_reference": "708:100", + "card": 708, + "inline_path": [], + "height": 20, + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 0, + 0 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 2, + "active": { + "card": 708, + "inline_path": [], + "height": 20, + "required": [ + [ + 8, + 8 + ] + ], + "envelope": [ + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 1, + 12 + ], + [ + 2, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 3, + 2 + ], + [ + 3, + 3 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 4, + 0 + ], + [ + 4, + 1 + ], + [ + 4, + 2 + ], + [ + 4, + 3 + ], + [ + 4, + 4 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 5, + 0 + ], + [ + 5, + 1 + ], + [ + 5, + 2 + ], + [ + 5, + 3 + ], + [ + 5, + 4 + ], + [ + 5, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 6, + 0 + ], + [ + 6, + 1 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 8, + 0 + ], + [ + 8, + 1 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 0 + ], + [ + 9, + 1 + ], + [ + 9, + 2 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 0, + 0 + ] + }, + "certificate_ref": { + "line": 703, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L703", + "node": "card 708" + } + }, + "maker_before": [ + [ + 8, + 8 + ] + ], + "breaker_before": [ + [ + 7, + 8 + ] + ], + "global_budget_before": 20, + "global_budget_after": 19, + "maker": { + "cell": [ + 8, + 7 + ], + "kind": "pivot", + "prescribed_cell": [ + 8, + 7 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ] + ], + "breaker": { + "cell": [ + 8, + 6 + ] + }, + "breaker_after": [ + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 6, + "kind": "reference", + "source_reference": "684:011", + "card": 684, + "inline_path": [], + "height": 18, + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 1, + 1 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 3, + "active": { + "card": 684, + "inline_path": [], + "height": 18, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ] + ], + "envelope": [ + [ + 1, + 10 + ], + [ + 1, + 12 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 1, + 1 + ] + }, + "certificate_ref": { + "line": 679, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L679", + "node": "card 684" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ] + ], + "breaker_before": [ + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 19, + "global_budget_after": 18, + "maker": { + "cell": [ + 11, + 8 + ], + "kind": "pivot", + "prescribed_cell": [ + 11, + 8 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 11, + 8 + ] + ], + "breaker": { + "cell": [ + 0, + 4 + ] + }, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 0, + "kind": "inline", + "source_reference": null, + "card": 684, + "inline_path": [ + 0 + ], + "height": 14, + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 1, + 1 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 4, + "active": { + "card": 684, + "inline_path": [ + 0 + ], + "height": 14, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 11, + 8 + ] + ], + "envelope": [ + [ + 1, + 10 + ], + [ + 1, + 12 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 12, + 6 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ] + ], + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 1, + 1 + ] + }, + "certificate_ref": { + "line": 679, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L679", + "node": "card 684 / child 0" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 11, + 8 + ] + ], + "breaker_before": [ + [ + 0, + 4 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 18, + "global_budget_after": 17, + "maker": { + "cell": [ + 8, + 9 + ], + "kind": "pivot", + "prescribed_cell": [ + 8, + 9 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 11, + 8 + ] + ], + "breaker": { + "cell": [ + 0, + 5 + ] + }, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 0, + "kind": "reference", + "source_reference": "118:45A", + "card": 118, + "inline_path": [], + "height": 7, + "placement": { + "matrix": [ + [ + 0, + -1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 11, + 6 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 5, + "active": { + "card": 118, + "inline_path": [], + "height": 7, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ] + ], + "envelope": [ + [ + 4, + 9 + ], + [ + 4, + 11 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 11, + 9 + ] + ], + "placement": { + "matrix": [ + [ + 0, + -1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 11, + 6 + ] + }, + "certificate_ref": { + "line": 113, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L113", + "node": "card 118" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 11, + 8 + ] + ], + "breaker_before": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 17, + "global_budget_after": 16, + "maker": { + "cell": [ + 8, + 10 + ], + "kind": "pivot", + "prescribed_cell": [ + 8, + 10 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 11, + 8 + ] + ], + "breaker": { + "cell": [ + 0, + 6 + ] + }, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 0, + "kind": "reference", + "source_reference": "7:303", + "card": 7, + "inline_path": [], + "height": 3, + "placement": { + "matrix": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "translation": [ + 8, + 6 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 6, + "active": { + "card": 7, + "inline_path": [], + "height": 3, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ] + ], + "envelope": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ] + ], + "placement": { + "matrix": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "translation": [ + 8, + 6 + ] + }, + "certificate_ref": { + "line": 2, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L2", + "node": "card 7" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 11, + 8 + ] + ], + "breaker_before": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 16, + "global_budget_after": 15, + "maker": { + "cell": [ + 8, + 11 + ], + "kind": "pivot", + "prescribed_cell": [ + 8, + 11 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 11, + 8 + ] + ], + "breaker": { + "cell": [ + 0, + 7 + ] + }, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 0, + "kind": "reference", + "source_reference": "6:001", + "card": 6, + "inline_path": [], + "height": 2, + "placement": { + "matrix": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "translation": [ + 8, + 7 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 7, + "active": { + "card": 6, + "inline_path": [], + "height": 2, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ] + ], + "envelope": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ] + ], + "placement": { + "matrix": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "translation": [ + 8, + 7 + ] + }, + "certificate_ref": { + "line": 1, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt#L1", + "node": "card 6" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 11, + 8 + ] + ], + "breaker_before": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 15, + "global_budget_after": 14, + "maker": { + "cell": [ + 9, + 11 + ], + "kind": "pivot", + "prescribed_cell": [ + 9, + 11 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 11 + ], + [ + 11, + 8 + ] + ], + "breaker": { + "cell": [ + 0, + 8 + ] + }, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": { + "child_index": 0, + "kind": "reference", + "source_reference": "4:100", + "card": 4, + "inline_path": [], + "height": 1, + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 8, + 7 + ] + } + }, + "won": false, + "witness": null + }, + { + "move": 8, + "active": { + "card": 4, + "inline_path": [], + "height": 1, + "required": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 9, + 11 + ] + ], + "envelope": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ] + ], + "placement": { + "matrix": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "translation": [ + 8, + 7 + ] + }, + "certificate_ref": { + "line": 36, + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/lean/OAI/GameTheory/SnakyTwentyOne/Cards/Height01Part01.lean#L36", + "node": "card 4" + } + }, + "maker_before": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 11 + ], + [ + 11, + 8 + ] + ], + "breaker_before": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "global_budget_before": 14, + "global_budget_after": 13, + "maker": { + "cell": [ + 9, + 10 + ], + "kind": "base_completion", + "prescribed_cell": [ + 9, + 10 + ] + }, + "maker_after": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 11, + 8 + ] + ], + "breaker": null, + "breaker_after": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 7, + 8 + ], + [ + 8, + 6 + ] + ], + "continuation": null, + "won": true, + "witness": { + "symmetry": 1, + "translation": [ + 8, + 7 + ], + "cells": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ] + ] + } + } + ], + "result": { + "maker_claims": 8, + "breaker_claims": 7, + "won": true, + "target": { + "symmetry": 1, + "translation": [ + 8, + 7 + ], + "cells": [ + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ] + ] + }, + "remaining_global_budget": 13 + }, + "limits": [ + "One illustrative checked execution with chosen legal Breaker replies.", + "Eight Maker claims in this example do not establish an eight-move guarantee.", + "The Python move adapter is not an extracted formally verified policy.", + "This record binds certificate and implementation inputs, not a successful Lean proof receipt.", + "The 21-move universal theorem and its proof receipt are separate evidence." + ] + }, + "claim_record": { + "schema_version": 1, + "namespace": "finite-congruence-context/query-v1", + "status": "ok", + "command": "explain", + "context": { + "id": "context:family-187:snaky:finite-board-21:v1", + "path": "evidence/snaky-finite-v1/claim.json", + "sha256": "20eb112e32c82ab23fb0c8d7db880f4996cd5008a4c767c84fa67822cad3b201" + }, + "claim": { + "schema_version": 1, + "namespace": "finite-congruence-atlas/snaky-finite-v1", + "id": "context:family-187:snaky:finite-board-21:v1", + "kind": "finite_board_strategy", + "evidence_status": "lean_proof_with_recorded_kernel_replay", + "statement": "Maker can force Snaky within 21 actual claims on the exact 251-cell envelope, and on the square with integer coordinates 0 through 16 in both directions.", + "scope": "One exact 728-card certificate, two specified finite boards, empty initial position; all legal board-contained Breaker replies.", + "assumptions": [ + "Maker moves first; players alternate claiming one fresh cell of the selected board.", + "Maker wins by owning a translated, rotated or reflected copy of the six specified target cells.", + "The game ends when Maker wins; no Breaker reply after victory is required.", + "Lean's kernel and only the standard axioms listed in the receipt are trusted." + ], + "limits": [ + "This formalizes the source paper's existing 21-Maker-claim finite-board corollaries. It does not establish a new bound, optimality, or a smallest board.", + "The formal result is a finite-board strategy-tree guarantee, not an extracted or benchmarked executable policy.", + "The 728-card theorem certificate is distinct from the historical 616-card comparator reconstruction.", + "The independent Python certificate reconstruction is tested computation, not a formally verified implementation.", + "Saved receipt replay checks recorded sources, commands, artifacts and bindings. It is not a new kernel execution or an authenticated attestation.", + "No general translation correctness or improved agent reasoning is established. Model benchmarks and training remain paused." + ], + "values": { + "target": [ + [ + 0, + 0 + ], + [ + 1, + 0 + ], + [ + 2, + 0 + ], + [ + 3, + 0 + ], + [ + 3, + 1 + ], + [ + 4, + 1 + ] + ], + "card_index": 727, + "envelope": [ + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 0, + 12 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ], + [ + 1, + 4 + ], + [ + 1, + 5 + ], + [ + 1, + 6 + ], + [ + 1, + 7 + ], + [ + 1, + 8 + ], + [ + 1, + 9 + ], + [ + 1, + 10 + ], + [ + 1, + 11 + ], + [ + 1, + 12 + ], + [ + 1, + 13 + ], + [ + 2, + 1 + ], + [ + 2, + 2 + ], + [ + 2, + 3 + ], + [ + 2, + 4 + ], + [ + 2, + 5 + ], + [ + 2, + 6 + ], + [ + 2, + 7 + ], + [ + 2, + 8 + ], + [ + 2, + 9 + ], + [ + 2, + 10 + ], + [ + 2, + 11 + ], + [ + 2, + 12 + ], + [ + 2, + 13 + ], + [ + 2, + 14 + ], + [ + 2, + 15 + ], + [ + 3, + 1 + ], + [ + 3, + 2 + ], + [ + 3, + 3 + ], + [ + 3, + 4 + ], + [ + 3, + 5 + ], + [ + 3, + 6 + ], + [ + 3, + 7 + ], + [ + 3, + 8 + ], + [ + 3, + 9 + ], + [ + 3, + 10 + ], + [ + 3, + 11 + ], + [ + 3, + 12 + ], + [ + 3, + 13 + ], + [ + 3, + 14 + ], + [ + 3, + 15 + ], + [ + 4, + 0 + ], + [ + 4, + 1 + ], + [ + 4, + 2 + ], + [ + 4, + 3 + ], + [ + 4, + 4 + ], + [ + 4, + 5 + ], + [ + 4, + 6 + ], + [ + 4, + 7 + ], + [ + 4, + 8 + ], + [ + 4, + 9 + ], + [ + 4, + 10 + ], + [ + 4, + 11 + ], + [ + 4, + 12 + ], + [ + 4, + 13 + ], + [ + 4, + 14 + ], + [ + 4, + 15 + ], + [ + 5, + 0 + ], + [ + 5, + 1 + ], + [ + 5, + 2 + ], + [ + 5, + 3 + ], + [ + 5, + 4 + ], + [ + 5, + 5 + ], + [ + 5, + 6 + ], + [ + 5, + 7 + ], + [ + 5, + 8 + ], + [ + 5, + 9 + ], + [ + 5, + 10 + ], + [ + 5, + 11 + ], + [ + 5, + 12 + ], + [ + 5, + 13 + ], + [ + 5, + 14 + ], + [ + 5, + 15 + ], + [ + 5, + 16 + ], + [ + 6, + 0 + ], + [ + 6, + 1 + ], + [ + 6, + 2 + ], + [ + 6, + 3 + ], + [ + 6, + 4 + ], + [ + 6, + 5 + ], + [ + 6, + 6 + ], + [ + 6, + 7 + ], + [ + 6, + 8 + ], + [ + 6, + 9 + ], + [ + 6, + 10 + ], + [ + 6, + 11 + ], + [ + 6, + 12 + ], + [ + 6, + 13 + ], + [ + 6, + 14 + ], + [ + 6, + 15 + ], + [ + 6, + 16 + ], + [ + 7, + 0 + ], + [ + 7, + 1 + ], + [ + 7, + 2 + ], + [ + 7, + 3 + ], + [ + 7, + 4 + ], + [ + 7, + 5 + ], + [ + 7, + 6 + ], + [ + 7, + 7 + ], + [ + 7, + 8 + ], + [ + 7, + 9 + ], + [ + 7, + 10 + ], + [ + 7, + 11 + ], + [ + 7, + 12 + ], + [ + 7, + 13 + ], + [ + 7, + 14 + ], + [ + 7, + 15 + ], + [ + 7, + 16 + ], + [ + 8, + 0 + ], + [ + 8, + 1 + ], + [ + 8, + 2 + ], + [ + 8, + 3 + ], + [ + 8, + 4 + ], + [ + 8, + 5 + ], + [ + 8, + 6 + ], + [ + 8, + 7 + ], + [ + 8, + 8 + ], + [ + 8, + 9 + ], + [ + 8, + 10 + ], + [ + 8, + 11 + ], + [ + 8, + 12 + ], + [ + 8, + 13 + ], + [ + 8, + 14 + ], + [ + 8, + 15 + ], + [ + 8, + 16 + ], + [ + 9, + 0 + ], + [ + 9, + 1 + ], + [ + 9, + 2 + ], + [ + 9, + 3 + ], + [ + 9, + 4 + ], + [ + 9, + 5 + ], + [ + 9, + 6 + ], + [ + 9, + 7 + ], + [ + 9, + 8 + ], + [ + 9, + 9 + ], + [ + 9, + 10 + ], + [ + 9, + 11 + ], + [ + 9, + 12 + ], + [ + 9, + 13 + ], + [ + 9, + 14 + ], + [ + 9, + 15 + ], + [ + 9, + 16 + ], + [ + 10, + 0 + ], + [ + 10, + 1 + ], + [ + 10, + 2 + ], + [ + 10, + 3 + ], + [ + 10, + 4 + ], + [ + 10, + 5 + ], + [ + 10, + 6 + ], + [ + 10, + 7 + ], + [ + 10, + 8 + ], + [ + 10, + 9 + ], + [ + 10, + 10 + ], + [ + 10, + 11 + ], + [ + 10, + 12 + ], + [ + 10, + 13 + ], + [ + 10, + 14 + ], + [ + 10, + 15 + ], + [ + 10, + 16 + ], + [ + 11, + 0 + ], + [ + 11, + 1 + ], + [ + 11, + 2 + ], + [ + 11, + 3 + ], + [ + 11, + 4 + ], + [ + 11, + 5 + ], + [ + 11, + 6 + ], + [ + 11, + 7 + ], + [ + 11, + 8 + ], + [ + 11, + 9 + ], + [ + 11, + 10 + ], + [ + 11, + 11 + ], + [ + 11, + 12 + ], + [ + 11, + 13 + ], + [ + 11, + 14 + ], + [ + 11, + 15 + ], + [ + 11, + 16 + ], + [ + 12, + 1 + ], + [ + 12, + 2 + ], + [ + 12, + 3 + ], + [ + 12, + 4 + ], + [ + 12, + 5 + ], + [ + 12, + 6 + ], + [ + 12, + 7 + ], + [ + 12, + 8 + ], + [ + 12, + 9 + ], + [ + 12, + 10 + ], + [ + 12, + 11 + ], + [ + 12, + 12 + ], + [ + 12, + 13 + ], + [ + 12, + 14 + ], + [ + 12, + 15 + ], + [ + 12, + 16 + ], + [ + 13, + 1 + ], + [ + 13, + 2 + ], + [ + 13, + 3 + ], + [ + 13, + 4 + ], + [ + 13, + 5 + ], + [ + 13, + 6 + ], + [ + 13, + 7 + ], + [ + 13, + 8 + ], + [ + 13, + 9 + ], + [ + 13, + 10 + ], + [ + 13, + 11 + ], + [ + 13, + 12 + ], + [ + 13, + 13 + ], + [ + 13, + 14 + ], + [ + 13, + 15 + ], + [ + 14, + 1 + ], + [ + 14, + 2 + ], + [ + 14, + 3 + ], + [ + 14, + 4 + ], + [ + 14, + 5 + ], + [ + 14, + 6 + ], + [ + 14, + 7 + ], + [ + 14, + 8 + ], + [ + 14, + 9 + ], + [ + 14, + 10 + ], + [ + 14, + 11 + ], + [ + 14, + 12 + ], + [ + 14, + 13 + ], + [ + 14, + 14 + ], + [ + 15, + 3 + ], + [ + 15, + 4 + ], + [ + 15, + 5 + ], + [ + 15, + 6 + ], + [ + 15, + 7 + ], + [ + 15, + 8 + ], + [ + 15, + 9 + ], + [ + 15, + 10 + ], + [ + 15, + 11 + ], + [ + 15, + 12 + ], + [ + 15, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 4 + ], + [ + 16, + 5 + ], + [ + 16, + 6 + ], + [ + 16, + 7 + ], + [ + 16, + 8 + ], + [ + 16, + 9 + ], + [ + 16, + 10 + ], + [ + 16, + 11 + ] + ], + "square_bounds": { + "x_min": 0, + "x_max": 16, + "y_min": 0, + "y_max": 16 + }, + "initial_maker": [], + "initial_breaker": [], + "certificate": { + "repository": "openai/math", + "commit": "1581d4cbdd69a0faf34b2089614fe2a814316a6a", + "path": "preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt", + "url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/verification/certificate.txt", + "certificate_sha256": "3fa12d36a6d4dbb185e3f2808c8dfde13d85ee309afbca030d6ad17ae9fe3d04", + "byte_length": 38367, + "hash_encoding": "SHA-256 of exact original certificate bytes; no newline normalization." + } + }, + "conclusion": { + "predicate": "A finite-board strategy tree guarantees a translated or square-symmetry copy of the exact six-cell Snaky within the stated number of actual fresh Maker claims from empty Maker and Breaker sets; every legal on-board Breaker reply is covered, and victory needs no further reply.", + "maker_claims_at_most": 21, + "envelope_cells": 251, + "square_cells": 289 + }, + "theorems": { + "envelope": "FiniteCongruenceChecks.SnakyFinite.envelope_wins", + "square": "FiniteCongruenceChecks.SnakyFinite.square_wins" + }, + "applicable_lemmas": [ + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.fresh_cell", + "role": "A strict occupied-cell bound supplies a legal board-contained cell." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.finite_compose", + "role": "The finite resource invariant justifies pivot replacement and every legal Breaker continuation." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.board_wins", + "role": "Any finite board containing the exact final envelope and at least 42 cells supports the strategy." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.envelope_wins", + "role": "Empty initial position on the exact 251-cell envelope." + }, + { + "theorem": "FiniteCongruenceChecks.SnakyFinite.square_wins", + "role": "Empty initial position on the exact 17 by 17 square." + } + ], + "citations": [ + { + "path": "lean/snaky/SnakySemantics.lean", + "sha256": "eed7dee5c079df33d8488018119dfdb48d8bc1bc6aeb70e6a23f679135e52f2b" + }, + { + "path": "lean/snaky/SnakyFinite.lean", + "sha256": "4481d384a4f7920d98088bd2cc10796d330e5ae9da11aeff718e0d949c27d3ff" + }, + { + "path": "lean/snaky/vendor-manifest.json", + "sha256": "ca09b16a386355c5aa5a46c91fa87b6979cfc809ddc01b55743d6199e6e63c22" + }, + { + "path": "lean/snaky/SnakyBinding.lean", + "sha256": "c2067bfff6b6a25ce5dc3c6f5d42973943d19f1587954d627e3e774e9b261f8b" + } + ], + "upstream_context": { + "family": "187", + "revision": "1581d4cbdd69a0faf34b2089614fe2a814316a6a", + "scope_url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/lean/docs/187.md", + "paper_url": "https://github.com/openai/math/blob/1581d4cbdd69a0faf34b2089614fe2a814316a6a/preprints/Snaky-in-21-Maker-moves-September-25-2026/build/strategy.tex", + "role": "The paper states the finite-board corollaries. The selected upstream Lean theorem covers the infinite grid." + }, + "proof_evidence": { + "path": "evidence/snaky-finite-v1/proof/summary.json", + "sha256": "9e2f9fafa6882ca21a89775671fe58bb21850faecf96f3c4916f8a7957e2079d", + "axioms": { + "FiniteCongruenceChecks.SnakyFinite.FiniteWins.false_impossible": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.FiniteWins.zero_iff": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.fresh_cell": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.finite_immediate": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.finite_compose": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.envelope_card": [ + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.square_card": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.envelope_subset_square": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.square_membership": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.board_wins": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.envelope_wins": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.square_wins": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.target_exact": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.envelope_exact": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.square_exact": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.inputs_exact": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.counts_exact": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.checked_envelope": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "FiniteCongruenceChecks.SnakyFinite.Binding.checked_square": [ + "Classical.choice", + "Quot.sound", + "propext" + ] + }, + "validation": "saved receipt replay; no Lean execution during query" + }, + "computational_evidence": { + "path": "evidence/snaky-finite-v1/computational.json", + "sha256": "24a023e3e6c65810ec0afdf896f3daf51e78bb582995e0bc7f8f9c0de98837ec", + "validation": "independent reconstruction of the exact 728-card certificate; Python correctness is not formally proved" + } + }, + "binding_method": "curated_exact_binding", + "validation_limit": "Exact registered context matching only. This does not elaborate Lean, infer theorem applicability, verify arbitrary claims, or establish that an agent preserved meaning." + }, + "evidence": [ + { + "title": "The exact recorded execution", + "description": "All chosen moves, complete ownership sets, certificate placements and the six-cell winning witness. The independent checker replays this one branch.", + "path": "evidence/snaky-play-v1/example.json", + "url": "https://github.com/Maverick0351a/finite-congruence-checks/blob/3bd96caa445c459371128e882fe420479084924e/evidence/snaky-play-v1/example.json", + "sha256": "052bfce71d1bf36ce8e109f6da41cbfcbeccbb93021a4d59bd6807b771b2ed10" + }, + { + "title": "The formal strategy guarantee", + "description": "The Lean theorem covers every legal reply on the exact finite board, within 21 Maker claims. The source paper already states this finite-board result.", + "path": "lean/snaky/SnakyFinite.lean", + "url": "https://github.com/Maverick0351a/finite-congruence-checks/blob/3bd96caa445c459371128e882fe420479084924e/lean/snaky/SnakyFinite.lean", + "sha256": "4481d384a4f7920d98088bd2cc10796d330e5ae9da11aeff718e0d949c27d3ff" + }, + { + "title": "The claim and its verification", + "description": "The receipt records the build, kernel replay, allowed axioms and deliberate mismatched-claim rejections. Offline receipt replay is not a new proof execution.", + "path": "evidence/snaky-finite-v1/proof/summary.json", + "url": "https://github.com/Maverick0351a/finite-congruence-checks/blob/3bd96caa445c459371128e882fe420479084924e/evidence/snaky-finite-v1/proof/summary.json", + "sha256": "9e2f9fafa6882ca21a89775671fe58bb21850faecf96f3c4916f8a7957e2079d" + } + ], + "commands": [ + "python scripts/check_snaky_play.py", + "python scripts/query_context.py explain context:family-187:snaky:finite-board-21:v1 --out snaky.json", + "python scripts/query_context.py check snaky.json", + "python scripts/snaky_proof.py run --out runs/snaky-fresh" + ] +} diff --git a/specs/snaky-play-source-anchor.json b/specs/snaky-play-source-anchor.json new file mode 100644 index 0000000..40e3031 --- /dev/null +++ b/specs/snaky-play-source-anchor.json @@ -0,0 +1,225 @@ +{ + "schema_version": 1, + "revision": "3bd96caa445c459371128e882fe420479084924e", + "files": { + "evidence/snaky-finite-v1/certificate.txt": "3fa12d36a6d4dbb185e3f2808c8dfde13d85ee309afbca030d6ad17ae9fe3d04", + "evidence/snaky-finite-v1/claim.json": "20eb112e32c82ab23fb0c8d7db880f4996cd5008a4c767c84fa67822cad3b201", + "evidence/snaky-finite-v1/computational.json": "24a023e3e6c65810ec0afdf896f3daf51e78bb582995e0bc7f8f9c0de98837ec", + "evidence/snaky-finite-v1/proof/Audit.lean": "557232d1735948205cdc299f6f04c68feca5ac51a6e0bd908ecb51c23f297270", + "evidence/snaky-finite-v1/proof/axioms.log": "ee6611b79ea4ba944f7f84f5249e51c79aa0a29f37a442348e8a8f4317218876", + "evidence/snaky-finite-v1/proof/build.log": "163fb6d214cac38bf07a43567ef6aa96d3c83f5090b03c3e601985d6ed90e6ca", + "evidence/snaky-finite-v1/proof/changed-envelope.lean": "09dcb538cd327b2d643b34a01310b7f030635555e87100d6a2030aae40919cf6", + "evidence/snaky-finite-v1/proof/changed-envelope.log": "aaf05646c138a5e2cfadc40801796927650a9d7aeddb4185135d3abcfd673bf3", + "evidence/snaky-finite-v1/proof/changed-square.lean": "a164f229a96ccdd4e0fd28bc85d9e526d6eb1fe1f737671bc3fd715d9bb8741e", + "evidence/snaky-finite-v1/proof/changed-square.log": "64e9f91ae9662f64a9c9093d74ca6b0dcb32af116509d162949125d9fc46736e", + "evidence/snaky-finite-v1/proof/changed-target.lean": "e0c4f53b637461df801de33dcc35304723ba539b07cefd934bb6f84a99c6c81c", + "evidence/snaky-finite-v1/proof/changed-target.log": "a41142412eadccc3e5ddeacb008268483b49026802aa48e0e76daf7055a772f1", + "evidence/snaky-finite-v1/proof/dependencies.log": "29e284dc7d8024aa6a333a92d0b23035028d78ada47b37f7dd77d8e1a0293483", + "evidence/snaky-finite-v1/proof/kernel.log": "2c00bad2ec2ad2e698cbe1be637427639026d9a2a527c0dc38279815b9655b9c", + "evidence/snaky-finite-v1/proof/nonempty-input.lean": "dd97852ef1248ba6125bd2c744a58f1657b4c83f6576ec2bfb242f6cf6084926", + "evidence/snaky-finite-v1/proof/nonempty-input.log": "7978c6b197071e8c2fd06104f50c6aa5e4b3b3e6ffb59ad3cb248932d5f3f416", + "evidence/snaky-finite-v1/proof/summary.json": "9e2f9fafa6882ca21a89775671fe58bb21850faecf96f3c4916f8a7957e2079d", + "evidence/snaky-finite-v1/proof/unrelated-theorem.lean": "7f0df330be1fb6245ddd4cc2be2bb188b437df35f4992c3b707222cb3b747d21", + "evidence/snaky-finite-v1/proof/unrelated-theorem.log": "f908a70b389cfbec20b6adc7521e33df18358f8bb39df36c68f048afe19ebdf4", + "evidence/snaky-finite-v1/proof/version.log": "355a9a028f81641782d75d6e6b58dec70f29d2f61238a9e271690259d9bf5680", + "evidence/snaky-finite-v1/proof/wrong-card.lean": "ff5de90e8fd5a0bbe6e910a97aeb1aa5bdef4286f127d00e89bbe97980bdf001", + "evidence/snaky-finite-v1/proof/wrong-card.log": "097d7942670f90bd9418dfca4609bb9ab0ece298278e8f1f42849c1abb09b1bd", + "evidence/snaky-finite-v1/proof/wrong-move-bound.lean": "700a2b952ea22cb9ec9450b77a5369646837fca6b9a6dbcd2ca5fb8771e1a664", + "evidence/snaky-finite-v1/proof/wrong-move-bound.log": "11d8192ccb4a4ad3038bd69f74b69b143b2a5fa4c5130b7542c86e2ad7ca8df1", + "evidence/snaky-play-v1/example.json": "052bfce71d1bf36ce8e109f6da41cbfcbeccbb93021a4d59bd6807b771b2ed10", + "lean/snaky/FiniteCards/Height01Part01.lean": "8ce6f26470a0ef7a90e273f15612ce7b028711ee895b0b28a660bd7333725438", + "lean/snaky/FiniteCards/Height02Part01.lean": "c1903729797b3d1fbaa149af328ec069d8eaff2cf148fea54e3251f9bbb562ea", + "lean/snaky/FiniteCards/Height02Part02.lean": "a0bae259e9753ba1da55d5326fac3c16e92b2209fbccbb46cb22841157581677", + "lean/snaky/FiniteCards/Height03Part01.lean": "cb55ef2c57a305d7ed4bcc8bfc18b0c74d4d8dcfeaa6ac746253d4c430fbab77", + "lean/snaky/FiniteCards/Height03Part02.lean": "c34a9ea623d76f93a17d8c2a13be5a6ee56f8cb46a25fad1ecfa31307b73364d", + "lean/snaky/FiniteCards/Height03Part03.lean": "f1eecfb54d82c2e1e33fcc25cbe9655f94a7e2fee035abfa8c914a0155a7b080", + "lean/snaky/FiniteCards/Height04Part01.lean": "bdaba8a61047af24723f05d7b042d9ae0d1ddd02e581b1fc267788e2ad7adc39", + "lean/snaky/FiniteCards/Height04Part02.lean": "51c83535ab4a18e778b77a4e9503eb2e2dcaf02ffce27b278e48c9cce767a9b0", + "lean/snaky/FiniteCards/Height04Part03.lean": "1d5034d925bc8a468a2b6b402801531874eea33ad78f35fb2ff92e5348c056a7", + "lean/snaky/FiniteCards/Height04Part04.lean": "542c4a04bffbeed6f501e063a6fd3ab61cdcb51283dc631668ac11993c3cfee1", + "lean/snaky/FiniteCards/Height04Part05.lean": "a6ca72ee5cb4c215f423139a700c8c200478e549b98d45f50e9c7a4ba912b8b7", + "lean/snaky/FiniteCards/Height05Part01.lean": "e0cb7028d42b55ad85a33ef13e58825eff2eea3312d31402f8ff7efd215601fe", + "lean/snaky/FiniteCards/Height05Part02.lean": "1178cbfea2ba0c83d47503e7b0eaa9871d715dae439da6d72d573fb3ec7adaac", + "lean/snaky/FiniteCards/Height05Part03.lean": "8d4e40b5a555fd47b666785b1cda6ab2a531b81b77ef87220eb4f0e3a506b90e", + "lean/snaky/FiniteCards/Height05Part04.lean": "f8a78bf54097fe92f5c4746fb0c83eeac7e080aa4533bb711e4460054872af57", + "lean/snaky/FiniteCards/Height05Part05.lean": "09e1efacebd597af8e92687a2879e17ce9f7c15c9e22d720ddb22619942e2989", + "lean/snaky/FiniteCards/Height05Part06.lean": "f67ad9130e8bdfc6cf104e9bed5cdd9fbc0f04a447842bee9debe7260d6a1681", + "lean/snaky/FiniteCards/Height05Part07.lean": "334daa658b65797fa70ed4f953722d831e8bee733869365e5539483e58dab944", + "lean/snaky/FiniteCards/Height06Part01.lean": "17576b955c548607046b479c46dfbae448c720a4507f3982c4980ca1afc38ffc", + "lean/snaky/FiniteCards/Height06Part02.lean": "b552030d555043e774856df2a94590c2cc95355fb607f3a668a316619520cbb5", + "lean/snaky/FiniteCards/Height06Part03.lean": "15a3e7f34ec61796b4e0c4b0c410544c2174e7869f42f3bd26639859056f45c5", + "lean/snaky/FiniteCards/Height06Part04.lean": "3a3cf04595892670a66d3e80ecb55fda0e532a6ebb70e2f4debffe327a7b01f7", + "lean/snaky/FiniteCards/Height06Part05.lean": "2eb0286ed43004820eb39c919ee065bcc4a588ff638c26aa4d64ede93ddb2d31", + "lean/snaky/FiniteCards/Height06Part06.lean": "6ccdbf6bd6a5d3508e17dbed960948556f31952c2496efc500c2999a4d7642de", + "lean/snaky/FiniteCards/Height07Part01.lean": "625d9c23b37c7f45d5f777059168361eafb564c42264b599b7cd3f36e4c7873a", + "lean/snaky/FiniteCards/Height07Part02.lean": "c711590b67f3bb39c7105dcccc78287c425c80d6191f8d10d09bb60e5e1a6a7e", + "lean/snaky/FiniteCards/Height07Part03.lean": "ec76f4a3a64fc6526be1df60dde7b3179a382756832333a8e8481d1f030a1b7a", + "lean/snaky/FiniteCards/Height07Part04.lean": "5aa1cee89196d89de0ac203aac3d98b3abe89ecfa56af6a795b8c18cfaa76e2a", + "lean/snaky/FiniteCards/Height07Part05.lean": "38947f99f3f589ecbacff7aa69bf53081a7535a55bb760d2ae60c3618b9c4712", + "lean/snaky/FiniteCards/Height07Part06.lean": "3f09b8d521b4cbafb81792163e571a538e6a6fb799ea2016a513a18fb7475723", + "lean/snaky/FiniteCards/Height08Part01.lean": "6892b7c97579655a7f8fca6e15e05e49abbe5126e27dbeeae620dcbb7c537c06", + "lean/snaky/FiniteCards/Height08Part02.lean": "ec75af9d0db5633275670ebcd909448a75b1cab5484b2841c42be44780367983", + "lean/snaky/FiniteCards/Height08Part03.lean": "fbb45f63c5e559fcd95712e2ddfbc1431eb3820bca2ccdd6e3d1b07466554c95", + "lean/snaky/FiniteCards/Height08Part04.lean": "50eebd526c4eabf660692bfb0dbcf39ec6c31a17ba7df9856ddb3524d4dd0f59", + "lean/snaky/FiniteCards/Height08Part05.lean": "b1848df70edceaaed8cd77289dbfcb9a643c141589b53fd341bfe99fa4994523", + "lean/snaky/FiniteCards/Height09Part01.lean": "4fadfde21993ed34175f51a17a8da454ca73a30ef5a92924e89d00142557f85b", + "lean/snaky/FiniteCards/Height09Part02.lean": "a694c0e41c7ee9d2b3b5a98e2db2afffdba395b57fdd5d84a87f0b6c5b377f1c", + "lean/snaky/FiniteCards/Height09Part03.lean": "3a000c50c81817c75ae753f63fd361abf8194789300999cef122e23ea69575c4", + "lean/snaky/FiniteCards/Height09Part04.lean": "b9720a4e14803cfbefcebdb8bf20cb6c4c2727d33d302bd9bc8329dc3ee9628b", + "lean/snaky/FiniteCards/Height09Part05.lean": "2ca75f0160bf4c7152aa0556c3c1881d25e6c52572e035bf7680ed6782a05593", + "lean/snaky/FiniteCards/Height09Part06.lean": "fad38a2cd0a68718c1f6084777724a730edeb736cf128115b39d929a26ef6344", + "lean/snaky/FiniteCards/Height09Part07.lean": "127c65ece69270fc38b0ba41704f40c3987ae6af1ec905ba59d6a52db64fcdeb", + "lean/snaky/FiniteCards/Height09Part08.lean": "03ba34ebf464b50646241ad20dc4fce747f735a7efcc715f90f31e43ba2ca7cd", + "lean/snaky/FiniteCards/Height10Part01.lean": "40e2de479acf3090647b8a07e0fc21d911a7b31649b4d1be1bb027ded311c452", + "lean/snaky/FiniteCards/Height10Part02.lean": "f9439f5946dcce6f4d3ca9d07759239cc78c2f9c60284bc7aec0df1f538a6c35", + "lean/snaky/FiniteCards/Height10Part03.lean": "baef28b1f9ff5c7dd6caf7116ca5da3293531a3377add4cb25b7090d727b1497", + "lean/snaky/FiniteCards/Height10Part04.lean": "47db043cb560943c62f076bbb5605223603113c79d7b12a5965bf417300e9d24", + "lean/snaky/FiniteCards/Height10Part05.lean": "0c60b4d4db00e4f59ea41007d98882627fa29fd361c84082b797527fd67b5c33", + "lean/snaky/FiniteCards/Height10Part06.lean": "85070a217949766901913a2851f2ba2f9ff9b61f3b01517e7818b8d2310afb40", + "lean/snaky/FiniteCards/Height10Part07.lean": "bc365b0393508083a04dbf01a8ac160e3c14c726fa0c1c93697a1d055be6aa39", + "lean/snaky/FiniteCards/Height11Part01.lean": "3425a345d9a9229e7410d593f2ebc0ca18795c4ca60bec743225bede9424ddb9", + "lean/snaky/FiniteCards/Height11Part02.lean": "0158daf583bc010542481565077fd485fd5047231fcbfe6fca3875e13841f1d1", + "lean/snaky/FiniteCards/Height11Part03.lean": "21ba2fa51aa15dec4752c3eb0eef99352fe43deb50172d9ad99d205516ae6890", + "lean/snaky/FiniteCards/Height11Part04.lean": "471e8995a02c5ec8ce1c66d1a39fb2d19dfef5796f279986bf730854230f53f4", + "lean/snaky/FiniteCards/Height11Part05.lean": "ecdd28cb39c48c1072deead4af2b4163b0bc0c05a385623a84d91778ffdf91b8", + "lean/snaky/FiniteCards/Height11Part06.lean": "c4dc54e1ac1eb16bbd07a6d485cf0b53c422a7c2f73c1c744a82178a45171fa3", + "lean/snaky/FiniteCards/Height12Part01.lean": "63f57780773fe4cf7354c2344ca02584b910251b777bcb1772a6ae8bbf79dff3", + "lean/snaky/FiniteCards/Height12Part02.lean": "a88ca3b2be232ccef987d07bb553db35e1c27fef006837391b5592cd05182361", + "lean/snaky/FiniteCards/Height12Part03.lean": "fb468e0e694f748cd4cb78b368d3ef417569a421889605f0daa29de700c1d6d6", + "lean/snaky/FiniteCards/Height12Part04.lean": "017ee2edc6a78628ac6209d868e4f78b4c947e4a47d240aede20e1082d4c2b59", + "lean/snaky/FiniteCards/Height12Part05.lean": "09ed1f540e2fbc1920fdabb71aedd628ef4a598834d66ed85270315f77ecd389", + "lean/snaky/FiniteCards/Height13Part01.lean": "287dbc1c1a78fde0928e61c0941c712d7f4ae2b7b45c01f1cf29e8b219384272", + "lean/snaky/FiniteCards/Height13Part02.lean": "ebdeec27330451c3a703529df37b510051185465fd0faf67be41782ffcdb6cb9", + "lean/snaky/FiniteCards/Height13Part03.lean": "1eae92ec890f11692c8e9ce4d0023baa52325791e610e99e2c0147c8b5c17b83", + "lean/snaky/FiniteCards/Height13Part04.lean": "735a6a5eb3808843c8ad6d83bf08e505e5d288049e37ac62f82e5728e21111ee", + "lean/snaky/FiniteCards/Height13Part05.lean": "092ce445abcc756b463e52e2fa357f37f975af3bd83138ce1ae3fdccdb966a53", + "lean/snaky/FiniteCards/Height13Part06.lean": "07d245a73ca81f362d6ce9cc88e6b9abdd47cb3224959088898b587bde9aba6d", + "lean/snaky/FiniteCards/Height13Part07.lean": "8322790eaea202f2b9017a7b23a6c26572157506b714e1bd43cffcffcc4bc171", + "lean/snaky/FiniteCards/Height14Part01.lean": "31bedc3edcd7f853fb99e951eca5257715a8338943aa4ed4419b40fe77c00967", + "lean/snaky/FiniteCards/Height14Part02.lean": "ba89a77b16358751cf9471c17fa3acfb2cb006fab5df75ed50a7d5e43ca17381", + "lean/snaky/FiniteCards/Height14Part03.lean": "0757d385cb3dd8416e9f16c0f17c55466d48155c8657405770256d451762c77b", + "lean/snaky/FiniteCards/Height14Part04.lean": "e17a8f7aa7b8d57f2be9d556cb894aeff05ef28b647a7bd52f5356d7ca7a8290", + "lean/snaky/FiniteCards/Height15Part01.lean": "29e6a73a81629ab9b121d22c4c5664835f2a5bc6eaae8426a4ba6d4cd944aa45", + "lean/snaky/FiniteCards/Height15Part02.lean": "9a5d3faaa804999caec3be6043cc4cb98396651ad742d6e4571bbf190667e0dc", + "lean/snaky/FiniteCards/Height15Part03.lean": "980212d37614d7c5ec333a94acd3dea988576baf5c92d7c6b183f647bda13c81", + "lean/snaky/FiniteCards/Height15Part04.lean": "a930353524d4c5c426526cb96c6900b21f765e7ab9001414675dddac91c722f1", + "lean/snaky/FiniteCards/Height16Part01.lean": "fabda38ff2d37b1a768e8607048d0a7b8343d416b3bfce96a2df3f82d6666911", + "lean/snaky/FiniteCards/Height16Part02.lean": "6746923d486a2220b87e1c7e8e6aa5243091d617bfdc9aab7f686715fe5054a6", + "lean/snaky/FiniteCards/Height16Part03.lean": "5842f9ed2a8cbb547ace0b8f18866a673e18cdbb2b55994718e519a541683fa1", + "lean/snaky/FiniteCards/Height17Part01.lean": "9656252931887c6cd9fd6256be35d9be673baeb46e544f88ca23f739b7af2a75", + "lean/snaky/FiniteCards/Height17Part02.lean": "aacbb495500616854cd8e7f7b1240261cfe13c19201a033fe8d56b1540c19c94", + "lean/snaky/FiniteCards/Height18Part01.lean": "9fd3e2424aa4fc06b73005f40bbcb6129e133de7ffc548669ab14f552c27bea3", + "lean/snaky/FiniteCards/Height18Part02.lean": "45141c8501b3011db96fc1ee9a5e3d3abadf161eab2bf24e30aa64594c34f114", + "lean/snaky/FiniteCards/Height19Part01.lean": "a0fce1dbbac2e34b740bec1ed593009770553d34a1b3311e0e80d54a87962ca9", + "lean/snaky/FiniteCards/Height20Part01.lean": "9bef588333dbffb781fab452f2b6fbe487532f13eb0d7a85e9af8f2577cad832", + "lean/snaky/FiniteCards/Height21Part01.lean": "5126d8214f7193a4421fa2a9968583721c5a929f7f206e04bbcb3454563b4f6e", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height01Part01.lean": "b721851d44936e696a7ca108bc258a9cff38340751b3d779e2cbbf8d8b5b5036", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part01.lean": "59d96363dfcfba2711d08567a0f536af7f4ec54cc777c823c78d4b5f6b905aa4", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height02Part02.lean": "0d57456db981f46183771645e5176837cf7d22bfddbb1a9ee2651bc0cfe900e4", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part01.lean": "09869ff7e389b199966af69e5e2b1b8c4a617656d6277698a8c96aa4b021a4b9", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part02.lean": "f229e04ff8b7d9176d39b26b24bfaa88b3f26d2710340db46e5b1b1d22144fc6", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height03Part03.lean": "1b9ddf7e48a2d55d51fc18ddc0f93bcb7b4dc048bd648d2d4e5a72d8bbdf17a3", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part01.lean": "f9e2556bf69c4f88311787cf0d663f0a24d2bfdd43762a6774f9133241b82b5b", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part02.lean": "b7371990d1a053b8dad99d5e3d0bdbfb4be5fc147d8ee5c7d886d89d4bc584e0", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part03.lean": "e80807a7f939ffebcdc234e68c234a3ac1c77e0571ee72c6aac569ff9f3e7b7d", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part04.lean": "93a6c395d391c2f2d73c0a6d6274c53904ed6a6b3e1f88a73781388ffdff6e34", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height04Part05.lean": "878e72c12b9e84fef33a3ea7d649574d08e19565c5560441d7d863117b89e8c3", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part01.lean": "e8bbd9bc6e87400a19e7a80e23eb2a0d3424199590ca3803befc6ecd6ee5a25a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part02.lean": "dd932253e77d2f7292d44782e4b6e37a8ff93c2df170a1340f27834c37894cc3", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part03.lean": "53b601dc52ccff754ccf70084ef44d606d93b41beaf2f7dd61cca127fa799933", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part04.lean": "dd7bf148b9ad98c1430be052ef1f6e9e437ee111a32166443790f15175506777", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part05.lean": "aea13ebf283c4d058d25ada4ed15cec3c3b0ce062b05769aecbac509d309dda5", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part06.lean": "649732e2efb25248b34b40715c91d769d5074fc03c89ba0a43065aa09ebf93f7", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height05Part07.lean": "ba0397ab80d2c5744520d4ea44eb6f857aabe35c7d1bfd787bbdd22f06269397", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part01.lean": "25631c997e43e5d2b93a65de3fa7b445be17232674796aba2572e7fea6f15852", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part02.lean": "c9676996ed11ffa3e24f78308318b2cd9100f36edca21633434ba629198ec813", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part03.lean": "9a6db2aec95eced43911499fbc2841ab1f831885bc087882be027b41b303a046", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part04.lean": "edb074c085baafc8a5dd469ff28d1650d0f51b99a0e46455f30a36a7996dbd7c", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part05.lean": "fb883f0172b0d7195cbc41290c6c2de9879221913ee699494f7179ed9fa5d162", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height06Part06.lean": "d16fbbc1233561d5fa5295174fce0c97805b32c8351374413c7038982392ea33", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part01.lean": "25cd3b6dfb5d18f99a0a9a3a50a5b54f0bf2bf600c942b1fc17cefb7fef79b12", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part02.lean": "11eb252c6d440ed9f51bb56e78af089e155bbe71c9a560a69fc12c331695b1bd", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part03.lean": "706d293c21868a010c5b8eda2cd1cfdbfdf9378e60e8053c190e15f29b8d034f", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part04.lean": "b6ada6198549c57e2c1780de45025ea71667386a45e1a7e551b437ed5fda6a47", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part05.lean": "8f0684cca8d7bc6258c368e7ad5d14f55972a411f64f26e7ccc6f3258a673acc", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height07Part06.lean": "243c2861da61125a2ae538143bd1016c70d888c90030174a43ba55f95f62e919", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part01.lean": "82c6d8311c44ad8d40aea9f0237156dad735197c0ae7986fd5c9169cd76eaf3b", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part02.lean": "78a39d42a9ce6b5ba0450598209571689a8ffd3ddecdf788c9080d2964b08694", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part03.lean": "a502d65803e3611d7df6e7933edb50a86a0f5d74ebfb134203864996c9a6efca", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part04.lean": "d383e19ead30aa84f8dfc1d91cba6bc899aea830b1bd8e75a71d535d8ac72753", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height08Part05.lean": "aac655834b86fccaf58a123116ef69a4503d0254e74bf3a5313e87169b7e03d7", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part01.lean": "eb041abc50134f6a894027720e1f5a72d210885e27e798fa25ecbd40cfcc7b8e", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part02.lean": "d70ef317bc9b10e88176c5299878b37fea8ff32ef13d2705dc5f2e11fe6cd744", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part03.lean": "51e58151811ea564c431a3354866283620e588e911873f91232e57dff26f5d2d", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part04.lean": "c67800b85780fbc0a017ac90bb69aa43474735fbcd36eae20230cb56bacdd792", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part05.lean": "a96acbd788ebbc4414d0e61a7d06e3a65d860c83f1db354511eda3543d4e9076", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part06.lean": "e483d02b0f566c62b17bd12614bce69f9589b9de4d93000c9305bc645c84dc82", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part07.lean": "c64b6fc7441de2c2d3b92daf23c7fdba4448d42589bc46f79ebfb7dae00209a8", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height09Part08.lean": "0d711b1ba2d8f0caf5e6188100216e78d3fb76ebfd63d7e8935d70a4f779681e", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part01.lean": "d8a501150730c5868dc1e87fa4e8f691df984e817b9b87fb454e9b86d12ebaf6", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part02.lean": "47128473825a65bb8a7c6edf869345edb33197e1b08b64452f7413b0b258ca5a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part03.lean": "90591ceddfdfb8a7109f4ec3ba1feac0c777d4aa8f98ef448a2081be2907c335", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part04.lean": "995aeb639e7a2ea3fc12b19382d26465d447e8fbfd12bfa275931f3dd05b3416", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part05.lean": "adbd7834740f2e09d435c743cb00ad078165321a388e86d7f0e4a07593e22846", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part06.lean": "941557ad54a116a5c5353f3abb2d347e995a301ed6d3fb9dd482ddae01c73a7d", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height10Part07.lean": "16bb244088a706cb45bba2c479a60c1ee525d46ab52069c5e27018251c199c6a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part01.lean": "2afe7b6b6d805fec07aef8b1560f7c7c10f5ee1ea2e60131cd2991c132a14425", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part02.lean": "6052574dc2afcc7933532c978ae9f50104b000d3f9e7d23bde74c7a984aafd33", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part03.lean": "c955d181f3d7e17739df4ce36a8e306f067e7ecd47dad1e301a603fbaeccbd24", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part04.lean": "3e15ffd5811c739975a3cccd95bd44abe635f97b9baaed944841b751365afd22", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part05.lean": "75f02f38d91fec7e334a0aa89450a0c27b728be98221d7559964ae0eb0e811e0", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height11Part06.lean": "744342de6ed465e062d443e918dcbf298636856e35958cc7afa32f827dde6da1", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part01.lean": "98ada75cffa280d9bfe02e5510507cdb7a425d326652119fd676e2a612b7de98", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part02.lean": "92978a0d11d3c74f49f2fed81eb75f7296610af3a4c4cd890f0b695009d9bb63", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part03.lean": "9caf9a13e979d827a4c0d74deca5f32c54f4b85c2e7d87ffde7015f02e82e0fb", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part04.lean": "45ab2b20c2db4517ef9db6d8c10849f623b78b4e0e90ed33532f2c456c47646a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height12Part05.lean": "844faee78ca99c9bf2644389ae17459584ed4bd76b1183b44407ea336a001e00", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part01.lean": "c7d05c2ae8c69a2b0d985c2e18edeab63af7e03276ecf47ed80768f730f43cec", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part02.lean": "98283cc58c87f7dbd87cb88ff0ba4b897e7683cafee56c1341610fc81f9a4c55", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part03.lean": "4e604e82c10e2d76f1b2c9a39d96f2f7472c0a8d3fc5f3c109668ba193d1bfa5", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part04.lean": "c6eb8cd09091be55e2bd853d8d0a02c6f3b01e56cf187831d866fe7c72481d16", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part05.lean": "f13ea4353c6cda2dbf684a2734e92f5064822170665155699c5113771be3f3a3", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part06.lean": "b4eb63c7fefeb0a5da6d8a047be13a9bb988a0abc0fa0b2e8e090e7952c2b3a4", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height13Part07.lean": "608570161b4a67b15a575d09664f5032ae854a881950cf6a98e9cf7c972138ca", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part01.lean": "cdcae9363b98149cce6a8a6d95b255bbb928b19226ad53a0efbe0283de9a2f68", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part02.lean": "536089a57e85902db6c1d5b125a4346fc8669ae9aba55099faba30ed1bbbc78a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part03.lean": "78867488bf9599a41719f74e42c34d5bd21047308382079ba3b59b408d5120a3", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height14Part04.lean": "ce1b0fa24cc8ed5050692cc200401c05f27c80ec295e2337cf687055efe7a751", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part01.lean": "95030470ead192c47b9115eed23c003978646393f5ca4f6257a0a1dde0ba7195", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part02.lean": "8d849760c2d74d70cf77c7ccbceca941ebe3fdf867f86afd13911f8e5b194ca2", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part03.lean": "d859675955b216884012b25c82b2c86f0ee159ed7d8fd51320fac584339946ac", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height15Part04.lean": "03498c2351fbd34ae0d95e0e971856f79593df844fc0190a7a0c921cd951da52", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part01.lean": "486549710154751edc1a3b719d1780e0b7bf0aa2955b7d3961e7f4a251ed7248", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part02.lean": "03dfedd9067aaf0644c6d76d75b470141dfd6eb48495eed2c9d3b7bc0a49aed7", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height16Part03.lean": "a9b209921b6691c59d893c8d58eaab64f359707778b8785da65959491164610c", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part01.lean": "060e3a5d9d3b5123433eb50d186c38679892e6663a7c1405ae21c77bc001e862", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height17Part02.lean": "4bd93d460827cf7c577fa113136abd40a53f5a8da1c6cd31f945ddd38d7c24ea", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part01.lean": "154698a2eafd7ab3118236a2f7c772c1b2057846780457f55f074703c267765b", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height18Part02.lean": "fc1ea2edfb94e051c937f84b1add1adc18fd106fcc5e2bf8a60ba5b26328acc9", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height19Part01.lean": "59c407a3ab501823540cf7732c8a9589ecb1a87a73af2776abdfa06c6da30bbb", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height20Part01.lean": "579f5ac435486638f55cba08fe32d2762291d7d3eecd2f54056f491e396fb6c1", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Cards/Height21Part01.lean": "4f89721d3d39ac9e4e253edc1cbe367f5a4b7db7a15d6241e28951899fa32845", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Certificate/Operations.lean": "e69c168bfdf68f10052ceb9963a4013ddf536bd15ac79f5522fe932e82364a03", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Certificate/Summary.lean": "93ec0b599d3ed2628af92fe631dcf1c185fa0a44c3a532cf3c9179edfe1c9f87", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Main.lean": "a62fa55a65fd74a1bb9a06509a668feba17a0ce589586e72ffee0c6d83134e28", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Model.lean": "e2b6365603299d20d407519c365561f330d03af3e579c0042f19cdc2657df8b0", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Game.lean": "1d20aa7e7c30c525e6daf2a0145668bbd50b42386e2f4523a96fa982b295730a", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Geometry.lean": "0d07595a7c774d1a7c6954f2241d32635457f84500ab32016f55a48e563655db", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Policy.lean": "c5feb030221603a62c91caaff754700b20da2c519a5bc05cf797f2dcd79598e5", + "lean/snaky/OAI/GameTheory/SnakyTwentyOne/Semantics/Replies.lean": "b7571f5cce7fa672f93e00a74b2cd5d5a1f8d694f4ba791a9d421e27bf3c56b2", + "lean/snaky/SnakyBinding.lean": "c2067bfff6b6a25ce5dc3c6f5d42973943d19f1587954d627e3e774e9b261f8b", + "lean/snaky/SnakyFinite.lean": "4481d384a4f7920d98088bd2cc10796d330e5ae9da11aeff718e0d949c27d3ff", + "lean/snaky/SnakySemantics.lean": "eed7dee5c079df33d8488018119dfdb48d8bc1bc6aeb70e6a23f679135e52f2b", + "lean/snaky/UPSTREAM_LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "lean/snaky/UPSTREAM_NOTICE.md": "1d9cac3fb50ac6ab0ec3000c11486056141aa51e6371e08503512843aa4bcab6", + "lean/snaky/generate_finite_cards.py": "475e39c9415fedb0afd237cc19a83fe3f267120aeea2ea34ee5f69009212ab2c", + "lean/snaky/lake-manifest.json": "5dda7eda39168cec70584a4b94d61681a7838d3daf43d093f31f4c4aaddf8e68", + "lean/snaky/lakefile.toml": "fcd7faca2253f2e936e294694c5d691b1ff43e8a168a9bf3f283e6570060acad", + "lean/snaky/lean-toolchain": "d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b", + "lean/snaky/vendor-manifest.json": "ca09b16a386355c5aa5a46c91fa87b6979cfc809ddc01b55743d6199e6e63c22", + "scripts/build_snaky_play.py": "77b0701590f0bd022240db0ca93bf46acc931024475454de143fc99c5bbafeac", + "scripts/check_snaky.py": "39557ec80096081efac4f5f8f0182383a4d23af855bb652a8108fa4228ee2d42", + "scripts/check_snaky_play.py": "1d9cd05e8865fbf1965f8948e6369f2b9011ae48e9658e1404313161ac08e1ae", + "scripts/snaky_proof.py": "d07a9623b0e18ad2c68d51dc4d08115adbe4f37f5664456aa90ce1799591fdb5" + } +}